（干货）java五大框架+面试

Struts，Spring，Hibernate，Spring MVC，Mybatis

MVC模式框架	控制层框架	数据持久层框架	模式
Struts	Spring	Hibernate（重量级）	SSH开发模式
SpringMVC		MyBatis（轻量级）	SSM开发模式

Struts

• 基于MVC设计模式的框架，每次请求都是一个类级别Action，都是一个Servlet

• 控制器类继承 com.opensymphony.xwork2.ActionSupport 类重写execute() 方法，请求到对应Action类时，前台属性会注入到Action类的成员属性中，对应成员属性的值，在jsp页面也可以使用Struts的标签库访问到

• web.xml文件中配置 org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter 拦截了所有的项目中的请求，进行对客户不同的请求行为的分发，分发给不同的控制器（action javabean），返回装饰页面

Struts2的优点

Struts2 是一个相当强大的Java Web开源框架，是一个基于POJO的Action的MVC Web框架。它基于当年的Webwork和XWork框架，继承其优点，同时做了相当的改进。Struts2现在在Java Web开发界的地位可以说是大红大紫，从开发人员的角度来分析，Struts2之所以能够如此的深入开发人员之心，与其优良的设计是分不开的。

1、Struts2基于MVC架构,框架结构清晰，开发流程一目了然，开发人员可以很好的掌控开发的过程。

我在项目开发过程中，一个具体的功能的开发流程是：拿到一个具体的功能需求文档和设计好的前台界面（在开发中我不负责设计页面），分析需要从前台传递哪些参数，确定参数的变量名称，在Action中设置相应的变量，这些参数在前台如何显示，并将页面上的一些控件适当使用Struts2提供的服务器端控件来代替，编写Action对应的方法来完成业务逻辑，最后，做一些与配置文件相关的设置。当然实际的开发比这个过程要复杂，涉及到数据库，验证，异常等处理。但是使用Struts2进行开发，你的关注点绝大部分是在如何实现业务逻辑上，开发过程十分清晰明了。

2、使用OGNL进行参数传递。
OGNL提供了在Struts2里访问各种作用域中的数据的简单方式，你可以方便的获取Request，Attribute，Application，Session，Parameters中的数据。大大简化了开发人员在获取这些数据时的代码量。

3、强大的拦截器
Struts2 的拦截器是一个Action级别的AOP，Struts2中的许多特性都是通过拦截器来实现的，例如异常处理，文件上传，验证等。拦截器是可配置与重用的，可以将一些通用的功能如：登录验证，权限验证等置于拦截器中以完成一些Java Web项目中比较通用的功能。在我实现的的一Web项目中，就是使用Struts2的拦截器来完成了系统中的权限验证功能。

4、易于测试
Struts2的Action都是简单的POJO，这样可以方便的对Struts2的Action编写测试用例，大大方便了Java Web项目的测试。

5、易于扩展的插件机制
在Struts2添加扩展是一件愉快而轻松的事情，只需要将所需要的Jar包放到WEB-INF/lib文件夹中，在struts.xml中作一些简单的设置就可以实现扩展。常用的Struts2的扩展可以通过这个链接找到：http://cwiki.apache.org/S2PLUGINS/home.html

6、模块化
Struts2已经把模块化作为了体系架构中的基本思想，可以通过三种方法来将应用程序模块化：
将配置信息拆分成多个文件
把自包含的应用模块创建为插件
创建新的框架特性，即将与特定应用无关的新功能组织成插件，以添加到多个应用中去。

7、全局结果与声明式异常
为应用程序添加全局的Result，和在配置文件中对异常进行处理，这样当处理过程中出现指定异常时，可以跳转到特定页面，这一功能十分实用。

说说你对struts2框架的理解?

Struts2,它是一个基于mvc设计思想的前端web层框架,主要作用就是对前端请求进行处理。他的核心是拦截器.但是他的前端控制器是一个过滤器. 它的请求拦截是基于类级别,OGNL也提供了在Struts2里访问各种作用域中的数据的简单方式.大大简化了获取数据的代码.struts2的执行流程是:

A. 页面请求传递到后台, 首先进入Struts2 的核心过滤器 StrutsPrepareAndExecutedFilter .
B. 请求进入到struts2 之后, 会根据请求的路径到 struts.xml 文件中根据 package的 namespace 属性 与 action 的 name 属性配置到请求处理的Action 类.
C. 匹配到对应 Action 类的对应方法 , 执行该方法进行业务处理, 处理完毕之后会返回一个结果视图(字符串).
D. 然后根据返回的结果视图 , 到struts.xml 中对应的Action的result结果集配置中 匹配 对应的视图页面(或action).
E. 然后根据 result 的type属性, 转发(或重定向) 对应的页面(或action).

Spring MVC

