ssh三大框架常见问题总结

七、框架部分

1、谈谈你对Struts2的理解。

1)struts2是一个MVC框架，MVC是一种开发模式，把业务逻辑代码与视图代码分离，通过控制器连接业务逻辑与视图。MVC将应用程序分成了视图、模型、控制器三部分，使代码结构层次清晰、降低耦合度、代码重用性高。

2）结合Struts2处理请求的工作流程加以说明：

客户端发送一个请求到服务器，tomcat会接收这个请求，tomcat会读取项目中的web.xml中的配置，判断请求是否符合Struts2过滤器StrutsPrepareAndExecuteFilter过滤的路径，如果符合会把这个请求交给Struts2处理，StrutsPrepareAndExecuteFilter会分析请求路径，根据Struts.xml中的配置，请求路径匹配package标签的namespace属性加上action标签的name属性，跳转到对应的action类，默认执行execute方法，并通过IoC方式，将值注入给Aciton。 如果使用动态方法调用，会执行action类中的对应方法，方法执行完成后会返回一个字符串，这个字符串对应Struts.xml中action标签下的result标签name属性根据result标签的配置跳转到对应的jsp页面，在jsp页面中呈现数据，返回给客户端。

3）结合Struts2优点说明：

a、实现MVC模式，结构清晰,使开发者只关注业务逻辑的实现.

b、有丰富的tag可以用 ,Struts的标记库(Taglib)，如能灵活动用，则能大大提高开发效率

c、页面导航使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时，这种优势体现得更加明显。

d、提供Exception处理机制 .

e、数据库链接池管理

f、支持I18N

2、谈谈你对Hibernate的理解。

1）hibernate是ORM框架，ORM是对象关系映射,类—>表，属性—>表中的列,对象—>表中的每一条数据，是为了解决面向对象与关系数据库之间互不匹配现象的技术。使我们编程的思想更面向对象了，不用去考虑关系型数据库。

2）hibernate工作流程是：configuration类读取并解析hibernate.cfg.xml配置文件，读取解析映射信息，创建sessionFactory，打开session，创建事务，持久化操作，关闭session，整个应用停止关闭sessionFactory。

3）结合hibernate优点说明：

a、程序更加面向对象，提高开发效率

b、提高了生产率，不用写SQL语句

c、hibernate使用的是hql，支持方言配置，方便据数库移植

d、对jdbc代码进行封装，编程更简便了

e、hibernate是个轻量级框架，对代码无侵入性

3、你对Spring的理解。

1）Sping是一个轻量级框架，设计原则是非侵入性的。Sping核心是IOC容器，IOC是一种编程思想，是一种架构艺术，是用来管理控制对象的生命周期和对象之间的关系，通过配置文件进行注入，很好的实现了对象与对象之间解耦。

2）IOC工作原理：IOC实现了工厂模式，通过读取application.xml配置文件中的标签的类，注入到IOC容器中，通过构造或set方法注入，产生BeanFactory，BeanFactory通过getBean方法获取对象。

3）Spring还提供了另外一种重要编程思想AOP，AOP称为面向切面编程，可以动态的将主线业务逻辑代码与实现功能代码分离，为了更清晰的逻辑，可以让你的业务逻辑去关注自己本身的业务，而不去想一些其他的事情，将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码

4）Spring提供了很多第三方框架的整合，如：hibernate、struts、mybatis、web service等，使用IOC管理所有的Java bean，这样可以让框架与框架之间偶尔度降低，方便项目的管理，提高开发效率。

4、Struts2优缺点

优点：

1）实现MVC模式，结构清晰,使开发者只关注业务逻辑的实现.

2）有丰富的tag可以用 ,Struts的标记库(Taglib)，如能灵活动用，则能大大提高开发效率

3）页面导航使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时，这种优势体现得更加明显。

4）提供Exception处理机制 .

5）数据库链接池管理

6）支持I18N

缺点

