1.使用Ajax的好处:
可以通过JavaScript发送请求到服务器,并或得返回的结果,在必要的时候需要更新页面的一部分,而不要整个页面都刷新,也称为:“无刷新”技术 提供连续的用户体验,而不被刷新中断
2.什么是Ajax
它是Asynchronous(异步的),JavaScript And Xml的简写;
3.Ajax的工作原理:
1. 首先向服务器发送一个异步请求(在Action中创建相应的方法---)
2. 创建 实例,设置回调函数
3. 初始化XmlHttpRequest实例,发送请求
4. XmlHttpRequest实例.send(null)
5. 对状态进行判段
6. 读取xml文件获取文本值
4. hibernate实现的原理?(Hibernate的目标:是用来保存数据(持久化数据))
1,读取并解析配置文件;
2, 读取并解析映射信息,创建sessionFactory;
3,打开session;
4, 创建事务transation;
5, 持久化操作;
6. 提交事物commit;
7, 操作失败rollback;
8,关闭session;
5. hibernate 的优点和缺点?
1. 对JDBC访问数据库的代码做了封装,大大简化 了数据访问层繁琐的重复性代码。
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的部署环境?(目标:与业务相关(处理业务数据))
1、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:
1、 属性查询
2、 参数查询、命名参数查询
3、 关联查询
4、 分页查询
5、 统计函数
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中文乱码怎么处理
1、 所有HTML/JSP页面全部采用UTF-8编码
2、 客户端浏览器完全支持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>