• 基于MVC设计模式的框架，类属Spring系列，可以很好的融合Spirng框架，不同于Struts每个类对应一个请求，它是方法级别的对应每个请求，更好的实现了 Resultful 风格

• Spring MVC只有一个Servlet作为整个项目的请求的分发器，找到对应请求的类，方法对应的地址

• 强大的前台视图解析器：framework，更好的处理青苔数据

• 每个请求对应的方法，都可以设置注解，可以配置对应请求的多个地址信息，限定请求方式，请求的编码等，做更多样化处理。同时还可以根据注解配置，支持json数据自动传输，和接收json数据格式

说说你对springMVC框架的理解?

Springmvc就是spring框架的一个模块,所以它可以和spring框架可以进行无缝整合,它是一个基于mvc设计思想的前端web框架,主要作用就是对前端请求进行处理。他的前端控制器是一个servlet.它的请求拦截是基于方法级别的.他的执行流程是
Spring的MVC框架主要由DispatcherServlet、处理器映射、处理器(控制器)、视图解析器、视图组成
1. 客户端请求提交到DispatcherServlet
2. 由DispatcherServlet控制器查询一个或多个HandlerMapping，找到处理请求的Controller
3. DispatcherServlet将请求提交到Controller
4. Controller调用业务逻辑处理后，返回ModelAndView
5. DispatcherServlet查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图
6. 视图负责将结果显示到客户端

Spring

• Sping是一个轻量级的DI和AOP容器框架，DI：称作依赖注入(Dependency Injection),和控制反转一个概念，具体的讲，当一个角色需要另外一个角色协助的时候，在传统的程序设计中，通常有调用者来创建被调用者的实例。但是在spring中创建被调用者将不再有调用者完成，因此叫控制反转。创建被调用对象有Spring来完成，在容器实例化对象的时候主动的将被调用者（或者说它的依赖对象）注入给调用对象，因此又叫依赖注入。

• AOP：Spring对面向切面编程提供了强有力的支持，通过它让我们将业务逻辑从应用服务（如事务管理）中分离出来，实现了高内聚开发，应用对象只关注业务逻辑，不再负责其它系统问题（如日志、事务等）。Spring支持用户自定义切面。

• 容器：Spring是个容器，因为它包含并且管理应用对象的生命周期和配置。如对象的创建、销毁、回调等。

• 框架：Spring作为一个框架，提供了一些基础功能，（如事务管理，持久层集成等），使开发人员更专注于开发应用逻辑。

优点

1.使用Spring的IOC容器，将对象之间的依赖关系交给Spring，降低组件之间的耦合性，让我们更专注于应用逻辑

2.可以提供众多服务，事务管理，WS等。

3.AOP的很好支持，方便面向切面编程。

4.对主流的框架提供了很好的集成支持，如hibernate,Struts2,JPA等

5.Spring DI机制降低了业务对象替换的复杂性。

6.Spring属于低侵入，代码污染极低。

7.Spring的高度可开放性，并不强制依赖于Spring，开发者可以自由选择Spring部分或全部

Spring 框架的优缺点 （大篇幅）

Spring的优势不言而喻：
　 1. 提供了一种管理对象的方法，可以把中间层对象有效地组织起来。一个完美的框架“黏合剂”。
　 2. 采用了分层结构，可以增量引入到项目中。
　 3. 有利于面向接口编程习惯的养成。
　 4. 目的之一是为了写出易于测试的代码。
　 5. 非侵入性，应用程序对Spring API的依赖可以减至最小限度。
　 6. 一致的数据访问介面。
　 6. 一个轻量级的架构解决方案
缺点也显而易见

1. 中断了应用程序的逻辑，使代码变得不完整，不直观。此时单从Source无法完全把握应用的所有行为。
   　2. 将原本应该代码化的逻辑配置化，增加了出错的机会以及额外的负担。