1）转到展示层时，需要配置forward，每一次转到展示层，相信大多数都是直接转到jsp，而涉及到转向，需要配置forward，如果有十个展示层的jsp，需要配置十次struts，而且还不包括有时候目录、文件变更，需要重新修改forward，注意，每次修改配置之后，要求重新部署整个项目，而tomcate这样的服务器，还必须重新启动服务器，如果业务变更复杂频繁的系统，这样的操作简单不可想象。现在就是这样，几十上百个人同时在线使用我们的系统，大家可以想象一下，我的烦恼有多大。
    2）Struts 的Action必需是thread－safe方式，它仅仅允许一个实例去处理所有的请求。所以action用到的所有的资源都必需统一同步，这个就引起了线程安全的问题。
    3）测试不方便. Struts的每个Action都同Web层耦合在一起，这样它的测试依赖于Web容器，单元测试也很难实现。不过有一个Junit的扩展工具Struts TestCase可以实现它的单元测试。
    4）类型的转换. Struts的FormBean把所有的数据都作为String类型，它可以使用工具Commons-Beanutils进行类型转化。但它的转化都是在Class级别，而且转化的类型是不可配置的。类型转化时的错误信息返回给用户也是非常困难的。
    5）对Servlet的依赖性过强. Struts处理Action时必需要依赖ServletRequest 和ServletResponse，所有它摆脱不了Servlet容器。
    6）前端表达式语言方面.Struts集成了JSTL，所以它主要使用JSTL的表达式语言来获取数据。可是JSTL的表达式语言在Collection和索引属性方面处理显得很弱。
    7）对Action执行的控制困难. Struts创建一个Action，如果想控制它的执行顺序将会非常困难。甚至你要重新去写Servlet来实现你的这个功能需求。
    8）对Action 执行前和后的处理. Struts处理Action的时候是基于class的hierarchies，很难在action处理前和后进行操作。
    9）对事件支持不够. 在struts中，实际是一个表单Form对应一个Action类(或DispatchAction)，换一句话说：在Struts中实际是一个表单只能对应一个事件，struts这种事件方式称为application event，application event和component event相比是一种粗粒度的事件。

5、说说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()方法进行校验。

8）一个请求来了的执行流程进行分析，struts2是自动支持分模块开发，并可以不同模块设置不同的url前缀，这是通过package的namespace来实现的；struts2是支持多种类型的视图；struts2的视图地址可以是动态的，即视图的名称是支持变量方式的，举例，论坛发帖失败后回来还要传递boardid。视图内容显示方面：它的标签用ognl，要el强大很多，在国际化方面支持分模块管理，两个模块用到同样的key，对应不同的消息。

9）与Struts1不同，Struts2对用户的每一次请求都会创建一个Action，所以Struts2中的Action是线程安全的。

10）给我印象最深刻的是：struts配置文件中的redirect视图的url不能接受参数，而struts2配置文件中的redirect视图可以接受参数。

6、struts的核心组件有哪些？

1）FilterDispatcher,struts2的核心组件，整个struts2的调度中心，它对请求进行过滤并决定struts2是否出来该请求。   

2）Strtus.xml：struts2的应用配置文件，它负责配置系统中用到的action

3）Action:strtus2的动作执行单元实际处理用户的请求，封装业务所需的数据

4）Result：action运行后要转向下一个资源，可以是视图也可以说其他的action

5）Struts标签：用于页面上遍历后台传过来的数据

7、Strus2的执行过程

1）客户端发送一个请求到服务器，tomcat会接收这个请求

2）tomcat会读取项目中的web.xml中的配置

3）判断请求是否符合Struts2过滤器StrutsPrepareAndExecuteFilter过滤的路径

4）如果符合会把这个请求交给Struts2处理

5）StrutsPrepareAndExecuteFilter会分析请求路径，根据Struts.xml中的配置，请求路径匹配package标签的namespace属性加上action标签的name属性，跳转到对应的action类

6）默认执行execute方法，如果使用动态方法调用，会执行action类中的对应方法，方法执行完成后会返回一个字符串

7）这个字符串对应Struts.xml中action标签下的result标签name属性

8）根据result标签的配置跳转到对应的jsp页面，在jsp页面中呈现数据，返回给客户端

8、为什么要使用struts2？

1）开源

2）mvc框架

3）纯pojo的action

4）更好的标签特性

5）易测性

6）易扩展性

