标签：
1、谈谈你对Struts的理解?
答:
1. Struts是一个按MVC模式设计的Web层框架，其实它就是一个大大的Servlet，这个Servlet名为ActionServlet，或是ActionServlet的子类。我们可以在web.xml文件中将符合某种特征的所有请求交给这个Servlet处理，这个Servlet再参照一个配置文件（通常为/WEB-INF/classes/struts.xml）将各个请求分别分配给不同的action去处理。
一个扩展知识点：Struts的配置文件可以有多个，可以按模块配置各自的配置文件，这样可以防止配置文件的过度膨胀；
2. ActionServlet把请求交给action去处理之前，会将请求参数封装成一个formbean对象（就是一个Java类，这个类中的每个属性对应一个请求参数），封装成一个什么样的formbean对象呢？看配置文件。
3.要说明的是， ActionServlet把formbean对象传递给action的execute方法之前，可能会调用formbean的validate方法进行校验，只有校验通过后才将这个formbean对象传递给action的execute方法，否则，它将返回一个错误页面，这个错误页面由input属性指定，（看配置文件）作者为什么将这里命名为input属性，而不是error属性，我们后面结合实际的运行效果进行分析。
4.action执行完后要返回显示的结果视图，这个结果视图是用一个ActionForward对象来表示的，ActionForward对象通过struts.xml配置文件中的配置关联到某个JSP页面，因为程序中使用的是在struts.xml配置文件为JSP页面设置的逻辑名，这样可以实现action程序代码与返回的JSP页面名称的解耦。
你对Struts可能还有自己的应用方面的经验，那也要一并说出来。
2、你对Spring的理解?
1.Spring实现了工厂模式的工厂类（在这里有必要解释清楚什么是工厂模式），这个类名为BeanFactory（实际上是一个接口），在程序中通常使用BeanFactory的子类ApplicationContext。Spring相当于一个大的工厂类，在其配置文件applicationContext.xml中通过<bean>元素配置用于创建实例对象的类名和实例对象的属性。
2. Spring提供了对IOC良好支持，IOC是一种编程思想，是一种架构艺术，利用这种思想可以很好地实现模块之间的解耦。IOC也称为DI（Depency Injection），依赖注入，那么什么叫依赖注入呢？
譬如：
Class Programmer {
Computer computer = null;
public void code(){
//Computer computer = new IBMComputer();
//Computer computer = beanfacotry.getComputer();
computer.write();
}
public void setComputer(Computer computer) {
this.computer = computer;
}
}
另外两种方式都由依赖，第一个直接依赖于目标类，第二个把依赖转移到工厂上，第三个彻底与目标和工厂解耦了。在Spring的配置文件中配置片段如下：
<bean id=”computer” class=”com.tfj.demo.Computer”> </bean> <bean id=”programmer” class=”com.tfj.demo.Programmer”> <property name=”computer” ref=”computer”></property> </bean>
3. Spring提供了对AOP技术的良好封装，AOP称为面向切面编程，就是系统中有很多各不相干的类的方法，在这些众多方法中要加入某种系统功能的代码，例如，加入日志，加入权限判断，加入异常处理，这种应用称为AOP。实现AOP功能采用的是代理技术，客户端程序不再调用目标，而调用代理类，代理类与目标类对外具有相同的方法声明，有两种方式可以实现相同的方法声明，一是实现相同的接口，二是作为目标的子类在，JDK中采用Proxy类产生动态代理的方式为某个接口生成实现类，如果要为某个类生成子类，则可以用CGLI B。在生成的代理类的方法中加入系统功能和调用目标类的相应方法，系统功能的代理以Advice对象进行提供，显然要创建出代理对象，至少需要目标类和Advice类。Spring提供了这种支持，只需要在Spring配置文件中配置这两个元素即可实现代理和AOP功能，例如，
<bean id=”proxy” type=”org.spring.framework.aop.ProxyBeanFactory”>
<property name=”target” ref=””></property>
<property name=”advisor” ref=””></property>
</bean>
3、谈谈你对Hibernate的理解？
答:
1. 面向对象设计的软件内部运行过程可以理解成就是在不断创建各种新对象、建立对象之间的关系，调用对象的方法来改变各个对象的状态和对象消亡的过程，不管程序运行的过程和操作怎么样，本质上都是要得到一个结果，程序上一个时刻和下一个时刻的运行结果的差异就表现在内存中的对象状态发生了变化。
2.为了在关机和内存空间不够的状况下，保持程序的运行状态，需要将内存中的对象状态保存到持久化设备和从持久化设备中恢复出对象的状态，通常都是保存到关系数据库来保存大量对象信息。从Java程序的运行功能上来讲，保存对象状态的功能相比系统运行的其他功能来说，应该是一个很不起眼的附属功能，Java采用JDBC来实现这个功能，这个不起眼的功能却要编写大量的代码，而做的事情仅仅是保存对象和恢复对象，并且那些大量的JDBC代码并没有什么技术含量，基本上是采用一套例行公事的标准代码模板来编写，是一种苦活和重复性的工作。
3.通过数据库保存Java程序运行时产生的对象和恢复对象，其实就是实现了Java对象与关系数据库记录的映射关系，称为ORM（即Object Relation Mapping），人们可以通过封装JDBC代码来实现了这种功能，封装出来的产品称之为ORM框架，Hibernate就是其中的一种流行ORM框架。使用Hibernate框架，不用写JDBC代码，仅仅是调用一个save方法，就可以将对象保存到关系数据库中，仅仅是调用一个get方法，就可以从数据库中加载出一个对象。
4.使用Hibernate的基本流程是：配置Configuration对象、产生SessionFactory、创建session对象，启动事务，完成CRUD（增加(Create)、读取(Retrieve)（重新得到数据）、更新(Update)和删除(Delete)）操作，提交事务，关闭session。
5.使用Hibernate时，先要配置hibernate.cfg.xml文件，其中配置数据库连接信息和方言等，还要为每个实体配置相应的hbm.xml文件，hibernate.cfg.xml文件中需要登记每个hbm.xml文件。
6.在应用Hibernate时，重点要了解Session的缓存原理，级联，延迟加载和hql查询。
4、Struts的工作流程？
5、Struts1的运行原理？
在启动时通过前端总控制器ActionServlet加载struts-config.xml并进行解析，当用户在JSP页面发送请求被Struts1的核心控制器ActionServlet接收，ActionServlet在用户请求时将请求参数放到对应的ActionForm对象中的成员变量中，然后ActionServlet则会根据struts-config.xml中的映射关系找到相应的Action中的方法，将对应的ActionForm一并传给这个Action中的方法里，然后执行相应的业务逻辑操作，最后就根据ActionMapping的findforward方法返回一个ActionForward,之后在struts-config.xml中找到与之对应的forward标签，根据它的配置路径找到对应的JSP页面。
6、Struts2的运行原理？
1、Tomcat 启动的时候会加载web.xml、核心控制器 StrutsPrepareAndExecuteFilter会加载并解析struts.xml
2、客户端会发送一个请求到 action 、StrutsPrepareAndExecuteFilter会根据后缀名进行拦截
3、StrutsPrepareAndExecuteFilter根据struts.xml的配置文件信息找到某个action对应的某个类里的指定方法
4、执行相关的业务逻辑最后返回一个String
5、<action/> 里配置 <result/> name的属性值与返回的String进行匹配，跳转到指定的JSP 页面
7、谈谈Struts中的ActionServlet类？
ActionServlet继承自javax.servlet.http.HttpServlet类，其在Struts framework中扮演的角色是中心控制器。它提供一个中心位置来处理全部的终端请求。控制器ActionServlet主要负责将HTTP的客户请求信息组装后，根据配置文件的指定描述，转发到适当的处理器。按照Servelt的标准，所有得Servlet必须在web配置文件（web.xml）声明。同样，ActoinServlet必须在Web Application配置文件（web.xml）中描述，有关配置信息如下。
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
</servlet>
全部的请求URI以*.do的模式存在并映射到这个servlet，其配置如下：
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
一个该模式的请求URI符合如下格式：
http://www.my_site_name.com/mycontext/actionName.do
中心控制器为所有的表示层请求提供了一个集中的访问点。这个控制器提供的抽象概念减轻了开发者建立公共应用系统服务的困难，如管理视图、会话及表单数据。它也提供一个通用机制如错误及异常处理，导航，国际化，数据验证，数据转换等。当用户向服务器端提交请求的时候，实际上信息是首先发送到控制器ActionServlet，一旦控制器获得了请求，其就会将请求信息传交给一些辅助类（help classes）处理。这些辅助类知道如何去处理与请求信息所对应的业务操作。在Struts中，这个辅助类就是org.apache.struts.action.Action。通常开发者需要自己继承Aciton类，从而实现自己的Action实例。
8、Struts优缺点？
优点：
1. 实现MVC模式，结构清晰，使开发者只关注业务逻辑的实现.
2．有丰富的TAG可以用，Struts的标记库(Taglib)，如能灵活动用，则能大大提高开发效率
3. 页面导航
使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时，这种优势体现得更加明显。
4. 提供Exception处理机制 .
5. 数据库链接池管理
6. 支持I18N
缺点
1. 转到展示层时，需要配置forward，如果有十个展示层的JSP，需要配置十次Struts，而且还不包括有时候目录、文件变更，需要重新修改forward，注意，每次修改配置之后，要求重新部署整个项目，而Tomcat这样的服务器，还必须重新启动服务器。
2. Struts的Action必需是thread－safe方式，它仅仅允许一个实例去处理所有的请求。所以action用到的所有的资源都必需统一同步，这个就引起了线程安全的问题。
测试不方便：Struts的每个Action都同Web层耦合在一起，这样它的测试依赖于Web容器，单元测试也很难实现。不过有一个JUnit的扩展工具Struts TestCase可以实现它的单元测试。
类型的转换：Struts的FormBean把所有的数据都作为String类型，它可以使用工具Commons-Beanutils进行类型转化。但它的转化都是在Class级别，而且转化的类型是不可配置的。类型转化时的错误信息返回给用户也是非常困难的。
对Servlet的依赖性过强：Struts处理Action时必需要依赖ServletRequest 和ServletResponse，所有它摆脱不了Servlet容器。
前端表达式语言方面：Struts集成了JSTL，所以它主要使用JSTL的表达式语言来获取数据。可是JSTL的表达式语言在Collection和索引属性方面处理显得很弱。
对Action执行的控制困难：Struts创建一个Action，如果想控制它的执行顺序将会非常困难。甚至你要重新去写Servlet来实现你的这个功能需求。
对Action 执行前和后的处理：Struts处理Action的时候是基于class的hierarchies（层次体系），很难在action处理前和后进行操作。
对事件支持不够：在Struts中，实际是一个表单Form对应一个Action类(或DispatchAction)，换一句话说：在Struts中实际是一个表单只能对应一个事件，Struts这种事件方式称为application event，application event和component event相比是一种粗粒度的事件
9、Struts的应用(如Struts架构) ？
Struts是采用Java Servlet/Java Server Pages技术，开发Web应用程序的开放源码framework。 采用Struts能开发出基于MVC(Model-View-Controller)设计模式的应用构架。 Struts有如下的主要功能：一.包含一个Controller Servlet，能将用户的请求发送到相应的Action对象。二.JSP自由TAG库，并且在Controller Servlet中提供关联支持，帮助开发员创建交互式表单应用。 三.提供了一系列实用对象：XML处理、通过Java Reflection API自动处理JavaBean属性、国际化的提示和消息。
10、说说Struts1与Struts2的区别？
1.都是MVC的WEB框架,
2 Struts1是老牌框架，应用很广泛，有很好的群众基础，使用它开发风险很小，成本更低！Struts2虽然基于这个框架，但是应用群众并不多，相对不成熟，未知的风险和变化很多，开发人员相对不好招，使用它开发项目的风险系数更大，用人成本更高！
3.Struts2毕竟是站在前辈的基础设计出来，它会改善和完善Struts1中的一些缺陷，Struts1中一些悬而未决问题在Struts2得到了解决。
4.Struts1的前端控制器是一个Servlet，名称为ActionServlet，Struts2的前端控制器是一个filter，在Struts2.0中叫FilterDispatcher，在Struts2.1中叫StrutsPrepareAndExecuteFilter。
5.Struts1的action需要继承Action类，Struts2的action可以不继承任何类；Struts1对同一个路径的所有请求共享一个Action实例，Struts2对同一个路径的每个请求分别使用一个独立Action实例对象，所有对于Struts2的Action不用考虑线程安全问题。
6.在Struts1中使用formbean封装请求参数，在Struts2中直接使用action的属性来封装请求参数。
7.Struts1中的多个业务方法放在一个Action中时（即继承DispatchAction时），要么都校验，要么都不校验；对于Struts2，可以指定只对某个方法进行校验，当一个Action继承了ActionSupport且在这个类中只编写了validateXxx()方法，那么则只对Xxx()方法进行校验。
（一个请求来了的执行流程进行分析，Struts2是自动支持分模块开发，并可以不同模块设置不同的URL前缀，这是通过package的namespace来实现的；Struts2是支持多种类型的视图；Struts2的视图地址可以是动态的，即视图的名称是支持变量方式的，举例，论坛发帖失败后回来还要传递boardid。视图内容显示方面：它的标签用OGNL，要比EL强大很多，在国际化方面支持分模块管理，两个模块用到同样的key，对应不同的消息；）
与Struts1不同，Struts2对用户的每一次请求都会创建一个Action，所以Struts2中的Action是线程安全的。
给我印象最深刻的是：Struts配置文件中的redirect视图的URL不能接受参数，而Struts2配置文件中的redirect视图可以接受参数。
11、Struts2中result中的type类型？
1.dispatcher：它是默认的，用来转向页面，通常处理JSP
2.redirect：将用户重定向到一个已配置好的URL
3.redirectAction：将用户重定向到一个已定义好的action
4.chain：将action和另外一个action链接起来
5.freemarker：呈现Freemarker模板
6.httpheader：返回一个已配置好的HTTP头信息响应
7.stream：向浏览器发送InputSream对象对下载的内容和图片非常有用
8.velocity：呈现Velocity模板
9.xslt：该XML可以通过XSL模板进行转换
10.plaintext：显示原始文件内容，例如文件源代码
12、Struts2标签？
首先需要引用 <%@taglib prefix="s" URL="/struts-tags"%>
1.<s:if></s:if> 判断标签 后面可跟 <s:else>
2.<s:iterator> </s:iterator> 迭代标签
3.<s:include></s:include> 引入标签 可以把一个JSP页面或者Servlet引入一个页面中
4.<s:property></s:property> 输出标签
5.<s:set></s:set> 标签赋予变量一个特定范围内的值
6.<s:form></s:form> 表单标签
7.<s:testarea></s:textarea> 文本域标签
8.<s:select></s:select> 下拉标签
9.<s:url></s:url> 声明一个URL的路径
最常用的是：
判断<s:if></s:if>
循环<s:iterator></s:terator>
输出<s:property></s:property>
13、Spring MVC运行原理？
整个处理过程从一个HTTP请求开始：
1.Tomcat在启动时加载解析Web.xml,找到Spring mvc的前端总控制器DispatcherServlet,并且通过DispatcherServlet来加载相关的配置文件信息。
2.DispatcherServlet接收到客户端请求，找到对应HandlerMapping，根据映射规则，找到对应的处理器（Handler）。
3.调用相应处理器中的处理方法，处理该请求后，会返回一个ModelAndView。
4.DispatcherServlet根据得到的ModelAndView中的视图对象，找到一个合适的ViewResolver（视图解析器），根据视图解析器的配置，DispatcherServlet将要显示的数据传给对应的视图，最后显示给用户。
14、Spring MVC、Struts1和Struts2区别？
1.Spring MVC单例 非线程安全
Struts1单例 非线程安全
Struts2线程安全对每个请求都产生一个实例
2.Spring MVC的入口是Servlet，而Struts2是filter
Spring 的前端总控制器为 DispatcherServlet
Struts2 的前端总控制器为 FilterDispatcher
Struts1 的前端总控制器为 ActionServlet
3. 参数传递：Struts是在接受参数的时候，
可以用属性来接受参数，这就说明参数是让多个方法共享的。
Spring MVC用方法来接受参数
4.Spring MVC是基于方法的设计，而sturts是基于类
15、Spring MVC整合？
1.首先，要在web.xml里面配置SpringMVC的核心控制器，DispatcherServlet对指定的后缀请求进行拦截。
2.Controller层要加 @Controller注解：表明该类是MVC的控制层。
3.创建Service接口,给接口加上注解 @Component或者 @Service 表明这是Service业务处理层
4.在Controller层声明Service变量(属性),给变量（属性） 加上 @Autowired注解,通过自动绑定机制将Service注入到Controller。 (注：@Autowired默认是ByType,如果想根据属性名注入,那么就再加上注解 @Resource(name="属性名"))
5.在Controller层的方法上加上注解 @RequestMapping("requestAddress") 表明该方法的请求地址
6.DAO层要加上注解 @Repository 表明这是数据库持久层
7.同样将DAO实例注入到service层中。
8.配置视图解析器 "InternalResourceViewResolver",对处理后的跳转进行统一配置。
16、AOP的作用？
面向切面编程（AOP）
面向切面编程（AOP）就是对软件系统不同关注点的分离，开发者通过拦截方法调用并在方法调用前后添加辅助代码。
AOP利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多了类的公共行为封装到一个可重用的模块，并将其命名为“Aspect”，即切面。
AOP的作用在于分离系统中各个关注点，将核心关注点和横切关注点分离开来。
17、Spring的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello"的XML配置文件该怎么写?
1、注入就是通过se方式注入对象或值，需要注入的对象或值需要在Spring文件中进行配置。
2、
<bean id="message" class="message所在类的路径名">
<property name="message" value="Hello" />
</bean>
18、Hibernate中的update()和saveOrUpdate()的区别，session的load()和get()的区别？
saveOrUpdate()方法可以实现update()的功能，但是会多些步骤，具体如下:
如果对象在该session中已经持久化，则不进行操作；如果对象的标识符属性(identifier property) 在数据库中不存在或者是个暂时的值，则调用save()方法保存它；如果session中的另一个对象有相同的标识符则抛出一个异常；以上皆不符合则调用update()更新。
拓展：Hibernate 中get和load的区别？
加载方式：
load为延迟加载(返回的是一个只有id属性的代理,只有使用该对象属性时，才发出SQL语句)；
get为立即加载(执行时,会立即向数据库发出SQL语句)
返回结果：
load检索不到记录时，会抛ObjectNotFoundException异常
get检索不到记录时，会返回null
session.load/get方法均可以根据指定的实体类和id从数据库读取记录，get方法返回null， 而load方法会抛出一个ObjectNotFoundException;load方法可返回实体的代理类实例，而get方法永远直接返回实体类；load方法可以充分利用内部缓存和二级缓存中的现有数据，而get方法则仅仅在内部缓存中进行数据查找，如果没有发现对应的数据，将越过二级缓存， 直接调用SQL完成数据读取。
19、iBATIS与Hibernate有什么不同?
相同点：屏蔽JDBC API的底层访问细节，使用我们不用与JDBC API打交道，就可以访问数据。
JDBC API编程流程固定，还将SQL语句与Java代码混杂在了一起，经常需要拼凑SQL语句，细节很繁琐。
iBATIS的好处：屏蔽JDBC API的底层访问细节；将SQL语句与Java代码进行分离；提供了将结果集自动封装称为实体对象和对象的集合的功能，queryForList返回对象集合，用queryForObject返回单个对象；提供了自动将实体对象的属性传递给SQL语句的参数。
Hibernate是一个全自动的orm映射工具，它可以自动生成SQL语句，iBATIS需要我们自己在xml配置文件中写SQL语句，Hibernate要比iBATIS功能负责和强大很多。因为Hibernate自动生成SQL语句，我们无法控制该语句，我们就无法去写特定的高效率的SQL。对于一些不太复杂的SQL查询，Hibernate可以很好帮我们完成，但是，对于特别复杂的查询，Hibernate就很难适应了，这时候用iBATIS就是不错的选择，因为iBATIS还是由我们自己写SQL语句。
20、写Hibernate的一对多和多对一双向关联的ORM配置?
多对一双向关联
注意:那个外键(两个约束必须要执行同一个外键)
<many-to-one name="dept" class="Dept" column="deptno">
</many-to-one>
<set name="emp" >
<key column="deptno"></key>
<one-to-many class="Emp"/>
</set>
注意deptno，多对一和一对多，外键的名字必须一致
21、在DAO中如何体现DAO设计模式?
数据库连接类、VO类、DAO接口、DAO实现类、DAO工厂类
22、Spring+Hibernate中委托方案怎么配置?
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource" ref="oracleDataSource"/>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">${hibernate.dialect}</prop>
<prop key="hibernate.connection.release_mode">after_transaction</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
<prop key="hibernate.temp.use_jdbc_metadata_defaults">false</prop>
</props>
</property>
<!-- Must references all OR mapping files. -->
<property name="defineMappingResources">
<list><value>classpath:*-*ql.xml</value></list>
</property>
</bean>
23. Hibernate进行多表查询每个表中各取几个字段，也就是说查询出来的结果集没有一个实体类与之对应如何解决？
解决方案一，按照Object[]数据取出数据，然后自己组bean
解决方案二，对每个表的bean写构造函数，比如表一要查出field1,field2两个字段，那么有一个构造函数就是Bean(type1 filed1,type2
field2) ，然后在hql里面就可以直接生成这个bean了。
24.介绍一下Hibernate的二级缓存？
按照以下思路来回答：（1）首先说清楚什么是缓存，（2）再说有了Hibernate的Session就是一级缓存，即有了一级缓存，为什么还要有二级缓存，（3）最后再说如何配置Hibernate的二级缓存。
（1）缓存就是把以前从数据库中查询出来和使用过的对象保存在内存中，准确说就是一个数据结构中，这个数据结构通常是或类似HashMap，当以后要使用某个对象时，先查询缓存中是否有这个对象，如果有则使用缓存中的对象，如果没有则去查询数据库并使用，并将查询出来的对象保存在缓存中，以便下次使用。下面是缓存的伪代码：
引出Hibernate的第二级缓存，用下面的伪代码分析了Cache的实现原理
DAO {
HashMap map = new Map();
User getUser(integer id) {
User user = map.get(id)
if(user == null) {
user = session.get(id);
map.put(id,user);
}
return user;
}
}
DAO {
Cache cache = null
setCache(Cache cache) {
this.cache = cache
}
User getUser(int id) {
if(cache!=null) {
User user = cache.get(id);
if(user ==null) {
user = session.get(id);
cache.put(id,user);
}
return user;
}
return session.get(id);
}
}
（2）Hibernate的Session就是一种缓存，我们通常将之称为Hibernate的一级缓存，当想使用session从数据库中查询出一个对象时，Session也是先从自己内部查看是否存在这个对象，存在则直接返回，不存在才去访问数据库，并将查询的结果保存在自己内部。由于Session代表一次会话过程，一个Session与一个数据库连接相关连，所以Session最好不要长时间保持打开，通常仅用于一个事务当中，在事务结束时就应关闭。并且Session是线程不安全的，被多个线程共享时容易出现问题。通常只有那种全局意义上的缓存才是真正的缓存应用，才有较大的缓存价值，因此，Hibernate的Session这一级缓存的缓存作用并不明显，应用价值不大。Hibernate的二级缓存就是要为Hibernate配置一种全局缓存，让多个线程和多个事务都可以共享这个缓存。一个人使用过，其他人也可以使用，但是Session没有这种效果。
（3）二级缓存是独立于Hibernate的软件部件，属于第三方的产品，多个厂商和组织都提供有缓存产品，例如，EHCache和OSCache等等。在Hibernate中使用二级缓存，首先就要在hibernate.cfg.xml配置文件中配置使用哪个厂家的缓存产品，接着需要配置该缓存产品自己的配置文件，最后要配置Hibernate中的哪些实体对象要纳入到二级缓存的管理中。明白了二级缓存原理和有了这个思路后，很容易配置起Hibernate的二级缓存。扩展知识：一个SessionFactory可以关联一个二级缓存，也即一个二级缓存只能负责缓存一个数据库中的数据，当使用Hibernate 的二级缓存后，注意不要有其他的应用或SessionFactory来更改当前数据库中的数据，这样缓存的数据就会与数据库中的实际数据不一致。
25、简述 Hibernate和JDBC的优缺点? 如何书写一个one to many 配置文件？
Hibernate和JDBC主要区别就是，Hibernate先检索缓存中的映射对象( 即Hibernate操作的是对象)，而JDBC则是直接操作数据库.
Hibernate是JDBC的轻量级的对象封装，它是一个独立的对象持久层框架。Hibernate可以用在任何JDBC可以使用的场合
Hibernate是一个和JDBC密切关联的框架，所以Hibernate的兼容性和JDBC驱动，和数据库都有一定的关系，但是和使用它的Java程序，和App Server没有任何关系，也不存在兼容性问题。
如果正确的使用JDBC技术,它的执行效率一定比Hibernate要好,因为Hibernate是基于JDBC的技术.
JDBC使用的是SQL语句，Hibernate使用的是HQL语句，但是HQL语句最终还会隐式转换成SQL语句执行。
Hibernate就是封装了JDBC，他可以写一条hql语句，可以再不同数据库中使用，不用修改hql语句，但是关联查询效率低。
JDBC是基础的链接数据库的框架，效率高，但是mysql、oracle、sql server等不同的数据库要写不同的SQL语句。
one to many比如Class和Student就是一个班级对应多个学生
在Class类中追加集合属性 Set<Student> students;
在Class的配置文件中追加（Class.hbm.xml）
<!-- 追加集合属性的配置 -->
<!-- 设置集合属性 -->
<set name="students" lazy="false" fetch="join" cascade="all" inverse="true">
<!-- 设置关联字段 -->
<key column="classId" />
<!-- 设置关联关系 -->
<one-to-many class="Studnet" />
</set>
将Studnet中的classId属性去掉换成 Class class;
在Student的配置文件中（Student.hbm.xml）
<many-to-one name="class" column="classId" lazy="false" fetch="join" class="Class">
</many-to-one>
26、Hibernate中的两大配置文件？
*.hbm.xml：主键生成策略，映射关系，一对多，一对一的关系。
Hibernate.cfg.xml：方言(用哪个数据库)，数据库连接信息，包含*.hbm.xml内容，映射 文件，也可以配事务。
Hibernate事务处理
开启事务 session.beginTransaction();
执行相关的操作，如果成功则session.getTransaction().commit();
执行操作失败则 session.getTransaction.rollback();
27、Hibernate、iBATIS、JDBC三者的区别？
Hibernate属于全自动， iBATIS属于半自动，JDBC属于手动，从开发效率上讲Hibernate较高，iBATIS居中，JDBC较低，从执行效率上讲Hibernate较低，iBATIS居中，JDBC较高，因为JDBC是手工写SQL语句，程序员对sql的控制能力更大，可以根据业务需要进行优化，而iBATIS虽然也可以对sql进行优化，但是他里面将resultset封装为实体的过程中采用了反射机制所以一定程度上影响了性能，而Hibernate因为高度封装所以开发效率相对较高，但正因为这个原因，所以程序员在对SQL语句的控制和优化方面相对比较弱，而且在将resultset封装成实体的过程中也采用了反射机制，所以在性能方面较低
28、Hibernate的运行原理？
在初始化Hibernate时，会首先会根据configuration接口去加载并读取Hibernate的配置信息(Hibernate.cfg.xml)，(一个Configeration实例代表Hibernate所有Java类到Sql数据库映射的集合。)，然后创建SessionFactory实例，把Configeration对象中的所有配置信息拷贝到SessionFactory的缓存中，最后通过调用SessionFactory创建Session对象，通过Session接口提供的各种方法来操纵数据库的访问(Query和Criteria接口)。
29、Hibernate五大核心（类/接口）简述？
1 .Configuration接口的作用是对Hibernate进行配置，以及对它进行启动。（加载 Hibernate.cfg.xml）并创建一个SessionFactory对象。
2 .SessionFactory接口
SessionFactory接口负责初始化Hibernate。它充当数据存储源的代理，并负责创建 Session对象。SessionFactory是线程安全的。
3 .Session接口
Session（会话）接口是Hibernate应用使用的主要接口。Session接口负责执行被持久化对象的CRUD操作(增删改查)。Session对象是非线程安全的。Session 相当于JDBC的connection
4 .Query与Criteria接口
总之Query和Criteria接口负责执行各种数据库查询。它可以使用HQL语句或SQL 语句两种表达方式。
5 .Transaction接口
Transaction（事务）接口是一个可选的API。负责操作相关的事务。
30、Hibernate的三种状态以及状态的转换？
Transient(临时)
new 一个初始化对象后，并没有在数据库里保存数据，处于临时状态；
Persistent(持久化)
当执行save()方法，调用session.close()方法之前，内存中的对象与数据库有 对应关系处于持久化状态；
Detached(脱管/游离)
当执行session.close()之后，处于脱管状态；
状态的转换
处于托管状态下，调用update()方法后，转换为持久化状态；
在持久化状态下，执行delete()方法后，转换为临时状态；
在未初始化对象之前，调用get(),load(),find(),iterate()之后，直接进入持久化 状态。
分页步骤
①前台封装一个显示分页的组件
②查询总条数
③后台封装分页工具类，计算开始位置、结束位置、总页数
④后台写支持分页的SQL语句
⑤前台包含分页组件，实现分页效果
注意:
查询总条数的where和查询列表信息的where条件要保证一致。
31、Hibernate缓存概述？
Hibernate分为一级缓存即session缓存也叫事务级别的缓存以及
二级缓存sessionFactory即应用级别的缓存,还有查询缓存即三级缓存.
一级缓存的生命周期和session的生命周期保持一致，
Hibernate默认就启用了一级缓存，
不能将其关闭，可以通过session.clear()和session.evict(object)来管理一级缓存。其中get,load,iterate都会使用一级缓存，一级缓存缓存的是对象。
二级缓存的生命周期和sessionFactory的生命周期保持一致，可以跨session,被多个session共享，Hibernate3默认开启二级缓存,也可以手动开启并指定缓存插件如ehcache,oscache
等。二级缓存也只能缓存对象。
三级缓存也叫查询缓存，查询缓存是针对普通属性结果集的缓存,
对实体对象的结果集只缓存id。对query.list()起作用，query.iterate不起作用，也就是query.iterate不使用查询缓存
32、SSH的概述？
SSH是Web开发中常见的一种框架
S-Struts
S-Spring
H-Hibernate
其中Struts在框架中充当控制器，实现MVC，主要用来处理用户的请求，和跳转页面。使项目结构清晰，开发者只需要关注业务逻辑的实现即可。
Spring在SSH充当粘合剂，粘合Struts-Sping-Hibernate，主要用来进行事物的控制，
Hibernate-充当数据库持久层，主要用它来与数据库交互，提高开发效率，减轻程序员sql控制要求，而且Hibernate通过反射机制，有灵活的映射性，还支持各种关系，一对一，一对多，多对多。
在进行SSH整合的时候，我们应该注意：
1. Action继承于ActionSupport
引入struts-spring-plugin.jar包，从而完成Struts和Spring的整合
在Struts2的action中注入service，保证service的名字和配置文件中的一致，并生成get,set方法
DAO层继承于HibernateDAOSupport
在DAO层的配置文件中注入sessionFactory
33、防止表单重复提交？
针对于重复提交的整体解决方案：
1.用redirect来解决重复提交的问题
2.点击一次之后，按钮失效
3.通过loading
4.自定义重复提交过滤器
5.解决Struts2重复提交
可以结合s:token标签来解决重复提交问题
利用token的原理：
1.在前端的JSP页面中加入s:token标签，在访问该页面时就会生成隐藏域，该隐藏域中包含一个随机生成的字符串，并把该字符串存入session中
2.在Struts2的配置文件中加入token拦截器后，当正常访问action的时候，会从session中取出该字符串，然后和页面隐藏域中提交字符串做对比，如果一致则正常执行并删除session中存储的字符串。
34、JDO是什么?
JDO是Java对象持久化的新的规范，是Java Data Object的简称,也是一个用于存取某种数据仓库中的对象的标准化API。JDO提供了透明的对象存储，因此对开发人员来说，存储数据对象完全不需要额外的代码（如JDBC API的使用）。这些繁琐的例行工作已经转移到JDO产品提供商身上，使开发人员解脱出来，从而集中时间和精力在业务逻辑上。另外，JDO很灵活，因为它可以在任何数据底层上运行。JDBC只是面向关系数据库（RDBMS）JDO更通用，提供到任何数据底层的存储功能，比如关系数据库、文件、XML以及对象数据库（ODBMS）等等，使得应用可移植性更强。
35、SSI整合？
1、Action继承于Actionsupport
2、引入Struts-Spring-plugin.jar包，从而完成Struts和Spring的整合
3、在Struts2的action中注入service，保证service的名字和配置文件中的一致， 并生成get，set方法
4、DAO层继承于SqlMapClientDAOSupport
5、在DAO层的配置文件中注入sqlMapClient
36、SSH整合？
1、Action继承于ActionSupport
2、引入Struts-Spring-plugin.jar包，从而完成Struts和Spring的整合
3、在Struts2的action中注入service，保证service的名字和配置文件中的一致， 并生成get，set方法
4、DAO层继承于HibernateDAOSupport
5、在DAO层的配置文件中注入sessionFactory
标签：
原文地址：http://www.cnblogs.com/tufujie/p/4922739.html