2. 时光倒退，失去了IDE的支持。在目前IDE功能日益强大的时代，以往代码重构等让人头痛的举动越来越容易。而且IDE还提供了诸多强大的辅助功能，使得 编程的门槛降低很多。通常来说，维护代码要比维护配置文件，或者配置文件+代码的混合体要容易的多。
   　4. 调试阶段不直观，后期的bug对应阶段，不容易判断问题所在。
   经典架构S（Struts）SH的优缺点
   Struts、Spring、Hibernate能流行这么多年经久不衰，自然有它的道理。J2EE最先出现的时候，我们一般是采用 JSP+Servlet+JavaBean+EJB的架构，尤其是1998年～2000年这段时间，互联网的泡沫从兴起到破裂，其波澜壮阔程度，丝毫不亚 于2008年开始的这次经济危机，在那个年代，是否掌握EJB开发技术将直接决定你的薪水能否翻一倍或者几倍。不过，Spring的作者Rod Johnson在2002年根据多年经验撰写了《Expert o-ne-on-One J2EE Design and Development》，其后又发表了著名的《Expert o-ne-on-one J2EE Development without EJB》一书，则彻底地改变了传统的J2EE一统天下的开发架构，基于Struts+Hibernate+Spring的J2EE架构也逐渐得到人们的认 可，甚至在大型的项目架构中也逐渐开始应用。下面我们分别说说Spring、Struts和Hibernate的优缺点。
   Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，使得每个层之间和类与类之间的关系，由原来的强绑定与强 耦合转变为不绑定和松耦合，直接面向接口编程，把设计与实现相分离的原则发挥到极致，对于单元测试也产生了很深远的影响。在Spring出现之前，如果某 个模块没有完成，做单独模块的单元测试还是很困难的。Spring同时也是 J2EE 应用程序开发的集成框架，因为J2EE是讲究分层理念的，Spring使得J2EE每个层之间的模块职能更加清晰。
   不过，对于大型项目的开发，Spring使得原来难以维护的类与类之间的强耦合关系，转变为更加难以维护的XML文件配置，这个工作量也是非常巨大 的，而且更容易出错。而且，随着每个应用 模块的升级，这些模块之间的版本，也不会是同步更新的，对于同一个公共组件，有的模块用的可能是1.0版本，而另 外一个功能模块用的可能是2.0版本，可怕的是1.0版本和2.0版本之间，可能还不兼容，Spring对于这些需求，就无能为力了。所以，有人说 Spring不适合大型项目开发，也是有一定道理的。最近Spring也加入了OSGI标准的实现，也是为了解决不同版本之间同时存在的这些问题。不过， 随着Spring加入的功能越来越多，Spring也就失去了轻量开源框架的特点，变得越来越笨重。
   虽然Spring现在也支持了所谓的免配置，可以通过@Autowired标签自行绑定，还可以通过 设置自动绑定加载所有的Hibernate对象，但是如果这些上百个或者数十个中的任何一个Entity对象加载失败，则整个Spring服务就启动不起 来了，这与难于部署的EJB有啥区别呢？而且，令人可笑的是，由于使用了@Autowired标签，相当一部分开发人员不再面向接口编程了，对于 Class A的实例，美其名曰由Spring自行绑定，接口也好，实际实现类也好，就在Spring配置一下就可以了。而Spring最核心的就是面向接口编程和 IOC，没有了面向接口编程，用一个 A a=new A() 来实例化一个Class，有什么不可以呢？少写了一行代码，引入了一个重量级的Spring，究竟为啥使用Spring呢？
   对于Hibernate的流行，则是由于开发人员和客户，对于Entity EJB（实体EJB）臃肿的身材及部署的困难，是在极度失望情绪下造成的。既然是轻量级解决方案，那么分布式就不是可选项，没有分布式，那么EJB就无用 武之地了。话又说回来了，Rod Johnson前些年就因为强调绝大部分企业应用是不需要分布式的，从而推出了自己轻量级的Spring解决方案。但是最近一年，随着云计算架构的兴起， 架构是否支持分布式，又是必选项了。技术架构的选型，就跟法国巴黎流行时装一样，今年流行短袖，明年流行下摆，真是典型的十年河东，十年河西。所以，像 SOA、云计算、SaaS、物联网这些大名词，不仅会给客户带来很大的困惑，同样也会给程序员、系统分析师、系统架构师、技术总监带来困惑。从肯定到否 定，再到自我否定，真是符合大自然螺旋式上升的发展规律。
   而对于Struts，它一经推出，几乎打败了当时的所有竞争对手。Struts的伟大之处，在于它对网页数据的动态绑定。虽然数据绑定不是一个新名 词，微软在1991年推出Visual Basic1.0的时候，就创造性地发明了让VB程序员又爱又恨的数据绑定，但是对于Web 编程，Struts也还是把数据绑定首次应用到了Web编程上。它能够让人们用Set和Get的形式取得网页数据，而不是单一的黑盒式的 request.getParameter()，从而使得网页数据取值进入面向对象（OO）化时代。
   Struts、Hibernate以及Spring本身都是制作精良的框架，但是对于自己产品和项目的应用，一经整合在一起，却不一定很适用。比如 说，对于数据库相关的MIS（管理信息系统）系统中，增加、修改、删除、查询功能是最基本、最常见、必不可少的。对于这些最基本的功能，不同的架构师，则 会做出不同的选择。有的架构师，选择了自动生成的理念，做一个代码自动生成器，设计好数据库表结构，单击一个脚本，或者用Eclipse插件的形式，做个 图形化生成界面，自动生成SSH框架，完成数据库的增加、修改、删除、查询操作。这么做的好处是数据库修改了，代码自动生成就可以了，使得程序员不用再维 护这些无聊的代码。不过缺陷也是致命的，一是随着Struts、Hibernate、Spring的升级，这个工具也不得不跟着升级，而做这个工具的程序 员，可能早就离开公司了，后续版本无法维护；二是如果有的业务逻辑跟这些生成的代码有交叉，数据库变更后，代码也无法再次生成了。三是公司的系统架构，则 被严重限制在SSH架构基础上，再也无法改变。有人会问：即使限制在这三种架构上，有何不好吗？假设有客户问，你的框架支持云计算吗？你总不能说”由于 Struts、Hibernate、Spring 不支持云计算架构，所以我也不支持”以此取得客户谅解吧。因此，依赖于第三方架构的产品体系架构，随着时间的推移，受到的限制会越来越大。