9、openSession和getCurrentSession

 1）openSession 从字面上可以看得出来，是打开一个新的session对象，而且每次使用都是打开一个新的session，假如连续使用多次，则获得的session不是同一个对象，并且使用完需要调用close方法关闭session。

  2）getCurrentSession ，从字面上可以看得出来，是获取当前上下文一个session对象，当第一次使用此方法时，会自动产生一个session对象，并且连续使用多次时，得到的session都是同一个对象，这就是与openSession的区别之一，简单而言，getCurrentSession 就是：如果有已经使用的，用旧的，如果没有，建新的。

注意 ：在实际开发中，往往使用getCurrentSession多，因为一般是处理同一个事务（即是使用一个数据库的情况），所以在一般情况下比较少使用openSession或者说openSession是比较老旧的一套接口了；

对于getCurrentSession 来说，有以下一些特点：

1.用途，界定事务边界

2.事务提交会自动close，不需要像openSession一样自己调用close方法关闭session

3.上下文配置（即在hibernate.cfg.xml）中，需要配置：

    thread

10、拦截器的作用？拦截器和过滤器的区别？

拦截器是对调用的action起作用，它提供类一种机制可以使开发者可以定义在一个action执行的前后执行的代码。拦截器只能拦截action，说白了拦截器其实就是一个action的功能块。拦截器可以抽象出一部分代码可以用来完善原来的action。同时可以减轻代码冗余提高重用率。

过滤器是拦截用户请求，范围被拦截器大。

11、struts.xml中result的type有哪些类型？

Dispatcher：struts2默认的结果类型，把控制权转发给应用程序里的某个资源，不能把控制权转发给一个外部资源，若需要啊控制权重定向到一个外部资源，应该使用redirect结果类型。

Redirect 把响应重定向到另一个资源

RedirectAction 把响应重定向到另一个Action

Freemarcker、velocity、chain、httpherder、xslt、plainText、stream、json.

12、一般情况下，关系数据模型与对象模型之间有哪些匹配关系?

表对应类

记录对应对象

表的字段对应类的属性

13、hibernate 数据的三个状态

1）瞬时状态（临时状态）：当new 对象时候，处于瞬时状态（如果程序运行完了，该对象会被垃圾回收）。

2）持久状态 ：跟session有关，就是持久状态，持久状态的对象，任何的修改，都会影响到数据库中与之对应的数据。

3）托管状态（游离状态）：当session不在管理对象的时候，脱离了    session 的管理，处于托管状态的对象，修改属性，对数据库数据没有任何影响。

企业开发中,使用saveOrUpdate(obj):   来替代save(obj)或update(obj)方法    

避免因为状态的改变,导致方法出错,    saveOrUpdate(obj)

可以根据obj的状态,来选择是save()还是update()

14、Hibernate中load和get的区别？

1.如果数据库中，没有userId的对象，如果通过get方法加载，则返回的是一个Null；如果通过Load则返回一个代理对象，如果后面代码调用user对象的某个属性,会抛出objectNotFoundException

2.Load支持延迟加载（懒加载），get不支持。

 解释：使用get 去查询数据，(先到一级/二级)会立即向db发出查询请求(select ...), 如果你使用的是 load查询数据，(先到一级、二级))即使查询到对象，返回的是一个代理对象,如果后面没有使用查询结果，它不会真的向数据库发select ,当程序员使用查询结果的时候才真的发出select ,这个现象我们称为懒加载(lazy)

3. 通过修改配置文件(*.hbm.xml文件)，我们可以取消懒加载

[html] view plain copy

1. <class  name="Employee" lazy="false" table="employee">  

4. 如何选择使用哪个: 如果你确定DB中有这个对象就用load(),不确定就用get()（这样效率高）

15、Hibernate的工作原理?

1）configuration类读取并解析hibernate.cfg.xml配置文件

2）读取解析映射信息，创建sessionFactory

3）打开session

4）创建事务

5）持久化操作

6）关闭session

7）整个应用停止，关闭sessionFactory

16、hibernate优缺点？

优点：

1）对jdbc访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

2）Hibernate是一个基于JDBC的主流持久性框架，是一个优秀的ORM实现，他很大程度的简化DAO的编码工作，程序更加面向对象，提高开发效率。

3）程序更加面向对象，提高开发效率

4）提高了生产率，不用写SQL语句

5）hibernate使用的是hql，支持方言配置，方便数据库移植

