1.使用Ajax的好处：
能够经过JavaScript发送请求到服务器，并或得返回的结果，在必要的时候须要更新页面的一部分，而不要整个页面都刷新，也称为：“无刷新”技术 提供连续的用户体验，而不被刷新中断html
2.什么是Ajax
它是Asynchronous(异步的)，JavaScript And Xml的简写；java
3.Ajax的工做原理：
1. 首先向服务器发送一个异步请求(在Action中建立相应的方法---)
2. 建立 实例,设置回调函数
3. 初始化XmlHttpRequest实例,发送请求
4. XmlHttpRequest实例.send(null)
5. 对状态进行判段
6. 读取xml文件获取文本值web
4. hibernate实现的原理？(Hibernate的目标:是用来保存数据(持久化数据))
1，读取并解析配置文件；
2, 读取并解析映射信息，建立sessionFactory;
3，打开session；
4, 建立事务transation；
5, 持久化操做；
6. 提交事物commit;
7, 操做失败rollback;
8，关闭session;
5. hibernate 的优势和缺点?
1. 对JDBC访问数据库的代码作了封装，大大简化 了数据访问层繁琐的重复性代码。 spring
2. Hibernate是一个基于JDBC的主流持久化框架 ，是一个优秀的ORM实现。他很大程度的简化DAO 层的编码 工做 数据库
3. hibernate使用Java反射机制，而不是字节码 加强程序来实现透明性。 编程
4. hibernate的性能很是好，由于它是个轻量级 框架。映射的灵活性很出色。它支持各 种关系数据库，从一对一到多对多的各 种复杂关系。
缺点:限制了实体对象，一个实体对象不能映射成 多个表
2. 不能对数据库操做进行优化
3. 不适用于对数据的批量操做
4. 不适用于对象关系不明确的操做设计模式
6． Struts工做机制？为何要使用Struts？
工做机制：
在web应用启动时就会加载初始化ActionServlet,ActionServlet从struts-config.xml文件中读取配置信息,把它们存放到各类配置对象,当 ActionServlet接收到一个客户请求时,
将执行以下流程.
-(1)检索和用户请求匹配的ActionMapping实例,若是不存在,就返回请求路径无效信息;
-(2)若是ActionForm实例不存在,就建立一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;
-(3)根据配置信息决定是否须要表单验证.若是须要验证,就调用ActionForm的validate()方法;
-(4)若是ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功;
-(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪一个Action,若是相应的Action实例不存在,就先建立这个实 例,而后调用Action的execute()方法;
-(6)Action的execute()方法返回一个ActionForward对象,ActionServlet再把客户请求转发给 ActionForward对象指向的JSP组件;
-(7)ActionForward对象指向JSP组件生成动态网页,返回给客户; 数组
8.为何要用：
JSP、Servlet、JavaBean技术的出现给咱们构建强大的企业应用系统提供了可能。但用这些技术构建的系统很是的繁乱，因此在此之上，咱们须要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。
基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件 浏览器
6.Spring的部署环境？(目标：与业务相关(处理业务数据))
一、spring依赖库
* SPRING_HOME/dist/spring.jar
* SPRING_HOME/lib/jakarta-commons/commons-logging.jar
* SPRING_HOME/lib/log4j/log4j-1.2.14.jar
--->拷贝spring，log4j配置文件到src下
--> 在业务层的实现类中提供构造函数或setter方法，spring将实例化好的持久层实现注入给咱们
让spring管理咱们的对象建立和依赖，必须在spring配置中进行定义 --->编写客户端
缓存
7.什么是框架?
框架是提供可重用的公共结构的一个半成品，它集成了优秀的程序架构和前人的经验总结，使用框架能够帮助咱们更快写出优秀，结构统一的程序；
8.struts中的标签：
1.使用html标签"绑定"数据；
使用过html标签进行页面编码；
2.使用logic标签实现判断逻辑
使用logic:notEmpty判断Bean值是否存在或非空
使用logic:equal判断Bean值是否相等
使用logic:iterate显示列表数据（负责集合数据的循环处理）
3.使用bean对Bean值进行相关处理
使用bean:write格式化输出(支持对数字和日期格式化)
使用bean:define定义页面变量 能够简化取出Bean再定义为脚本 变量的过程和新的Bean
使用bean:size获得集合数据记录数，它不会输出任何内容，只是取得值，并从新定义，方便其余标签或EL表达式应用，最终采用bean:write标签或EL表达式输出
9.Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现 同时是一个“对象-关系映射”框架，它能很大
程度地简化DAO层编码工做
10.为何使用HQL?
HQL是Hibernate提供的一种面向对象的查询语言，支持：属性查询、参数查询、关联查询、分页查询、统计函数 使用它避免使用JDBC查询的一些弊端，不要再些繁琐的SQl语句
咱们只要针对实体类及其属性进行查询，查询的结果直接放到List中的对象，不须要再次封装，对不一样的数据库根 据方言自动生成不一样的SQl语句
步骤：获得Session， 编写HQL语句 ，建立Query对象(封装了设置参数，执行查询，设置返回数据的开始位置和 总的返回条数 )， 执行查询，获得结果
11.为何使用Criteria查询？
Criteria查处(又称为对象查询) 采用面向对象的方式(主要是Criteria对象)封装查询条件，并提供Restrictions等类别 作辅助，能够是编写查询代码更方便
步骤 ：获得Session， 建立Criteria对象（须要传入对应实体类的类型对象） ，使用Restrictions对象的静态方法构造查询条件并添加进Criteria对象中；
12. 使用Spring好处？
充当了粘合剂和润滑剂的角色，它对Struts，Hibernate等技术都提供了良好的支持，可以把现有的java系统柔顺的
整合起来，同时自身还提供了声明式事物等企业开发不可或缺的功能
13.什么是依赖注入？
就是明确的定义组建接口，独立开发各个组建，而后根据组件间的依赖关系组装运行的设计开发模式
14.什么是AOP
从系统中分离出方面，而后集中实现，从而能够编写业务逻辑代码和方面代码，在系统运行的时候再将方面代码 “织入”到系统中
15. Hibernate工做原理及为何要用？
原理：
1.读取并解析配置文件
2.读取并解析映射信息，建立SessionFactory
3.打开Sesssion
4.建立事务Transation
5.持久化操做
6.提交事务
7.关闭Session
8.关闭SesstionFactory
16.为何要用：
1. 对JDBC访问数据库的代码作了封装，大大简 化了数据访问层繁琐的重复性代码。
2. Hibernate是一个基于JDBC的主流持久化框架 ，是一个优秀的ORM实现。他很大程度的简化DAO 层的编码工做
3. hibernate使用Java反射机制，而不是字节码 加强程序来实现透明性。
4. hibernate的性能很是好，由于它是个轻量级 框架。映射的灵活性很出色。它支持各类关系数据 库，从一对一到多对 多的各类复杂关系。
17． Hibernate是如何延迟加载?
1. Hibernate2延迟加载实现：a)实体对象 b)集合 （Collection）
2. Hibernate3 提供了属性的延迟加载功能
当Hibernate在查询数据的时候，数据并无存在 与内存中，当程序真正对数据的操做时，对象才存 在与内存中，就实现 了延迟加载，他节省了服务器 的内存开销，从而提升了服务器的性能。
18．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)
类与类之间的关系主要体如今表与表之间的关系进行操做，它们都市对对象进行操做，咱们程序中把全部的表与类都映射在一块儿， 它们经过配 置文件中的many-to-one、one-to-many、many-to-many、
优缺点： 1. 对JDBC访问数据库的代码作了封装，大大简化了数据访问层繁琐的重复性代码。
2. Hibernate是一个基于JDBC的主流 持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工做 V
3. hibernate使用Java反射机制，而不是字节码加强程序来实现透明性。
4. hibernate的性能很是好，由于它是个轻量级框架。映射的灵活性很出色。它支持各类关系数据库，从一对一到多对多的各类复 杂关系。
缺点：
一个实体不能映射成多个表
不能对数据库操做进行优化
不适用于对数据进行批量操做
4． 说下Hibernate的缓存机制
1. 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存
2. 二级缓存：
a) 应用及缓存
b) 分布式缓存
条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非关键数据
c) 第三方缓存的实现
5． Hibernate的查询方式
Sql、Criteria,object comptosition
Hql：
一、 属性查询
二、 参数查询、命名参数查询
三、 关联查询
四、 分页查询
五、 统计函数
6． 如何优化Hibernate？
1.使用双向一对多关联，不使用单向一对多
2.灵活使用单向一对多关联
3.不用一对一，用多对一取代
4.配置对象缓存，不使用集合缓存
5.一对多集合使用Bag,多对多集合使用Set
6. 继承类使用显式多态
7. 表字段要少，表关联不要怕多，有二级缓存撑腰
7． Struts工做机制？为何要使用Struts？
工做机制：
Struts的工做流程:
在web应用启动时就会加载初始化ActionServlet,ActionServlet从
struts-config.xml文件中读取配置信息,把它们存放到各类配置对象
当ActionServlet接收到一个客户请求时,将执行以下流程.
-(1)检索和用户请求匹配的ActionMapping实例,若是不存在,就返回请求路径无效信息;
-(2)若是ActionForm实例不存在,就建立一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;
-(3)根据配置信息决定是否须要表单验证.若是须要验证,就调用ActionForm的validate()方法;
-(4)若是ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功;
-(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪一个Action,若是相应的 Action实例不存在,就先建立这个实例,而后调用Action的execute()方法;
-(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给 ActionForward对象指向的JSP组件;
-(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;
为何要用：
JSP、Servlet、JavaBean技术的出现给咱们构建强大的企业应用系统提供了可能。但用这些技术构建的系统很是的繁乱，因此在此之上，咱们须要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。
基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件
8． Struts的validate框架是如何验证的？
在struts配置文件中配置具体的错误提示，再在FormBean中的validate()方法具体调用。
9． 说下Struts的设计模式
MVC模式: web应用程序启动时就会加载并初始化ActionServler。用户提交表单时，一个配置好的ActionForm对象被建立，并被填入表单相应的数据，ActionServler根据Struts-config.xml文件配置好的设置决定是否须要表单验证，若是须要就调用ActionForm的Validate（）验证后选择将请求发送到哪一个Action，若是Action不存在，ActionServlet会先建立这个对象，而后调用Action的execute（）方法。Execute（）从ActionForm对象中获取数据，完成业务逻辑，返回一个ActionForward对象，ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动态的网页，返回给客户。
10． spring工做机制及为何要用?
1.spring mvc请全部的请求都提交给DispatcherServlet,它会委托应用系统的其余模块负责负责对请求进行真正的处理工做。
2.DispatcherServlet查询一个或多个HandlerMapping,找处处理请求的Controller.
3.DispatcherServlet请请求提交到目标Controller
4.Controller进行业务逻辑处理后，会返回一个ModelAndView
5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象
6.视图对象负责渲染返回给客户端。
11.为何用：
{AOP 让开发人员能够建立非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务 （比 如日志、持久性、事务等）就能够分解成方面并应用到域对象上，同时不会增长域对象的对象模型的复杂性。
IOC 容许建立一个能够构造对象的应用环境，而后向这些对象传递它们的协做对象。正如单词 倒置 所代表的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每个对象都是用其协做对象构造的。所以是由容器管理协做对象（collaborator）。
Spring即便一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协做对象）。而后能够很容易地在须要时替换具备相似接口的协做对象。}
ssh----------->
11. 经常使用的Struts标签.迭代是用什么标签
<logic:iterate>
1.方法中定义的变量？
*不能有访问修饰符;
*必须赋初始值;
*修饰符为final的表示变量的生命
周期与实例同样，且在方法体中不能改变它的值，
不然方法调用完就就销毁；
2.final?
*final修饰的类不能有子类;
*final修饰的方法在子类中不能重写;
*类中的成员属性用final修饰必须赋初始值;
3.方法的说明符
*方法的访问说明符：
public
protected(不加访问说明符时)
default
private
*方法的其它修饰符
static
final
abstract
native
synchronized
4.内部类（当一个类继承的父类，与实现的接口中有相同的方法和成员属性时）
*能够定义在方法中，语句中，类中；
*static内部类只能访问外部类中的static成员属性,成员方法；
*内部类访问外部类中的成员属性，要加： 外部类的名称 + this + 成员属性;
*内部类要能访问方法中定义的变量(注意方法中定义的变量必定要赋初始值)，
则方法中定义的变量前要加final(final,为常量定义，改变了变量的生命周期);
*内部类中有一个默认的成员属性，
名称为:外部类的名称.this,引用外部类的实例；
得到内部类的实例：
1.在外部类中定义方法,该方法的返回值类型内部类；
2.经过外部类的实例.new 内部类(),就能够获得内部类的实例;
5.集合：
List,set,Map;
set中的数据不能重复，list中装的数据能够重复;
集合中装的数据只能为对象类型，
且在集合中的值为对象的引用；
List,set的父类是Collection;
Collection与Collections区别；
Collections该类中有不少的静态方法，用来操做集合；
例子：
List<Integer> ll = new ArrayList<Integer>();
ll.add(5);
ll.add(4);
ll.add(3);
System.out.println(ll.get(0));//5
Collections.sort(ll);
System.out.println(ll.get(0));//3
Collection 是list,set的父类;
集合的长度是size();
字符串的长度：length();
数组的长度为length;
NodeList的长度为getLength();
如何把数据增长到集合中去:
list.add();
set.add();
map.put(键，值);
如何把值从list,set,map中取出来:
1.list能够用get(),也能够把其转化为iterator,再取值;
2.set能够Iterator;
3.map先把它的键转化为set,
再itertor遍历set,获得键,由map.get()能够获得值;
6.线程的程序：
*运行main方法，jre开启一个后台线程；
a.Thread.currentThread().getName()
得到的当前运行该程序的线程的名称;
b.单线程的程序：第一条语句执行完后，
再执行第二条语句；
............等
c.
*线程的定义：
第一种方式：
a.类名 extends Thread
重写run()方法；
*如何开启线程
Thread的实例.start();
一个Thread的实例对应一个线程;
不是调用Thread的实例的一次start()方法，
就开启一个线程;
*后台线程：
Thread的实例.start()是前台线程；
前台变为后台：
Thread tt =new TestThread();
tt.setDaemon(true);
若是全部线程都为后台，则程序会自动退出；
若是后台线程已运行完，前台线程还会继续执行；
*线程的优先级：
*线程同步(synchronized)：
同步代码块：
从新在类中定义一个成员属性，
用来作线程同步的监视器变量；
同步方法：
监视器变量为（this）:
当线程执行到同步方法时，
jre虚拟机立刻在this所对应的方法上锁定，
其余线程不能调用该同步方法；
7.servlet的生命周期:
每调用一次servlet的url，
是否是产生一个新的servlet实例?
servlet的生命周期：
实例化:
init:
service:
destory:
servlet的实例化的方式：
1.调用的时候，如表单,RequestDispatcher.forword();
2.在web容器启动的时候：
在<servlet>元素中增长一个子元素：
<load-on-startup>1</load-on-startup>
load-on-startup的文本节点的值大于等于零,
则在web容器启动的时候，实例化servlet的实例；
小于零，则不实例化；
如有多个servlet，配置了<load-on-startup>
且他们的值不同，值越小，容器先实例化；
他们的值同样，则在web.xml文件中,越在后面的先实例化
3. init只执行一次；
8.servlet的路劲问题：
./ : 表示当前的路径；
../ ：表示回到上一级路径；
以上路径以当前页面为基准点，再定义到其它页面；
request.getScheme()的值为：http
request.getServerName()的值为:主机的ip地址或主机机器的名称；
request.getServerPort()的值为:端口号；
request.getContextPath()的值为:/ + 站点名；
另外一种方式：
以站点名为统一的基准点，
使用该种方式：必须在head中增长如下：
<base href="<%=basePath%>">
basePath:
<%
String path = request.getContextPath();
String basePath = request.getScheme() + "://"
+ request.getServerName() + ":" + request.getServerPort()
+ path + "/";
%>
页面转化：
RequestDispatcher disaptcher =request.getRequestDispatcher("ServletTest2");
//disaptcher.include(request, response);该为页面包含；
disaptcher.forward(request, response);
url的地址不变，同用同一个request对象；
页面重定向：
response.sendRedirect("ServletTest2");
url的地址变，不一样用同一个request对象；
9.cookie:
*服务器能够向客户端写内容；
*只能是文本内容；
*客户端能够阻止服务器写入；
*只能拿本身的webapp写入的东西；
*以‘名--值’对的形式出现；
*.Cookie分为两种
属于窗口/子窗口
属于文本
*一个servlet/jsp设置的Cookie可以被
同一个路径下面或者子路径下面的servlet/jsp读到
(路径=url,路径!=真实的路径)
*可使用Cookie的setXXX()方法来设定一些相应的值
a.setName(String name) /getName();
b.setValue(String value)/getValue();
c.setMaxAge(int age)/getMaxAge();
d.利用HttpServletResponse的addCookie(Cookie cookie)方法将它设置到客户端，
e.利用HttpServletRequest的getCookie()方法来读取客户端的全部Cookie,返回一个Cookie数组；
*设置cookie:
见程序：SetCookies.java
*读取Cookie
见程序：ShowCookies.java
* 设置了生命周期的cookie才能写入浏览器的cookie中;
10.Session的实现机制：
*经过Cookie实现；
若是浏览器支持Cookie，建立Session的时候会把SessionId保存在Cookie中；
向服务器发送第一次请求的时候，
a.服务器立刻产生一个Session，放在在服务器中;
b.把session的sessionId放在brower的cookie中；
c.以后在调用jsp或servlet的doGet()或doPost()方法，
同时把表单中的值及sessionId一块儿传给服务器；
*经过url实现；
若是不支持Cookie,必须本身编程使用URL重写的方式实现Session,
Jsp中： response.encodeURL("url");
servlet中：response.sendRedirect(
response.encodeRedirectURL("uri"));
转码;
URL后面加入SessionId;
*Session不象Cookie拥有路径访问的问题
同一个application下的servlet/jsp能够共享同一个Session，前提是同一个客户端窗口
*Session在用户第一贯服务器产生的 ,
为了跟踪当前用户；
每打开一个浏览器客户端窗口,输入url,发送请求，
就会产生一个Session实例；
11. 如何把map中装的值转化为成员属性所对应的数据类型；
a.经过得到成员属性的数据类型，
用相应的if语句进行转换：
b.转化器：
参数说明：
1. Class class1：要转化到数据类型
2. Object obj：要转化其余数据类型的值
public abstract Object convert(Class class1, Object obj)
12.怎样建立监听器：(监听器类在容器一启动的时候就进行实例化)
import javax.servlet.http.HttpSessionListener;
public SessionListener(){
System.out.println("---> session is constr");
}
public class SessionListener implements HttpSessionListener{
public void sessionCreate(){
htrtpsessionevet.getSession();
System.out.println("---> session is Create");
}
}
13.怎样实现线程安全？
*<第一种方案>
用监听器
*<第二种方案>
把applicationContext做为类的成员属性要注意线程安全问题
struts 的action的成员属性则必须有
spring容器来钞，且 <bean>的属性必须为name ,且要把scope="prototype" ，所请求必须有代理类来抄
*<第三种方案>
本身作回调类，从上下文取得ioc容器实列
14.类的说明符：
类的访问说明符
public
default(不加访问说明符时):
a.类的名称能够与类的文件名称不同；
b.java 加类名；
c.类名第一字母要打写；
d.public 类型的类必须与文件名同样;
类的其它修饰符
final
abstract
15.jsp隐试对象？
request :表示HttpServletRequest对象。它包含了有关浏览器请求的信息，而且提供了几个用于获取cookie, header, 和session数据的有用的方法。
response :表示HttpServletResponse对象，并提供了几个用于设置送回 浏览器的响应的方法（如cookies,头信息等）
out :对象是javax.jsp.JspWriter的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。
pageContext :表示一个javax.servlet.jsp.PageContext对象。它是用于方便存取各类范围的名字空间、servlet相关的对象的API，而且包装了通用的servlet相关功能的方法。
session :表示一个请求的javax.servlet.http.HttpSession对象。Session能够存贮用户的状态信息
applicaton :表示一个javax.servle.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息
config :表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。
page :表示从该页面产生的一个servlet实例
16.el表达式 隐式对象： 获取getAttribute(String name)属性的值
a. pageContext
能够访问ServletContext, Request, Response 和 Session 等对象
${pageContext.ServletContext.serverInfo}
${pageContext. Request.requestURL}
${pageContext.Response.characterEncoding}
${pageContext.session.creationTime}
b. pageScope:
类型是java.util.Map , 将页面范围内的属性名和它的值进行映射.主要用于获取页面范围内的属性的值. ${pageScope.user}
c. requestScope: --- HttpServletRequest
类型是java.util.Map , 将请求范围内的属性名和它的值进行映射.主要用于获
请求范围内的属性值. ${requestScope.user.age}
d. sessionScope --- HttpSession
类型是java.util.Map , 将会话范围内的属性名和它的值进行映射.主要用于获
会话范围内的属性的值. ${sessionScope.user.education}
e. applicationScope: --- ServletContext
类型是java.util.Map , 将应用程序范围内的属性名和它的值进行映射.主要用于获取应用程序范围内的属性的值. ${applicationScope.user.education}
f. param ---- getParameter( String name)
类型是java.util.Map , 将请求中的参数的名字和单个参数值进行映射.主要用于获取请求的参数值(表单中的值和请求地址的值). ${ param.name }
g. paramValues ---- getParameterValues(String name)
类型是java.util.Map , 将请求中的参数的名字和该参数全部对应的值进行映射.主要用于获取请求的参数值.(表单中同名元素的值: 单选按纽, 复选按纽的值) ${ paramValues.sex } 等同于 ServletRequest.getParameterValues(String name);
h. header: --- ServletRequest.getHeader(String name)
类型是java.util.Map, 主要用于请求报头的值 ServletRequest.getHeader(String name)
${header[“User-Agent”]} 这里只能用”[]” 不能用 “.”
i. headerValues --- ServletRequests(String name)
类型是java.util.Map, 主要用于请求报头的值ServletRequest.getHeaders(String name) ${header[“User-Agent”]} 这里只能用”[]” 不能用 “.”
j. cookie
类型是java.util.Map, 主要用于获取Cookie对象, 等同HttpServletRequest.getCookie() 从返回的Cookie数组中找到匹配名字的第一
个Cookie对象 ${cookie.userinfo.name}
k. initParam.
类型是 java.util.Map 主要用于获取Web应用程序初始化参数的值,等价于
ServletContext.getInitParameter(String name), 在web.xml 文件中, 使用 <context-param>元素配置了一个driver参数
12. Struts是否线程安全的,不是怎么处理使它安全.
不安全.
解决方法:
1. 采用单线程方式
在JSP文件中加上,使它以单线程方式执行,这时仍然只有一个实例,全部客户端的请求以串行方式执行.这样会下降系统的性能.
2. 对函数加synchronized进行线程同步,JSP仍然以多线程方式执行,可是也会下降系统性能.
3. 采用局部变量代替实例变量
13. Struts中文乱码怎么处理
一、 全部HTML/JSP页面所有采用UTF-8编码
二、 客户端浏览器彻底支持UTF-8编码
14. Hibernate最常遇到一种异常
是空指针(ObjectNotFoundException).
15. Hibernate session 的 get()和load()有什么区别
1. 若是未能发现符合条件的记录，get方法返回null，而load方法会抛出一个ObjectNotFoundException
2. Load方法可返回实体的代理类实例，而get方法永远直接返回实体类.
3. load方法能够充分利用内部缓存和二级缓存中的现有数据，而get方法则仅仅在内部缓存中进行数据查找，如没有发现对应数据，将越过二级缓存，直接调用SQL完成数据读取。
16. Hibernate延长加载
1. 实体对象的延迟加载
在set中指定lazy=true
这样只有实际加载与对象相关联的集合对象的时候，再经过session从数据库中加载实际的数据集
2. 属性延迟加载
在property节点中声明lazy=true,并且还须要借助Hibernate类加强器对POJO类的二进制Class文件进行强化处理.
17. Hibernate中事务怎么处理
Hibernate有三种事务
1. JDBC 2. JTA事务 3. CMT事务
在这三种事务中，JDBC事务是默认的。这就意味着若是未设置hibernate.properties文件中的hibernate.transaction_factory的键值，beginTransaction将返回一个JDBC事务。
虽然一个会话中能够包含多个事务，但并不须要人为地对这些事务进行分割，而是由会话中的一些方法对多个事务进行管理的。下面将详细描述这些方法：
commit()方法是结束事务的两个方法。在这方法在内部调用了会话对象的save()方法。当调用这个方法时，若是这个事务已经被初始化，那么这个事务将成功提交。
18. 说说Spring AOP和IOC
AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面编程,面向切面编程(事物和权限管理造成一个切面，至关于一个过滤器(把共有的信息放到里面来)调用方法时就要先通过这个切面，什么是切点，什么时切面？) AOP很是适合开发J2EE容器服务器.
IoC就是Inversion of Control，控制反转。在Java开发中，IoC意味着将你设计好的类交给系统去控制，而不是在你的类内部控制。这称为控制反转. 管理对象依赖注入
19.struts和Spring是怎么的继承 每一个控制那一个IOC实例 每一个表对应一控制 方法：本身重写ContextLoaderLIstener方法，在Web容器中配置，一开启的时候就调用方法 重写XMlWebApplicationContext将配置文件放到上下文中；20.注入SessionFactory的时候？ 注入的是：LocalSessionFactoryBean类型的，而咱们须要的是SessionFactory类型的(成员属性或子类不一样) 解决的缘由：由于实现了FacotryBean接口 要实现接口中山个方法： 在spring配置文件中配置 <bean class="包名+类名" id="localsessionfactorybean" > </bean> 经过ApplicationContext app= new ClassPathxmlApplicationcontext("配置文件的Id值"); FactoryBean放回的类型要看getObject()此方法是重写父类中的）放回的值 IOC造对象的范围： 有五种：Request,session,prototype,singleon,globalsession struts1.x的缺陷？ 1.它是一个轻量级的框架 2.值提供整个表单提交，不能当数据提交 3.页面是能是jsp页面hibernate是怎么实现延时加载的？ 在web容器中配置一个过滤器org.springframewrok.orm.hibernate3.support.OpenSessionInViewFilter <filter> <filter-name>opensession</filter-name> <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class> </filter>