说说你对spring框架的理解?他的作用是什么?

    （1）aop:面向切面编程，将跟业务逻辑没有关系的代码提取出来，在调用目标方法之前或者之后执行。常用的场景，事务，日志，权限控制，异常处理等方面。
    （2）ioc:创建对象的权利，交给spring容器创建。
    （3）di：如果一个对象A需要使用另一个对象B才能实现某个功能，这时就可以说A对象依赖于B对象，而Spring容器在创建A对象时，会自动将A对象需要的B对象注入到A对象中，此过程就是依赖注入。

核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
    Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
    Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
    Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
    Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
    Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
    Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

Hibernate

• Hibernate功能强大，数据库无关性好，O/R映射能力强， Hibernate对数据库结构提供了较为完整的封装，Hibernate的O/R Mapping实现了POJO 和数据库表之间的映射，以及SQL 的自动生成和执行

• Hibernate的缺点就是学习门槛不低，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡，以及怎样用 好Hibernate方面需要你的经验和能力都很强才行，但是Hibernate现在已经是主流O/R Mapping框架，从文档的丰富性，产品的完善性，版本的开发速度都要强于Mybatis

• Hibernate 缓存机制：一级缓存 Session级别缓存 ,二级缓存 SessionFactory级别缓存

Hibernate优点与缺点。

Hibernate优点
(1) 对象/关系数据库映射(ORM)
它使用时只需要操纵对象，使开发更对象化，抛弃了数据库中心的思想，完全的面向对象思想
(2) 透明持久化(persistent)
带有持久化状态的、具有业务功能的单线程对象，此对象生存期很短。这些对象可能是普通的JavaBeans/POJO，这个对象没有实现第三方框架 或者接口，唯一特殊的是他们正与（仅仅一个）Session相关联。一旦这个Session被关闭，这些对象就会脱离持久化状态，这样就可被应用程序的任 何层自由使用。（例如，用作跟表示层打交道的数据传输对象。）
(3) 事务Transaction(org.hibernate.Transaction)
应用程序用来指定原子操作单元范围的对象，它是单线程的，生命周期很短。它通过抽象将应用从底层具体的JDBC、JTA以及CORBA事务隔离 开。某些情况下，一个Session之内可能包含多个Transaction对象。尽管是否使用该对象是可选的，但无论是使用底层的API还是使用 Transaction对象，事务边界的开启与关闭是必不可少的。
(4) 它没有侵入性，即所谓的轻量级框架
(5) 移植性会很好
(6) 缓存机制，提供一级缓存和二级缓存
(7) 简洁的HQL编程
Hibernate缺点
(1) Hibernate在批量数据处理时有弱势
(2) 针对单一对象简单的增删查改，适合于Hibernate,而对于批量的修改，删除，不适合用Hibernate,这也是OR框架的弱点；要使用数据库的特定优化机制的时候，不适合用Hibernate
Hibernate和iBATIS 优缺点比较
（注意:iBATIS 是MyBATIS的前生，也就是1.0版本）
Hibernate的特点：
Hibernate功能强大，数据库无关性好，O/R映射能力强， Hibernate对数据库结构提供了较为完整的封装，Hibernate的O/R Mapping实现了POJO 和数据库表之间的映射，以及SQL 的自动生成和执行。程序员往往只需定义好了POJO 到数据库表的映射关系，即可通过Hibernate 提供的方法完成持久层操作。程序员甚至不需要对SQL 的熟练掌握， Hibernate/OJB 会根据制定的存储逻辑，自动生成对应的SQL 并调用JDBC 接口加以执行。Hibernate的缺点就是学习门槛不低，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡，以及怎样用 好Hibernate方面需要你的经验和能力都很强才行，但是Hibernate现在已经是主流O/R Mapping框架，从文档的丰富性，产品的完善性，版本的开发速度都要强于iBATIS。

说说你对hibernate框架的理解

hibernate查询方式？
    （1）导航对象图检索方式。根据已经加载的对象，导航到其他对象。
    （2）OID检索方式。使用get或者load加载对应的对象
    （3）HQL检索方式。
    （4）QBC检索方式。
    （5）SQL检索方式。
sql与hql的区别？
    （1）sql是直接操作数据库的
    （2）hql是通过操作对象操作数据库，对大小写敏感。