6）hibernate是个轻量级框架，对代码无侵入性

缺点：

1）效率比JDBC略差

2）不适合批量操作

3）对表的操作不够灵活

17、Hibernate是如何延迟加载的？

hibernate中存在一些查询方法，在查询的时候并没有立刻访问数据库查询数据，而是返回了一个空对象，这个对象并不是null而是经过new的对象，但对象中除了ID这种属性外其他属性都是null，当程序使用对象时hibernate才会真正的发送语句去查询数据库，将返回的数据填充到对象的属性值。这种将推迟查询队形机制称为延迟加载。

为什么要用延迟加载：

1）推迟的时间内由于没有数据加载可以节约内存空间，提高内存的使用率。

2）如果对象查询出来并没有使用，那么延迟加载的对象根本没有访问数据库，可以减少数据可得访问次数。

如何使用延迟加载

1）在hibernate里面有一些方法自动支持延迟加载，只要调用就可以使用。

2）具有延迟加载的方法如下:

     session.load();

     query.iterate();

  关联映射属性加载,属性名是lazy，如果查询不存在延迟加载就会抛异常

18、如果优化Hibernate？

使用双向一对多关联，不使用单向一对多

灵活使用单向一对多

不使用一对一，用多对一取代

配置对象缓存，不适用集合缓存

一对多集合使用bag，多对多使用set

继承类使用显式多态

表字段要少，表关联不要怕多，有二级缓存。

19、什么是ORM？

ORM是对象关系映射,类—>表，属性—>表中的列,对象—>表中的每一条数据,

是为了解决面向对象与关系数据库之间互不匹配现象的技术。

优点：使我们编程的思想更面向对象了，不用去考虑关系型数据库

20、Hibernate的主键生成策略？

1）sequence,通知Hibernate框架，主键的值采用指定序列生成，然后插入数据库，主要用于

 Oracle,DB2,不用程序员参与

 

    foo_seq// 必须加上

                            

2）identity,通知hibernate框架，主键值采用数据库自动增长机制，每次进行save()操作，hibernate都会根据（数据库）自增的方式，生成一个id值，不用程序员参与，主要用于

    mySQL , SQLServer

                        

3）uuid(西方常用),hibernate 每次进行save()操作，都会随机生成一个32的不重复的字符串，不用程序员去参与维护，PO类的Id属性必须为String

4）native 根据dialect(方言)不同,来自动的选择identity或sequence智能选择。是企业中常用的

5）assigned 不推荐使用，程序言要自己维护主键的Id值，当数据量很大时候很难维护

21、Hibernate的级联操作

1) cascade操作

            all:所有情况下都进行级练操作 ，save-update和delete

            save-update: 在进行save()/update()/saveOrUpdate时候进行级练操作

            delete:在进行delete时候进行级练操作

            all-delete-orphan   :适合集合中删除，在返回的集合中执行remove()操作

            none:在任何情况下都不进行级练操作

2) inverse属性的作用

            是否放弃维护关联关系 true放弃 false不放弃

22、Hibernate有哪5个核心接口？

Configuration接口：配置Hibernate，根据其启动hibernate，创建SessionFactory对象；

SessionFactory接口：初始化Hibernate，充当数据存储源的代理，创建session对象，sessionFactory是线程安全的，意味着它的同一个实例可以被应用的多个线程共享，是重量级、二级缓存；

Session接口：负责保存、更新、删除、加载和查询对象，是线程不安全的，避免多个线程共享同一个session，是轻量级、一级缓存；

Transaction接口：管理事务；

Query和Criteria接口：执行数据库的查询。

23、什么是重量级？什么是轻量级？

轻量级是指它的创建和销毁不需要消耗太多的资源，意味着可以在程序中经常创建和销毁session的对象；重量级意味不能随意的创建和销毁它的实例，会占用很多的资源。

24、谈谈Spring的IOC和DI

  首先想说说IoC（Inversion of Control，控制倒转）。这是spring的核心，贯穿始终。所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。这是什么意思呢，举个简单的例子，我们是如何找女朋友的？常见的情况是，我们到处去看哪里有长得漂亮身材又好的mm，然后打听她们的兴趣爱好、qq号、电话号、ip号、iq号………，想办法认识她们，投其所好送其所要，然后嘿嘿……这个过程是复杂深奥的，我们必须自己设计和面对每个环节。传统的程序开发也是如此，在一个对象中，如果要使用另外的对象，就必须得到它（自己new一个，或者从JNDI中查询一个），使用完之后还要将对象销毁（比如Connection等），对象始终会和其他的接口或类藕合起来。

  那么IoC是如何做的呢？有点像通过婚介找女朋友，在我和女朋友之间引入了一个第三者：婚姻介绍所。婚介管理了很多男男女女的资料，我可以向婚介提出一个列表，告诉它我想找个什么样的女朋友，比如长得像李嘉欣，身材像林熙雷，唱歌像周杰伦，速度像卡洛斯，技术像齐达内之类的，然后婚介就会按照我们的要求，提供一个mm，我们只需要去和她谈恋爱、结婚就行了。简单明了，如果婚介给我们的人选不符合要求，我们就会抛出异常。整个过程不再由我自己控制，而是有婚介这样一个类似容器的机构来控制。Spring所倡导的开发方式就是如此，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所

25、什么是AOP？

IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？ Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。

总结：IOC是用来管理控制对象的生命周期和对象之间的关系，通过配置文件进行注入，很好的实现了对象与对象之间解耦。

IOC工作原理：

IOC实现了工厂模式，通过读取application.xml配置文件中的标签的类，

注入到IOC容器中，通过构造或set方法注入，产生BeanFactory，

BeanFactory通过getBean方法获取对象。

 Aspect Oriented Programming (面向切面 编程)

 OOP是面向对象编程,AOP是在OOP基础之上一种更高级的设计思想.

 OOP和AOP之间也存在一些区别,OOP侧重于对象的提取和封装.

 AOP侧重于方面组件,方面组件可以理解成封装了通用功能的组件,

 方面组件可以通过配置方式灵活的切入到某一批目标对象方法上.

aop是面向切面编程，可以动态的将主线业务逻辑代码与实现功能代码分离，没有侵入性。为了更清晰的逻辑，可以让你的业务逻辑去关注自己本身的业务，而不去想一些其他的事情，将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

26、Spring的通知类型有哪些？

通知决定了方面组件功能在目标对象方法上执行的时机.

    Spring框架提供了以下5中类型通知.

    1）.前置通知

       方面功能在目标方法之前调用.

    2）后置通知

       方面功能在目标方法之后调用.(如果目标方法抛出异常则不会执行方面功能)

    3）最终通知

       方面功能在目标方法之后调用.(目标方法有无异常都会执行方面功能)

    4）环绕通知

       方面功能在目标方法之前和之后调用.

    5）异常通知

       方面功能在目标方法抛出异常之后调用.

27、什么是MVC？

MVC是一种开发模式，把业务逻辑代码与视图代码分离，通过控制器连接业务逻辑与视图。

MVC将一个应用程序分为三个部分：

Model：业务逻辑的处理。

View：代表和用户交互的界面。

Controller：控制器，连接模型层与视图层

优点:

1)代码结构层次清晰

2)就是低耦合

3)重用性高

缺点:

一个应用程序分成了三个部分开发，增加开发工作量。

28、hibernate查询方式有多少种？

主键查找：session.get()或load()

hql查询：session.createQuery(“hql”)

sql查询：session.createSQLQuery(“sql”)

criteria查询（QBC）: session.createCriteria()

29、spring中Bean的scope

目前，scope的取值有5种。 

     在Spring 2.0之前，有singleton和prototype两种

    在Spring 2.0之后，为支持web应用的ApplicationContext，推出另外三种：request，session和global session类型

singleton：在IOC容器中只存在一个实例

prototype：在IOC容器中只存在多个实例

request：使用在web应用中，相当于Servlet中的Request

session：使用在web应用中，相当于Servlet中的Session

global session：使用在web应用中，相当于Servlet中的application

30、SSH对应MVC的哪些层

Struts2：用于处理请求，调用业务逻辑

Hibernate：用于操作数据库，做持久化操作

Spring：用于管理对象，处理对象与对象之间的关系

MVC是一种开发模式，模型、视图、控制，与SSH框架的作用是两个东西，不能相互对应。