一级缓存和二级缓存的区别？
    （1）一级缓存是session级别的缓存，二级缓存是sessionFactory级别的缓存。
hibernate中get和load的区别？
    get和load都是根据id获取数据。
    （1）get先查询session中对应id是否有数据，如果有则直接返回，有查询数据库，如数据库中没有则返回为null；
    （2）load方式查询session中对应id是否有数据，如果没有生成代理对象，查询数据库。如没有对应的id则抛出异常

Mybatis

• Mybatis入门简单， 即学即用，提供了数据库查询的自动对象绑定功能，而且延续了很好的SQL使用经验，对于没有那么高的对象模型要求的项目来说，相当完美

• 简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据 库修改。当系统属于二次开发,无法对数据库结构做到控制和修改,那iBATIS的灵活性将比Hibernate更适合。系统数据处理量巨大，性能要求极为 苛刻，这往往意味着我们必须通过经过高度优化的SQL语句（或存储过程）才能达到系统性能设计指标。在这种情况下iBATIS会有更好的可控性和表现。

iBATIS的特点：

iBATIS入门简单， 即学即用，提供了数据库查询的自动对象绑定功能，而且延续了很好的SQL使用经验，对于没有那么高的对象模型要求的项目来说，相当完美。iBATIS的缺 点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据 库修改。当系统属于二次开发,无法对数据库结构做到控制和修改,那iBATIS的灵活性将比Hibernate更适合。系统数据处理量巨大，性能要求极为 苛刻，这往往意味着我们必须通过经过高度优化的SQL语句（或存储过程）才能达到系统性能设计指标。在这种情况下iBATIS会有更好的可控性和表现。 
对于实际的开发进行的比较： 
1． iBATIS需要手写sql语句，也可以生成一部分，Hibernate则基本上可以自动生成，偶尔会写一些Hql。同样的需求,iBATIS的工作量比 Hibernate要大很多。类似的，如果涉及到数据库字段的修改，Hibernate修改的地方很少，而iBATIS要把那些sql mapping的地方一一修改。 
2. iBatis 可以进行细粒度的优化 
比 如说我有一个表，这个表有几个或者几十个字段，我需要更新其中的一个字段，iBatis 很简单，执行一个sql UPDATE TABLE_A SET column_1=#column_1# WHERE id=#id# 但是用 Hibernate 的话就比较麻烦了,缺省的情况下 hibernate 会更新所有字段。 当然我记得 hibernate 有一个选项可以控制只保存修改过的字段，但是我不太确定这个功能的负面效果。 
例 如：我需要列出一个表的部分内容，用 iBatis 的时候，这里面的好处是可以少从数据库读很多数据，节省流量SELECT ID, NAME FROM TABLE_WITH_A_LOT_OF_COLUMN WHERE …一般情况下Hibernate 会把所有的字段都选出来。比 如说有一个上面表有8个字段，其中有一两个比较大的字段，varchar(255)/text。上面的场景中我为什么要把他们也选出来呢？用 hibernate 的话，你又不能把这两个不需要的字段设置为lazy load，因为还有很多地方需要一次把整个 domain object 加载出来。这个时候就能显现出ibatis 的好处了。如果我需要更新一条记录（一个对象），如果使用 hibernate，需要现把对象 select 出来，然后再做 update。这对数据库来说就是两条sql。而iBatis只需要一条update的sql就可以了。减少一次与数据库的交互，对于性能的提升是非常重 要。 
3. 开发方面： 
开发效率上，我觉得两者应该差不多。可维护性方面，我 觉得 iBatis 更好一些。因为 iBatis 的 sql 都保存到单独的文件中。而 Hibernate 在有些情况下可能会在 java 代码中保sql/hql。相对Hibernate“O/R”而言，iBATIS 是一种“Sql Mapping”的ORM实现。（iBatis 是将sql写在配置文件中的，而hibernate是自己生成的） 而iBATIS 的着力点，则在于POJO 与SQL之间的映射关系。也就是说，iBATIS并不会为程序员在运行期自动生成SQL 执行。具体的SQL 需要程序员编写，然后通过映射配置文件，将SQL所需的参数，以及返回的结果字段映射到指定POJO。使用iBATIS 提供的ORM机制，对业务逻辑实现人员而言，面对的是纯粹的Java对象，这一层与通过Hibernate 实现ORM 而言基本一致，而对于具体的数据操作，Hibernate会自动生成SQL 语句，而iBATIS 则要求开发者编写具体的SQL 语句。相对Hibernate而言，iBATIS 以SQL开发的工作量和数据库移植性上的让步，为系统设计提供了更大的自由空间。 
4. 运行效率 
在不考虑 cache 的情况下，iBatis 应该会比hibernate 快一些或者很多。 

说说你对mybatis框架的理解

Mybatis的工作流程
1、  mybatis配置
	SqlMapConfig.xml，此文件作为mybatis的全局配置文件，配置了mybatis的运行环境等信息。
	mapper.xml文件即sql映射文件，文件中配置了操作数据库的sql语句。此文件需要在SqlMapConfig.xml中加载。
2、  通过mybatis环境等配置信息构造SqlSessionFactory即会话工厂
3、  由会话工厂创建sqlSession即会话，操作数据库需要通过sqlSession(DefaultSqlSession)进行。
4、  mybatis底层自定义了Executor(BaseExecutor)执行器接口操作数据库，Executor接口有两个实现，一个是基本执行器、一个是缓存执行器。
5、  Mapped Statement也是mybatis一个底层封装对象，它包装了mybatis配置信息及sql映射信息等。mapper.xml文件中一个sql对应一个Mapped Statement对象，sql的id即是Mapped statement的id。
6、  Mapped Statement对sql执行输入参数进行定义，包括HashMap、基本类型、pojo，Executor通过 Mapped Statement在执行sql前将输入的java对象映射至sql中，输入参数映射就是jdbc编程中对preparedStatement设置参数。
7、  Mapped Statement对sql执行输出结果进行定义，包括HashMap、基本类型、pojo，Executor通过 Mapped Statement在执行sql后将输出结果映射至java对象中，输出结果映射过程相当于jdbc编程中对结果的解析处理过程。

对比

Struts1、Struts2和springmvc比较

1、都是web层框架。

2、Struts1是基于servlet；Struts2是基于filter；springmvc是基于servlet 。

3、Struts1的action是单例模式，线程不安全的；Struts2 action是原型模式 prototype，每次访问对象都会创建新的实例，保证线程安全性；springmvc controller是单例模式，整个程序只有一个对象实例。Spring的安全性是通过绑定threadlocal实现。

4、Struts1使用JSTL EL表达式，但是对集合和索引属性的支持很弱。Struts2采用 OGNL。 struts2是类级别的拦截， 一个类对应一个request上下文，springmvc是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应。

5、Strust1中通常以action访问时.do，struts2、spring mvc 都是以.action做结尾。

6、spring3 mvc可以认为已经100%零配置了。

Spring MVC和Struts2的比较的优点

我们用struts2时采用的传统的配置文件的方式，并没有使用传说中的0配置。spring3 mvc可以认为已经100%零配置了（除了配置spring mvc-servlet.xml外）。

Spring MVC和Struts2的区别：

机制：spring mvc的入口是servlet，而struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是 servlet的一种特殊），这样就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。

性能：spring会稍微比struts快。spring mvc是基于方法的设计，而sturts是基于类，每次发一次请求都会实例一个action，每个action都会被注入属性，而spring基于方法，粒度更细，但要小心把握像在servlet控制数据一样。spring3 mvc是方法级别的拦截，拦截到方法后根据参数上的注解，把request数据注入进去，在spring3 mvc中，一个方法对应一个request上下文。而struts2框架是类级别的拦截，每次来了请求就创建一个Action，然后调用setter getter方法把request中的数据注入；struts2实际上是通过setter getter方法与request打交道的；struts2中，一个Action对象对应一个request上下文。

参数传递：struts是在接受参数的时候，可以用属性来接受参数，这就说明参数是让多个方法共享的。

设计思想上：struts更加符合oop的编程思想， spring就比较谨慎，在servlet上扩展。

intercepter的实现机制：struts有以自己的interceptor机制，spring mvc用的是独立的AOP方式。这样导致struts的配置文件量还是比spring mvc大，虽然struts的配置能继承，所以我觉得论使用上来讲，spring mvc使用更加简洁，开发效率Spring MVC确实比struts2高。spring mvc是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应，所以说从架构本身上spring3 mvc就容易实现restful url。struts2是类级别的拦截，一个类对应一个request上下文；实现restful url要费劲，因为struts2 action的一个方法可以对应一个url；而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了。spring3 mvc的方法之间基本上独立的，独享request response数据，请求数据通过参数获取，处理结果通过ModelMap交回给框架方法之间不共享变量，而struts2搞的就比较乱，虽然方法之间也是独立的，但其所有Action变量是共享的，这不会影响程序运行，却给我们编码，读程序时带来麻烦。

另外，spring3 mvc的验证也是一个亮点，支持JSR303，处理ajax的请求更是方便，只需一个注解@ResponseBody ，然后直接返回响应文本即可。

struts1与struts2本质区别

1 在Action实现类方面的对比：Struts 1要求Action类继续一个抽象基类；Struts 1的一个具体问题是使用抽象类编程而不是接口。Struts 2 Action类可以实现一个Action接口，也可以实现其他接口，使可选和定制的服务成为可能。Struts 2提供一个ActionSupport基类去实现常用的接口。即使Action接口不是必须实现的，只有一个包含execute方法的POJO类都可以用 作Struts 2的Action。