31、spring注入方式有几种

Spring四种依赖注入方式，常用1、2种，

1）Set方法注入

2）构造器注入

3）静态工厂方法注入

4）实例工厂方法注入

32.几种常见的设计模式

     单例模式 ，原型模式 ，工厂模式，代理模式，

- 工厂模式：工厂类可以根据条件生成不同的子类实例，这些子类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作（多态方法）。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。
- 代理模式：给一个对象提供一个代理对象，并由代理对象控制原对象的引用。实际开发中，按照使用目的的不同，代理可以分为：远程代理、虚拟代理、保护代理、Cache代理、防火墙代理、同步化代理、智能引用代理。
- 适配器模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起使用的类能够一起工作。
- 模板方法模式：提供一个抽象类，将部分逻辑以具体方法或构造器的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法（多态实现），从而实现不同的业务逻辑。

除此之外，还可以讲讲上面提到的门面模式、桥梁模式、单例模式、装潢模式（Collections工具类和I/O系统中都使用装潢模式）等，反正基本原则就是拣自己最熟悉的、用得最多的作答，以免言多必失。

2：spring 的事务有几种方式？谈谈spring事务的隔离级别和传播行为。

声明事务和编程事务

隔离级别：

- DEFAULT使用数据库默认的隔离级别

- READ_UNCOMMITTED会出现脏读，不可重复读和幻影读问题

- READ_COMMITTED会出现重复读和幻影读

- REPEATABLE_READ会出现幻影读

- SERIALIZABLE最安全，但是代价最大，性能影响极其严重

和传播行：

- REQUIRED存在事务就融入该事务，不存在就创建事务

- SUPPORTS存在事务就融入事务，不存在则不创建事务

- MANDATORY存在事务则融入该事务，不存在，抛异常

- REQUIRES_NEW总是创建新事务

- NOT_SUPPORTED存在事务则挂起，一直执行非事务操作

- NEVER总是执行非事务，如果当前存在事务则抛异常

- NESTED嵌入式事务

 

1． SprinMVC工作机制及为什么要用?    

1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。    

2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.    

3.DispatcherServlet请请求提交到目标Controller    

4.Controller进行业务逻辑处理后，会返回一个ModelAndView    

5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象    

6.视图对象负责渲染返回给客户端。    

 

为什么用：    

{AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务 （比 如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。    

  IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。    

Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。}

4． 如何优化Hibernate？    

1.使用单向多对一关联，不使用双向一对多    

2.灵活使用单向一对多关联    

3.不用一对一，用多对一取代    

4.配置对象缓存，不使用集合缓存    

5.一对多集合使用Bag,多对多集合使用Set    

6. 继承类使用显式多态    

7. 表字段要少，表关联不要怕多，有二级缓存撑腰  

3． 说下Hibernate的缓存机制    

Hibernate中提供了两级缓存 ，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存由hibernate管理的，一般情况下无需进行干预，一个Session做了一个查询操作，它会把这个操作的结果放在一级缓存中，如果短时间内这个session（一定要同一个session）又做了同一个操作，那么hibernate直接从一级缓存中拿，而不会再去连数据库，取数据。；

第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存可以进行配置和更改，并且可以动态加载和卸载。 Hibernate还为查询结果提供了一个查询缓存，它依赖于第二级缓存。

第一级缓存的物理介质为内存，由于内存容量有限

第二级缓存的物理介质可以是内存和硬盘，因此第二级缓存可以存放大量的数据

     

什么样的数据适合存放到第二级缓存中？

　　1、很少被修改的数据

　　2、不是很重要的数据，允许出现偶尔并发的数据

　　3、不会被并发访问的数据

　　4、参考数据

　　Hibernate的二级缓存策略的一般过程如下：

　　1) 条件查询的时候，总是发出一条select * from table_name where …. （选择所有字段）这样的SQL语句查询数据库，一次获得所有的数据对象。

　　2) 把获得的所有数据对象根据ID放入到第二级缓存中。

　　3) 当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；查不到，如果配置了二级缓存，那么从二级缓存中查；查不到，再查询数据库，把结果按照ID放入到缓存。

　　4) 删除、更新、增加数据的时候，同时更新缓存。

c) 第三方缓存的实现