2 线程模式方面的对比：Struts 1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts 1 Action能做的事，并且要在开发时非凡小心。Action资源必须是线程安全的或同步的；Struts 2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。

3 Servlet依靠方面的对比：Struts 1 Action依靠于Servlet API，因为Struts 1 Action的execute方法中有HttpServletRequest和HttpServletResponse方法。Struts 2 Action不再依靠于Serzvlet API，从而答应Action脱离Web容器运行，从而降低了测试Action的难度。 当然，假如Action需要直接访问HttpServletRequest和HttpServletResponse参数，Struts 2 Action仍然可以访问它们。但是，大部分时候，Action都无需直接访问HttpServetRequest和 HttpServletResponse，从而给开发者更多灵活的选择。

4 可测性方面的对比：测试Struts 1 Action的一个主要问题是execute方法依靠于Servlet API，这使得Action的测试要依靠于Web容器。为了脱离Web容器测试Struts 1的Action，必须借助于第三方扩展：Struts TestCase，该扩展下包含了系列的Mock对象（模拟了HttpServetRequest和HttpServletResponse对象），从而 可以脱离Web容器测试Struts 1的Action类。Struts 2 Action可以通过初始化、设置属性、调用方法来测试。

5 封装请求参数的对比：Struts 1使用ActionForm对象封装用户的请求参数，所有的ActionForm必须继续一个基类：ActionForm。普通的JavaBean不能用 作ActionForm，因此，开发者必须创建大量的ActionForm类封装用户请求参数。虽然Struts 1提供了动态ActionForm来简化ActionForm的开发，但依然需要在配置文件中定义ActionForm；Struts 2直接使用Action属性来封装用户请求属性，避免了开发者需要大量开发ActionForm类的烦琐，实际上，这些属性还可以是包含子属性的Rich 对象类型。假如开发者依然怀念Struts 1 ActionForm的模式，Struts 2提供了ModelDriven模式，可以让开发者使用单独的Model对象来封装用户请求参数，但该Model对象无需继续任何Struts 2基类，是一个POJO，从而降低了代码污染。

6 表达式语言方面的对比：Struts 1整合了JSTL，因此可以使用JSTL表达式语言。这种表达式语言有基本对象图遍历，但在对集合和索引属性的支持上则功能不强；Struts 2可以使用JSTL，但它整合了一种更强大和灵活的表达式语言：OGNL（Object Graph Notation Language），因此，Struts 2下的表达式语言功能更加强大。

7 绑定值到视图的对比：Struts 1使用标准JSP机制把对象绑定到视图页面；Struts 2使用“ValueStack”技术，使标签库能够访问值，而不需要把对象和视图页面绑定在一起。

8 类型转换的对比：Struts 1 ActionForm 属性通常都是String类型。Struts 1使用Commons-Beanutils进行类型转换，每个类一个转换器，转换器是不可配置的；Struts 2使用OGNL进行类型转换，支持基本数据类型和常用对象之间的转换。

9 数据校验的对比：Struts 1支持在ActionForm重写validate方法中手动校验，或者通过整合Commons alidator框架来完成数据校验。Struts 2支持通过重写validate方法进行校验，也支持整合XWork校验框架进行校验。

10 Action执行控制的对比：Struts 1支持每一个模块对应一个请求处理（即生命周期的概念），但是模块中的所有Action必须共享相同的生命周期。Struts 2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期。开发者可以根据需要创建相应堆栈，从而和不同的Action一起使用。

JDBC编程有哪些不足之处，MyBatis是如何解决这些问题的？

① 数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。

解决：在SqlMapConfig.xml中配置数据链接池，使用连接池管理数据库链接。

② Sql语句写在代码中造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。

解决：将Sql语句配置在XXXXmapper.xml文件中与java代码分离。

③ 向sql语句传参数麻烦，因为sql语句的where条件不一定，可能多也可能少，占位符需要和参数一一对应。

解决： Mybatis自动将java对象映射至sql语句。

④ 对结果集解析麻烦，sql变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成pojo对象解析比较方便。

解决：Mybatis自动将sql执行结果映射至java对象。

SpringMVC与Struts2的主要区别？

①springmvc的入口是一个servlet即前端控制器，而struts2入口是一个filter过虑器。

②springmvc是基于方法开发，传递参数是通过方法形参，可以设计为单例或多例(建议单例)，struts2是基于类开发，传递参数是通过类的属性，只能设计为多例。

③Struts采用值栈存储请求和响应的数据，通过OGNL存取数据， springmvc通过参数解析器是将request对象内容进行解析成方法形参，将响应数据和页面封装成ModelAndView对象，最后又将模型数据通过request对象传输到页面。 Jsp视图解析器默认使用jstl。

Servlet与Struts2的主要区别？

共同点：都是MVC框架；

不同点：

1、servlet要在web.xml配置，struts2需要web.xml配置过滤器；

2、servlet不能分xml文件，struts2可以；

3、servlet需要依赖容器，httprequest，httprespones必须有容器才能初始化。action完全与容器松耦合。

4、request.getParameter()得到servlet页面的值，action可以用属性驱动，模型驱动获取。

5、servlet不利于团队开发，struts2有利于团队开发；

6、servlet没拦截器，struts2用拦截器；

7、servlet要么转发要么重定向；struts2可以自定义结果集；

8、servlet的控制器是servlet，struts2的控制器是action;

MyBatis与Hibernate有哪些不同

Mybatis和hibernate不同，它不完全是一个ORM框架，因为MyBatis需要程序员自己编写Sql语句，不过mybatis可以通过XML或注解方式灵活配置要运行的sql语句，并将java对象和sql语句映射生成最终执行的sql，最后将sql执行的结果再映射生成java对象。

Mybatis学习门槛低，简单易学，程序员直接编写原生态sql，可严格控制sql执行性能，灵活度高，非常适合对关系数据模型要求不高的软件开发，例如互联网软件、企业运营类软件等，因为这类软件需求变化频繁，一但需求变化要求成果输出迅速。但是灵活的前提是mybatis无法做到数据库无关性，如果需要实现支持多种数据库的软件则需要自定义多套sql映射文件，工作量大。

Hibernate对象/关系映射能力强，数据库无关性好，对于关系模型要求高的软件（例如需求固定的定制化软件）如果用hibernate开发可以节省很多代码，提高效率。但是Hibernate的缺点是学习门槛高，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡，以及怎样用好Hibernate需要具有很强的经验和能力才行。
总之，按照用户的需求在有限的资源环境下只要能做出维护性、扩展性良好的软件架构都是好架构，所以框架只有适合才是最好。

jdbc,mybatis,hibernate的区别

1）从层次上看，JDBC是较底层的持久层操作方式，而Hibernate和MyBatis都是在JDBC的基础上进行了封装使其更加方便程序员对持久层的操作。

2）从功能上看，JDBC就是简单的建立数据库连接，然后创建statement，将sql语句传给statement去执行，如果是有返回结果的查询语句，会将查询结果放到ResultSet对象中，通过对ResultSet对象的遍历操作来获取数据；Hibernate是将数据库中的数据表映射为持久层的Java对象，对sql语句进行修改和优化比较困难；MyBatis是将sql语句中的输入参数和输出参数映射为java对象，sql修改和优化比较方便.

3）从使用上看，如果进行底层编程，而且对性能要求极高的话，应该采用JDBC的方式；如果要对数据库进行完整性控制的话建议使用Hibernate；如果要灵活使用sql语句的话建议采用MyBatis框架。

JDBC

工作原理

主要分3个步骤:1、加载数据库驱动。2、获取数据库连接。3、发送sql语句访问数据库

1、加载数据驱动：使用Class.forName方法，调用这个方法会加载数据库驱动com.mysql.jdbc.driver。

关于数据库驱动的理解，其实是sun公司给了一个Driver的接口，然后各个数据厂商根据自己的数据库

来实现这个接口。当要访问数据库的时候，需要引入这个第三方类库。类的加载主要分为5个部分，

加载、验证、准备、解析、初始化。在初始化的部分用到了DriverManager.registerDriver()方法，将

自己注册给DriverManager的Driver接口。这个地方体现了多态。这个时候就可以使用Driver了。

2、获取数据库连接DriverManager.getConnection()。这个方法主要调用driver的connect（）方法

返回一个实现了Connection接口的对象。

3、然后利用Connection对象创建Statement，发送sql语句访问数据库。

4、访问结束关闭资源

JDBC几个步骤：

1，使用jdbc编程需要连接数据库，注册驱动和数据库信息

2，操作Connection，打开Statement对象

3，通过Statement对象执行SQL，返回结果到ResultSet对象

4，使用ResultSet读取数据，然后通过代码转化为具体的POJO对象

5，关闭数据库相关的资源

jdbc的缺点：

一：工作量比较大，需要连接，然后处理jdbc底层事务，处理数据类型，还需要操作Connection，Statement对象和ResultSet对象去拿数据并关闭他们。

二：我们对jdbc编程可能产生的异常进行捕捉处理并正确关闭资源

由于JDBC存在的缺陷，在实际工作中我们很少直接使用jdbc进行编程，用的更多的是ORM对象关系模型来操作数据库，Hibernate就是一个ORM模型

Hibernate是建立在若干POJO通过xml映射文件（或注解）提供的规则映射到数据库表上的。我们可以通过POJO直接操作数据库的数据，他提供的是一种全表映射的模型。相对而言，Hibernate对JDBC的封装程度还是比较高的，我们已经不需要写SQL，只要使用HQL语言就可以了。