中移动杭州研究院
Java web开发三大框架整理报告
Java web开发三大框架整理
目录
1．引言 (1)
2 Java Web 开发三大框架 (2)
2.1 Struts框架 (2)
2.1.1 Struts框架概述 (2)
2.1.2 Struts2 处理流程 (3)
2.1.3 Struts框架的组件分析 (4)
2.2 Hibernate框架 (6)
2.2.1 Hibernate 工作原理和工作流程 (6)
2.2.2 Hibernate框架的组件分析 (7)
2.2.3 Hibernate核心接口 (8)
2.2.4 Hibernate缓存管理 (8)
2.2.5 Hibernate框架优势 (9)
2.3 Spring框架 (9)
2.3.1 Spring框架模块 (10)
2.3.2 控制反转（IoC）和依赖注入（DI） (11)
2.3.3 面相切面编程（AOP） (12)
2.3.4 Spring框架优势 (12)
3 SSH框架整合 (12)
3.1 整合理念 (12)
3.2 整合方案 (14)
3.2.1 Spring 与Struts 的集成 (14)
3.2.2 Spring 与Hibernate的集成 (15)
3.2.3 系统分析 (15)
4 小结 (16)
1．引言
随着计算机网络技术的日益普及，基于Java的Web技术也得到了广泛的应用。然而，利用Java进行Web应用程序的软件架构非常复杂，这在很大程度上限制了Web系统的开发效率，因此轻量级J2EE框架应运而生。优秀的轻量级J2EE框架不仅保留了传统J2EE框架良好的可扩展性、可维护性等特点，还具有开发效率高、各层无缝集成等优点。
Web框架是开发者在使用某种语言编写Web应用服务端时关于架构的最佳
实践。所谓的三层开发就是将系统的整个业务应用划分为“表示层—业务逻辑层—数据访问层”，这样有利于系统的开发、维护、部署和扩展，分层是为了实现“高内聚、低耦合”。三层体系将业务规则、数据访问及合法性校验等工作放在业务逻辑层处理。客户端不直接与数据库交互，而是通过组件与中间层建立连接，再由中间层与数据库交互。
本报告探讨现在主流一种轻量级J2EE架构，即SSH(Struts +Spring +Hibernate) 框架，并对各层之间的整合技术进行研究。首先，分析了Struts、Spring和Hibernate 三种框架和各自的特点；其次，阐述了它们整合的理念，选取了一种比现有SSH 框架更加合理有效的整合方案，使其各层能够无缝集成、有机整合，最大限度地实现SSH框架的高内聚低耦合的特点。
2 Java Web 开发三大框架
2.1 Struts框架
2.1.1 Struts框架概述
Struts是一个基于MVC( Model-View -Controller)模式的应用架构开源框架，
采用Servlet和JSP技术实现，它减弱了业务逻辑接口和数据接口之间的耦合，为
开发人员节约了时间。其中Struts 的控制文件struts-config. xml、Action 和Action Servlet实现MVC 的控制器，Java Bean或者EJB完成MVC的模型部分， JSP 页面承担MVC 的视图组件，而且所有的控制逻辑都是由struts-config.xml配置文件
来完成。Struts把Servlet、JSP、自定义标签和信息资源(message resources)整合到一个统一的框架中，开发人员利用其进行开发时不用再自己编码实现全套MVC模式，极大的节省了时间。
在使用Struts框架应该遵守以下原则：
◆尽量使用Struts标签，避免嵌入Java代码；
◆避免在视图层处理对数据库的访问。
2.1.2 Struts2 处理流程
当用户端的Http请求到达时，Struts2处理流程如图2-1所示
图2-1 Struts2 处理流程
一个客户端请求在Struts 2框架中的处理大概分为以下几个步骤：
◆客户端提交一个（Http Servlet Request）请求；
◆请求被提交到一系列（主要是3层）的过滤器（Filter），如Action Context
Clean Up、Filter Dispatcher等。注意：这里是有顺序的，先Action Context Clean Up，再其他过滤器（Other Filters、Site Mesh等），最后到Filter
Dispatcher；
◆Filter Dispatcher是控制器的核心，就是MVC的Struts 2实现中控制层
（Controller）的核心；
◆Filter Dispatcher询问Action Mapper是否需要调用某个Action来处理这个
（Http Servlet Request）请求，如果Action Mapper决定需要调用某个
Action，Filter Dispatcher则把请求的处理交给Action Proxy；
◆Action Proxy通过Configuration Manager（struts.xml）询问框架的配置文件，
找到需要调用的Action类；
◆Action Proxy创建一个Action Invocation实例，同时Action Invocation通过
代理模式调用Action。但在调用之前，Action Invocation会根据配置加载Action相关的所有Interceptor（拦截器）；
◆一旦Action执行完毕，Action Invocation负责根据struts.xml中的配置找到
对应的返回结果result，最后将该result通过（Http Servlet Response）请求返回给客户端。
2.1.3 Struts框架的组件分析
（1）Struts 2配置文件
Struts 2配置文件是用户请求(View)和业务逻辑模块（Model)）Action 之间联系的桥梁,可以通过修改Struts 2的配置文件来快速适应业务需求,它是整个Struts 2的精髓之一。Struts 2框架配置文件分为XML文件和属性资源文件两种。
web.xml对web应用中一些初始信息进行了配置。web.xml可以配置过滤器用于同时拦截多个请求的URL。除此之外web.xml还可以用来配
struts.xml文件主要用来配置Action和Http请求的对应关系，以及配置逻辑视图和物理视图资源的对应关系。struts.xml文件中包含了Action的定义以及Action的返回值对应的视图资源、命名空间等信息。此外,用户也可以定义自己的XML文件,然后通过include指令将其包含到struts.xml文件中。
另一类配置文件是属性资源文件。资源文件中一般采用固定的Key -Value形式,用于定义Struts 2 全局或者局部的资源数据。例如定义国际化、开发模式等信息。
（2）Struts 2控制器
Struts 2的控制器组建是Struts 2框架的核心，事实上所有MVC框架都是以控制器组件为核心的。正如前面提到的，Struts 2的控制器由两个部分组成：Filter Dispatcher和业务控制器Action。前者由框架提供，负责拦截所有的用户请求。
◆Filter Dispatcher
负责根据用户提交的URL和struts.xml中的配置，来选择合适的Action，让这个Action来处理用户的请求。Filter Dispatcher其实是一个过滤器Filter
（Servlet规范中的一种web组件），只需要在web.xml文件中配置即可。Filter Dispatcher充分体现了J2EE核心设计模式中的前端控制器模式。
业务控制器Action
Struts 2框架为用户提供了一个名为Action Support的接口。该接口定义SUCCESS、ERROR、INPUT、LOGIN、NONE五个静态的字符串和一个execute 方法,用户在编写自己的Action时只要实现该接口并重写其中的execute方法,将所要实现的业务逻辑在该方法中处理就行了,当调用Action时,Struts 2框架会自调用execute方法来完成所需的业务逻辑处理。而且用户亦可编辑自己的函数并通过Struts 2框架调用实现。实际上,在Struts2中起作用的业务逻辑并不是用户自定义的Action ,而是系统生成的Action代理,只不过Action代理以用户定义的Action 为目标。
（3）Struts2 拦截器
拦截器（Interceptor）是Struts 2中的重要组成部分，Struts 2拦截器是在访问某个Action或Action的某个方法，字段之前或之后实施拦截，并且Struts2拦截器是可插拔的。拦截器是AOP的一种实现。使用拦截器可以给开发过程带来很多好处：可以将大问题分解成多个小问题以便于处理，使每个Action更专注于处理自己的功能。Struts 2拦截器（Interceptor Stack）就是将拦截器按一定的顺序联结成一条链。图2-2为拦截器功能图。在访问被拦截的方法或字段时，Struts2拦截器链中的拦截器就会按其之前定义的顺序被调用。Struts2拦截器的实现原理相对简单，当请求struts2的action时，Struts 2会查找配置文件，并根据其配置实例化相对的拦截器对象，然后串成一个列表，最后一个一个地调用列表中的拦截器。
图2-2 拦截器功能图
（4） Struts 2 标签库
Struts 2的标签库也是Struts 2的重要组成部分，Struts 2的标签库提供了非常丰富的功能，这些标签不仅提供了表现层数据处理，而且还提供了基本的流程控制功能，还提供了国际化、Ajax支持等功能。使用标签，开发者可以最大限度地减少页面代码的书写。
（5）Struts2 框架优势
Struts 2框架（MVC框架）的优势如下：
◆实现了MVC模式，层次结构清晰，使程序员只需关注业务逻辑的实现；
◆丰富的标签库，大大提高了开发的效率；
◆Struts2提供丰富的拦截器实现；
◆通过配置文件，就可以掌握整个系统各个部分之间的关系；
◆异常处理机制，只需在配置文件中配置异常的映射，即可对异常做相
应的处理。
2.2 Hibernate框架
Hibernate是数据持久层的一个轻量级框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，并且Hibernate是一个开源的orm（object relations mapping）框架，提供了查询获取数据的方法，用面向对象的思想来操作数据库，节省了我们开发处理数据的时间。目前使用较多且较稳定的版本是Hibernate3。
2.2.1 Hibernate 工作原理和工作流程
图2-3展示了Hibernate 的工作原理，从该图中很清楚地了解到Hibernate 框架是在物理数据库之上利用一些配置文件如hibernate.cfg.xml 文件、XML Mapping （映射文件）等来为应用系统提供数据持久化方面的服务，同时达到将应用系统的持久层与不同的物理数据库系统相互隔离开的目的。
图2-3 Hibernate 的工作原理
Hibernate工作流程：
◆读取并解析配置文件；
◆Configuration负责读取并创建映射信息，创建session factory；
◆SessionFactory负责创建session；
◆Transaction负责开启事物Transaction；
◆Query负责执行持久化操作；
◆Transaction负责提交实物；
◆关闭session和session factory。
2.2.2 Hibernate框架的组件分析
（1）Hibernate核心文件
Hibernate核心文件主要包括两种类型文件：Hibernate的配置文件和映射文件。
Hibernate的配置文件hibernate.cfg.xml可以配置JDBC的连接属性和列出所有的映射文件，对C3P0连接池提供了内嵌支持，还可以通过JNDI建立数据源，建立与数据库的连接，同时该文件可以对Hibernate的二级缓存进行管理，可以到动态加载和卸载。
映射文件用于向Hibernate提供将对象持久化到关系数据库中的相关信息，将持久化类与数据库表之间建立起映射。这意味着映射文档是按照持久化类的定义来创建的，而不是表的定义。这个xml文件默认名为*.hbm.xml。根据映射文件，Hibernate可以生成足够的信息以产生所有SQL语句，即插入、更新、删除和查询所需要的SQL语句。
2.2.3 Hibernate核心接口
Hibernate3 共有5个核心接口和1个核心类，分别是Session接口、Session Factory接口、Transaction接口、Query 接口、Criteria 接口和Configuration类。
◆Session接口
S ession 接口是Hibernate中使用最广泛的接口，主要用于对数据的增、删、改、查等操作。而这个Session 对象是非线程安全的，不能被多个线程共享。
◆Session Factory 接口
一个Session Factory对应一个数据存储源，也就是一个数据库对应一个Session Factory。Session Factory 负责创建Session对象，并且是线程安全的，可以被多个线程共享。
◆Transaction接口
Transaction 接口是Hibernate的事务接口，负责处理与事务相关的操作。
它是一个可选的应用程序编程接口，开发人员也可以选择自己设计编写底层事务的处理代码。
◆Query接口
Query 接口是Hibernate 的查询接口，负责执行数据库的各种查询。它提供了结构化的SQL和面向对象的HQL两种查询方式。
◆Criteria 接口
Criteria 接口和Query接口非常类似，它允许创建并执行面向对象方式的查询，而且更擅长于执行动态查询。
◆Configuration类
Configuration 类负责配置并引导Hibernate，创建Session Factory 对象。它包含数据库实例的配置信息，通过它可以创建一个Configuration 类的实例来管理相应的配置文档。
2.2.4 Hibernate缓存管理
Hibernate 中提供了两级Cache，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存由hibernate管理的，一般情况下无需进行干预；第二级别的缓存是Session Factory级别的缓存，它是属于进程范围或群集
范围的缓存。这一级别的缓存可以进行配置和更改，并且可以动态加载和卸载。Hibernate还为查询结果提供了一个查询缓存，它依赖于第二级缓存。
2.2.5 Hibernate框架优势
◆对象/关系数据库映射(ORM)
它使用时只需要操纵对象，使开发更对象化，抛弃了数据库中心的思想，完全的面向对象思想
◆透明持久化(persistent)
带有持久化状态的、具有业务功能的单线程对象，此对象生存期很短。
这些对象可能是普通的Java Beans/POJO，这个对象没有实现第三方框架或者接口，唯一特殊的是他们正与（仅仅一个）Session相关联。一旦这个
Session被关闭，这些对象就会脱离持久化状态，这样就可被应用程序的任何层自由使用。（例如，用作跟表示层打交道的数据传输对象。）
◆事务Transaction (org. hibernate. Transaction)
应用程序用来指定原子操作单元范围的对象，它是单线程的，生命周期很短。它通过抽象将应用从底层具体的JDBC、JTA以及CORBA事务隔离开。某些情况下，一个Session之内可能包含多个Transaction对象。尽管是否使用该对象是可选的，但无论是使用底层的API还是使用Transaction对象，事务边界的开启与关闭是必不可少的。
◆它没有侵入性，即所谓的轻量级框架
◆移植性会很好
◆缓存机制，提供一级缓存和二级缓存
◆简洁的HQL编程
2.3 Spring框架
Spring 是一个基于J2EE 平台的分层的应用程序框架，为企业级应用提供了一个轻量级的解决方案，这个方案包括声明式事务管理、通过RMI 或Web Service 远程访问业务逻辑、mail 支持工具以及对于数据持久层的各种配置的支持。Spring还提供了一个MVC 应用框架，Spring还可以通过集成A OP 透明地嵌入
软件，同时Spring 包含一个优秀的异常处理体系，这个异常体系可以自动从属性异常体系进行映射。Spring 框架的核心技术是控制反转（IoC）和面向切面编程（AOP）。
2.3.1 Spring框架模块
Spring 框架是一个分层架构，由7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理bean 的方式，如图2-4所示。
图2-4 Spring框架模块
组成Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：
◆核心容器
核心容器提供Spring 框架的基本功能。核心容器主要组件是Bean Factory，它是工厂模式的实现。Bean Factory 使用控制反转（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异常层次结构。
2.3.2 控制反转（IoC）和依赖注入（DI）
控制反转即依赖注入是Spring 应用的核心。当应用了IoC技术后，控制权就由对象本身转向容器，也就是由容器根据配置文件去创建实例并负责控制各个实例之间的依赖关系。也就是说，一个类不需要去查找或实例化它们所依赖的类。对象间的依赖关系在对象创建时由负责协调项目中各个对象的外部容器来提供并管理的。也就是强调了对象间的某种依赖关系式由容器在运行期间注入调用者的，控制程序间的关系的实现交给了外部的容器来完成。这样，当调用者需要被调用者对象时，调用者不需要知道具体的实现细节，它只需要从容器中拿出一个对象并使用就可以了。
依赖注入存在着2种实现方式，分别是设值注入和构造方法注入。
◆设值注入即Set注入（setter injection）
指IOC容器使用setter方法来注入被依赖的实例。通过调用无参结构或无参static工厂方法实例化bean后，调用该bean的setter，即可实现基于setter的依赖注入。
◆构造注入（constructor injection）
指在接受注入的类中定义一个构造方法，并在参数中定义需要注入的元素。为了让Business接受Data Base的注入，需要为它定义一个构造方法，来接受Data Base的注入。
2.3.3 面相切面编程（AOP）
AOP 将应用程序分成两大部分，即核心业务逻辑和通用逻辑。使用AOP 后，应用对象只需关注它们需要关注的核心业务逻辑即可，而无需关注通用逻辑，如大中型系统都要涉及的事务管理、安全管理、日志管理等。
AOP的出现解决了面向对象编程的局限性。AOP利用了一种称为“横切”的技术，将已封装好的对象剖开，找出其中对多个对象产生影响的公共行为，并将其封装为一个可重用的模块，这个模块可以称为“切面”。切面将与那些业务无关，却被业务模块调用的逻辑提取并封装起来，减少了系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。
Spring通常可以单纯使用aspect J进行aop，也可以spring和aspect J联合开发进行aop。spring和aspect J联合开发进行aop有两种方式，一是单纯的使用注解，二是在配置文件中进行定义。前者较为灵活强大，后者更利于管理模块化管理。
2.3.4 Spring框架优势
Spring框架的优势可以总结为以下几点：
◆能有效地组织中间层对象。可以有效地将现有框架例如Struts和Hibernate框架
组织起来；
◆实现了真正意义上的面相接口编程，可实现组件之间的高度解耦；
◆使用Spring构建的应用程序易于进行单元测试；
◆Springs所秉承的设计思想就是让使用Spring创建的那些应用都尽可能少地
依赖于它的APIs。在Spring应用中的大多数业务对象都不依赖于Spring；
◆提高了代码的可重用性，它尽可能避免在程序中使用硬编码；
◆简化了底层数据库的访问方式。
3 SSH框架整合
3.1 整合理念
一个典型的Web 应用系统，按职责一般分为三层，即表示层，业务逻辑层和
数据持久层，每一层次都有其独特的职责，不能把各自的功能与其他层次相混合。
◆表示层
位于web应用的最前端，它可以将一个数据视图呈现给用户，也可以接收用户表单在用户界面上的操作；
◆业务逻辑层
完成项目各种业务逻辑的实现，表示层通过业务层中提供的方法来完成一系列的展示工作，而业务层的业务逻辑方法需要通过与持久层的交互来实现；
◆数据持久层
将访问数据库的各种操作进行封装，提供给业务层使用。在持久化层的实现中，常常采用工厂模式和DAO模式来降低应用的业务逻辑和数据库的访问逻辑之间的关联。
采用Struts、Spring和Hibernate 框架技术可以分别实现这三层，即利用Struts 框架作为系统整体基础架构，负责MVC 的分离，在Struts 架构的Model 部分，利用Spring 支持业务逻辑，用Hibernate 支持数据持久层，具体整合架构如图3-1所示。
图3-1 Struts+ Spring+ Hibernate 整合结构
Struts 用于表示层，直接面向用户，响应用户的请求，为显示提供一个模型和一个控制器，并委派调用业务逻辑和其他上层处理等功能。
Spring在事务管理和依赖注入方面的独特能力，实现处理应用程序的业务
逻辑和业务校验，以及提供与其他层进行相互作用的接口等。
Hibernate 是ORM 的实现，利用它建立Java 对象模型的持久化对象，进而以面向对象的方式来方便地操作关系数据库．这样Struts、Spring和Hibernate 就能够很好地封装各个层次的程序，如在处理前台表示层时就不会把事务逻辑和持久化逻辑掺杂进来，从而最大限度地实现各层的高内聚低耦合目标。
3.2 整合方案
Struts、Spring 和Hibernate 的整合，有很多种不同的方案选取，若要实现SSH 框架的有机整合以及整个结构的高内聚、低耦合，就需要做出最优的选择。在这里很多项目的开发人员更愿意使用Spring去整合Struts框架和Hibernate框架。
3.2.1 Spring 与Struts 的集成
就当前来看，Spring 和Struts整合的方式主要有三种，分别如下所述:
◆使用Web Application Context
这种方式是在Struts 的Action 类中获取Spring 应用上下Web Application Context的实例化对象，通过此对象调用Bean 来实现。
◆继承Spring 的Action Support
这种方式实际上是对第一种方式的简化，当Struts的Action 类继承了Spring
的Action Support 后，直接可以使用Web Application Context对象，从而简化对Spring 应用上下文的操作。
◆将Struts 的Action 托管给Spring的IoC 容器
这种方式将Struts 的Action 以Bean 的形式托管给Spring，通过Spring IoC 容器来管理各个Action。由于前两种方式存在各种弊端，如Struts 框架对Spring 的依赖性强，若Spring 更新了版本，就必须要重写相关代码。而使用Spring 的IoC 容器来管理Action，组件依赖注入的工作由IoC 容器自动完成，实现了Spring 和Struts 的有机整合，因此本文选择第三种整合方式。
在3种框架整合的轻量级J2EE架构中, 一般采用Spring的IoC 容器来管理Struts Action。采用这种方法能够充分的利用Spring 依赖注入的优势, 而不需要显示的获取Spring的Application Context实例。Struts2与Spring集成时要用到Spring
的插件包，这个包是随着Struts2一起发布的。
当创建一个新对象时，Spring插件先使用Struts2 配置文件中的class属性与Spring配置文件中的id属性进行关联，如果能找到相应对应的关系则由Spring负责创建对象，否则仍由Struts2框架自身负责创建对象，创建后再由Spring进行装配。
3.2.2 Spring 与Hibernate的集成
Spring 对Hibernate 提供了良好的支持，如对Hibernate 异常的支持、对Hibernate 事务的支持以及对Hibernate基础实施的支持等，利用Spring 提供的local Session Factory Bean和Hibernate Transaction Manager两个组件类能很方便地实现Spring和Hibernate 的有机整合。
在系统实现中,使用了Hibernate Template 提供持久层访问模板。使用Hibernate Template 无需实现特定接口, 它只需要提供一个Session Factory的引用, 就可以执行持久化操作。Session Factory对象可以通过构造参数传入, 或者是通过设置方式传入。在Web 应用中, 通常启动时会自动加载Application Context, Session Factory 和DAO 对象都处在Spring 上下文管理下, 因此无需在代码中显示地设置,可采用依赖注入解耦Session Factory 和DAO。
3.2.3 系统分析
在SSH的整合框架中, 吸收了Struts框架在表示层方面的优点,并且由Struts 来实现页面的请求与页面的转发, Spring框架在业务层中夜发挥了巨大的作用, 由Spring容器对业务逻辑进行处理;同时, Hibernate来实现与数据库的交互,整个框架非常清晰,有利于开发人员的分工合作,使开发人员将注意力集中在业务逻辑的实现上,而不需要浪费太多的经历在页面的实现以及数据库的连接上,极大地缩短了系统的开发周期。同时使得应用逻辑与实现的代码相分离；应用逻辑没有写在代码中,而是采用了配置文件的形式来定义应用逻辑.这样,应用需求发生更改时,不需要对代码进行重新编译。而且该平台该完整的实现了MVC 模式, 实现了逻辑与显示的分离。最后整个项目的实现都是用了开源的框架,不仅降低了系统开发的费用,并且,开源还能够保证框架功能的完善。
4 小结
采用ssh框架开发的最大优势是，开发者只需要专注于完成业务的逻辑，至于操作数据库，和连接数据库等基础功能，框架已经实现。而开发过程中真正有价值的地方在业务逻辑上，框架就是把精力集中用到开发逻辑上，而不是花在项目本身的建设上，这样就会大大减少了项目的成本，极大地缩短了系统的开发周期。至于怎么提供访问控制，数据库连接，事物管理，日志分析，等等系统级功能，程序开发者只需选择完成效率最高的框架就可以实现这些功能除此之外，Spring和Struts以及Hibernate的集成做的很好，实现了敏捷开发，加快了项目的进程，同时也避免了不成熟技术造成的项目风险。而且使用SSH 框架设计的程序比较好维护，扩张，思路也很清晰。
然而对于简单的应用，采用ASP或者PHP的开发效率比采用J2EE框架的开发效率要高。对于这些简单的应用，可能采用这种分层的结构，要比一般采用JSP + Servlet的系统开发效率要低。而且Struts和Hibernate不支持分布式部署。
Java工程师（程序员）面试题 Struts,Spring,Hibernate三大框架的面试 1.Hibernate工作原理及为什么要用？ 原理：1.读取并解析配置文件2.读取并解析映射信息，创建SessionFactory 3.打开Session 4.创建事务Transation 5.持久化操作6.提交事务7.关闭Session 8.关闭SesstionFactory 为什么要用：1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。 2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作 3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。 4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。 2．Hibernate是如何延迟加载? 1. Hibernate2延迟加载实现：a)实体对象b)集合（Collection） 2. Hibernate3 提供了属性的延迟加载功能当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。 3．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系) 类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many 4.Struts1流程： 1、客户端浏览器发出HTTP请求。 2、根据web.xml配置，该请求被ActionServlet接收。 3、根据struts-config.xml配置，ActionServlet先将请求中的参数填充到ActionForm中，然后ActionServlet再将请求发送到Action 进行处理。 4、是否验证，需要验证则调用ActionForm 的validate方法，验证失败则跳转到input，成功则继续。 5、Action从ActionForm获得数据，调用javabean 中的业务方法处理数据。 6、Action返回ActionForward对象，跳转到相应JSP 页面或Action。 7、返回HTTP响应到客户端浏览器。 MVC设计模式：modal：“模型”也称业务逻辑，是正真完成任务的代码,相当与JavaBeanview：视图，其实就是显示界面，相当于JSPcontroller：控制器，他控制模型和视图的交互过程，相当于servletstruts1是基于MVC设计模式hibernate是基于ORM对象关系映射 5.struts是什么？ struts1是基于JSP和servlet的一个开源的Web应用框架，使用的是MVC的设计模式struts2是基于webwork技术的框架，是sun和webwork公司联手开发的一个功能非常齐全的框架，struts2和struts1没有任何关系，是一个全新的框架 6.spring是什么？ spring是一个集成了许多第三方框架的大杂烩，其核心技术是IOC（控制反转，也称依赖注
框架阶段测试卷 选择题(共50题，每题2分，满分100分) 1．选出不是Restrictions方法的选项（D ）。 A．eq() B．gt() C．like() D．isNULL() 2．已知系统中TBL_USER 表对应的实体类是TblUser，下列HQL 语句中正确的是 （D ）。 A．from Tbl_User B．select * from tbluser C．select TblUser from TblUser D．from TblUser t where t.uname = "15" 3．阅读下面的代码，要输出查询结果中第一条记录的用户名，正确的代码是（AD ）。 String hql = "select u.uname, u.upass from TblUser u"; Query query = session.createQuery(hql); A．Object[] arr = (Object[])query.list().iterator().next(); System.out.println(arr[0]); B．TblUser user = (TblUser)query.list().get(0); System.out.println(user.getUname()); C．String uname = (String)query.list().get(0).get(0); System.out.println(uname); D．String uname = (String)query.list().get(0)[0]; System.out.println(uname); 4．对下面代码中存在的错误，说法不正确的是（D）。 String hql = "from TblUser u where u.status = @status ";//<1> Query query = session.createQuery();//<2> query.setNamedParameter(":status","");//<3> return query.executeQuery(hql);//<4> A．第一行中的命名参数“@status”应该是“:status” B．第二行createQuery 函数应该传入hql 作为参数 C．第三行命名参数名称“:status”应该是“status” D．第四行应该是“return query.list(hql);” 5．下面代码的执行效果是（C ）。 String hql = "from TblStudent s order by s.score asc"; Query query = session.createQuery(hql); query.setFirstResult(0); query.setMaxResults(5); return query.list(); A．返回分数最高的五个学生
Hibernate框架 第一章数据结构 1.1认识数据结构 数据：是信息的载体，是能够被计算机识别、存储、计算的符号集合是计算机处理的对象的总称； 数据元素：也称为结点，是组成数据的基本单位； 数据项：是数据的最小单位； 数据对象：是具有相同特征的数据元素的集合，它是数据的子集； 数据结构：计算机存储、组织数据的方式； ●逻辑结构：指从逻辑关系上描述数据，与数据的存储无关，且独立于语言； ?线性结构：有且仅有一个开始结点和一个终端结点，所有结点最多只有一个前驱 结点和一个直接后继结点； ?非线性结构：指一个结点可能有多个直接前驱和直接后继结点。 ●存储结构：指数据元素及其关系在计算机存储时如何表示，依赖于语言； ●数据运算：通茶昂贵定义在数据的逻辑结构上。 1.2算法 是为求解一个问题需要遵循的，被清晰的制定的简单指令的集合；正确的算法有如下特点： ●用待处理问题的相关信息作为输入数据 ●对一个既定的合法输入，多次执行同一算法，总返回同一个结果（随机算法除外） ●算法中的指令是可行的，即每个指令都可以实现 ●算法中指令的数量是有限的 ●算法执行完毕后，能够输出正确的数据集合 1.3算法分析 目的在于选择合适的算法，算法分析是从复杂度来考虑的。复杂度：衡量一个算法好坏的重要手段； ●时间复杂度：以算法执行时间长短来衡量 ●空间复杂度：以算法执行占用的存储空间来衡量
第二章算法 第三章设计模式 3.1面向对象设计原则 单一职责原则：要求每个对象应该只有一种责任； 开闭原则：设计程序时对扩展开放，对修改关闭； 里氏替换原则：任何情况下，子类替换父类，不会影响程序运行； 依赖倒置原则：提倡高层不依赖底层，二者都依赖抽象； 接口隔离原则：把多个功能分开声明，不强迫客户实现不需要的功能； 迪米特原则：最少只是原则尽可能的降低访问级别； 组合/聚合复用原则：尽量不用继承达到复用类的目的，而是使用组合和聚合。 3.2设计模式分类 创建型模式：如何创建对象以及何时创建对象，工厂模式，单例模式 结构型模式：对象该如何组织以及采用什么样的结构更合理 行为型模式：规定了各个对象应该具备的职责以及对象间的通信模式 3.3什么是框架 应用程序骨架；框架技术的优势在于： ●不用再考虑公共问题，框架已经帮我们做好了 ●可以专心在业务逻辑上，保证核心业务逻辑的开发质量 ●结构统一，便于学习、维护 ●框架集成的前人的经验有助于写出稳健、性能优良并且结构优良的高质量程序 3.4主流框架 3.4.1 Struts框架 最早的Java开源框架之一，定义了通用的Controller(控制器)，通过配置文件（一般是struts-config.xml）隔离了Model(模型)和View(视图)，以Action的概念对用户请求进行了封装，是代码更清晰易读。 3.4.2 Struts2框架 新的框架特性： ●从逻辑中分离出横切关注点的拦截器 ●减少或者消除配置文件 ●贯穿整个框架的强大表达式语言 ●支持可变更和可重用的基于MVC模式的标签API
Spring是什么？ Spring是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为J2EE应用程序开发提供集成的框架。他提供依赖注入容器，目标是使现有的技术更加易用，促进良好的编程习惯。 Spring框架是一个分层架构，由7个定义良好的模块组成。Spring模块构建在核心容器之上，核心容器定义了创建、配置和管理bean的方式 Spring的6大容器 1、核心容器：核心容器提供Spring框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。 2、Spring（JEE）上下文：Spring上下文是一个配置文件，向Spring框架提供上下 文信息。Spring上下文包括企业服务，例如JNDI、EJB、电子邮件、国际化、校验和调度功能。 3、Spring AOP：通过配置管理特性，Spring AOP模块直接将面向方面的编程功能集 成到了Spring框架中。所以，可以很容易地使Spring框架管理的任何对象支持AOP。Spring AOP模块为基于Spring的应用程序中的对象提供了事务管理服务。通过使用Spring AOP，不用依赖EJB组件，就可以将声明性事务管理集成到应用程序中。 4、Spring DAO：JDBC DAO抽象层提供了有意义的异常层次结构，可用该结构来管 理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO的面向JDBC的异常遵从通用的DAO异常层次结构。 5、Spring ORM：Spring框架插入了若干个ORM框架，从而提供了ORM的对象关 系工具，其中包括JDO、Hibernate和iBatis SQL Map。所有这些都遵从Spring的通用事务和DAO异常层次结构。 6、Spring Web模块：Web上下文模块建立在应用程序上下文模块之上，为基于Web 的应用程序提供了上下文。所以，Spring框架支持与Jakarta Struts的集成。Web模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。 7、Spring MVC框架：MVC框架是一个全功能的构建Web应用程序的MVC实现。 通过策略接口，MVC框架变成为高度可配置的，MVC容纳了大量视图技术，其中包括JSP、Velocity、Tiles、iText和POI。 Spring框架的功能可以用在任何J2EE服务器中，大多数功能也适用于不受管理的环境。Spring的核心要点是：支持不绑定到特定J2EE服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同J2EE环境（Web或EJB）、独立应用程序、测试环境之间重用。
ooa(object oriented analysis)面向对象分析 ood(object oriented design)面向对象设计 Oop 面向对象编程 Spring javabean的生命周期 配置初始化调用销毁 Spring 1、spring原理 2、IoC概念：控制权由对象本身转向容器：由容器根据配置文件区创建实例并创建各个实例之间依赖关系。 spring的最大作用ioc/di,将类与类的依赖关系写在配置文件中， 程序在运行时根据配置文件动态加载依赖的类，降低的类与类之间 的藕合度。它的原理是在applicationContext.xml加入bean标记, 在bean标记中通过class属性说明具体类名、通过property标签说明 该类的属性名、通过constructor-args说明构造子的参数。其一切都是 返射，当通过applicationContext.getBean(―id名称‖)得到一个类实例时， 就是以bean标签的类名、属性名、构造子的参数为准，通过反射实例对象， 唤起对象的set方法设置属性值、通过构造子的newInstance实例化得到对象。 正因为spring一切都是反射，反射比直接调用的处理速度慢，所以这也是spring 的一个问题。 spring第二大作用就是aop，其机理来自于代理模式，代理模式 有三个角色分别是通用接口、代理、真实对象 代理、真实对象实现的是同一接口，将真实对象作为 代理的一个属性，向客户端公开的是代理，当客户端 调用代理的方法时，代理找到真实对象，调用真实对象 方法，在调用之前之后提供相关的服务，如事务、安全、 日志。其名词分别是代理、真实对象、装备、关切点、连接点。 2、动态代理:不用写代理类，虚拟机根据真实对象实现的接口产生一个类，通过 类实例化一个动态代理，在实例化动态代理时将真实对象 及装备注入到动态代理中，向客户端公开的是动态代理， 当客户端调用动态代理方法时，动态代理根据类的返射得
一.在MyEclipse里先建立一个Web project 的项目，选最新版本的java ee。 二.添加struts2框架支持 1.引入struts2必须得几个jar包，放在WebRoot->WEB-INF->lib 目录下。 2.将WEB应用部署到tomcat服务器上：找到tomacat的安装目录Tomcat6.x\apache-tomcat-6.0.33\conf，打开其中的server.xml文件，在文件末尾上面加入例如
器将部署好的应用纳入到struts2的管辖范围类，具体代码如下
三大框架 ·Java三大框架各自的作用是什么？ struts：主要负责表示层的显示 spring：利用它的IOC和AOP来处理控制业务（负责对数据库的操作） hibernate：主要作用是数据的持久化到数据库 一、Spring Spring是一个解决了许多在J2EE开发中常见的问题的强大架。Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯。光谷校区专业老师指出，Spring的架构基础是基于使用JavaBean属性的Inversion of Control容器。然而，这仅仅是完整图景中的一部分：Spring在使用IoC 容器作为构建完关注所有架构层的完整解决方案方面是独一无二的。 Spring提供了唯一的数据访问抽象，包括简单和有效率的JDBC框架，极大的改进了效率并且减少了可能的错误。Spring的数据访问架构还集成了Hibernate 和其他O/R?mapping解决方案。Spring还提供了唯一的事务管理抽象，它能够在各种底层事务管理技术，例如JTA或者JDBC事务提供一个一致的编程模型。Spring 提供了一个用标准Java语言编写的AOP框架，它给POJOs提供了声明式的事务管理和其他企业事务--如果你需要--还能实现你自己的aspects。这个框架足够强大，使得应用程序能够抛开EJB的复杂性，同时享受着和传统EJB相关的关键服务。Spring还提供了可以和IoC容器集成的强大而灵活的MVCWeb框架。 二、Structs 说到Struts框架，它是一个基于Sun J2EE平台的MVC框架，主要是采用Servlet 和JSP技术来实现的。由于Struts能充分满足应用开发的需求，简单易用，敏捷迅速，在过去的一年中颇受关注。Struts把Servlet、JSP、自定义标签和信息资源(message resources)整合到一个统一的框架中，开发人员利用其进行开发时不用再自己编码实现全套MVC模式，极大的节省了时间，所以说Struts是一个非常不错的应用框架。 三、Hibernate Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序实用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate 可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。
Struts的原理和优点. Struts工作原理 MVC即Model-View-Controller的缩写，是一种常用的设计模式。MVC 减弱了业务逻辑接口和数据接口之间的耦合，以及让视图层更富于变化。MVC的工作原理,如下图1所示： Struts 是MVC的一种实现，它将Servlet和JSP 标记（属于J2EE 规范）用作实现的一部分。Struts继承了MVC的各项特性，并根据J2EE的特点，做了相应的变化与扩展。Struts的工作原理， 视图：主要由JSP生成页面完成视图，Struts提供丰富的JSP 标签库：Html，Bean，Logic，Template等，这有利于分开表现逻辑和程序逻辑。 控制：在Struts中，承担MVC中Controller角色的是一个Servlet，叫ActionServlet。ActionServlet是一个通用的控制组件。这个控制组件提供了处理所有发送到Struts的HTTP请求的入口点。它截取和分发这些请求到相应的动作类（这些动作类都是Action类的子类）。另外控制组件也负责用相应的请求参数填充Action From（通常称之为FromBean）,并传给动作类（通常称之为ActionBean）。动作类实现核心商业逻辑，它可以访问java bean 或调用EJB。最后动作类把控制权传给后续的JSP 文件，后者生成视图。所有这些控制逻辑利用Struts-config.xml文件来配置。 模型：模型以一个或多个java bean的形式存在。这些bean分为三类：Action Form、Action、JavaBean or EJB。Action Form通常称之为FormBean，封装了来自于Client的用户请求信息，如表单信息。Action通常称之为ActionBean，获取从ActionSevlet传来的FormBean，取出FormBean中的相关信息，并做出相关的处理，一般是调用Java Bean或EJB等。 流程：在Struts中，用户的请求一般以*.do作为请求服务名，所有的*.do请求均被指向ActionSevlet，ActionSevlet根据Struts-config.xml中的配置信息，将用户请求封装成一个指定名称的FormBean，并将此FormBean传至指定名称的ActionBean，由ActionBean完成相应的业务操作，如文件操作，数据库操作等。每一个*.do均有对应的FormBean名称和ActionBean名称，这些在Struts-config.xml中配置。 核心：Struts的核心是ActionSevlet，ActionSevlet的核心是Struts-config.xml。 Struts优缺点 优点： 1.开源软件，能更深入的了解其内部实现机制。 2.Taglib标记库，灵活动用，能大大提高开发效率。 3.页面导航使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时，这种优势体现得更加明显。
JAVA中常说的三大框架指：SSH 即：Spring、Struts、Hibernate Spring：功能强大的组件粘合济，能够将你的所有的java功能模块用配置文件的方式组合起来（还让你感觉不到spring的存在）成为一个完成的应用 Struts：不说了，大名鼎鼎的功能强大的MVC架构 Hibernate：强大的ORM工具，然后很方便将数据库记录转化为java的实体实例，将java 的实体实例很容易的保存到数据库中，如果你不需要很复杂的数据库访问，利用它你根本就不用了解数据库的细节 Java工程师（程序员）面试题 Struts,Spring,Hibernate三大框架的面试 1.Hibernate工作原理及为什么要用？原理： 1.读取并解析配置文件 2.读取并解析映射信息，创建SessionFactory 3.打开Session 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory 为什么要用： 1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。 2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作 3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。 4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。2．Hibernate是如何延迟加载? 1. Hibernate2延迟加载实现：a)实体对象 b)集合（Collection） 2. Hibernate3 提供了属性的延迟加载功能当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。 3．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系) 类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many 4.Struts1流程： 1、客户端浏览器发出HTTP请求。 2、根据web.xml配置，该请求被ActionServlet接收。 3、根据struts-config.xml配置， ActionServlet先将请求中的参数填充到ActionForm中，然后ActionServlet再将请求发送到Action 进行处理。 4、是否验证，需要验证则调用ActionForm的validate方法，验证失败则跳转到input，成功则继续。 5、Action从ActionForm获得数据，调用javabean 中的业务方法处理数据。 6、Action返回ActionForward 对象，跳转到相应JSP页面或Action。 7、返回HTTP响应到客户端浏览器。 MVC设计模式：modal：“模型”也称业务逻辑，是正真完成任务的代码,相当与JavaBeanview：视图，其实就是显示界面，相当于JSPcontroller：控制器，他控制模型和视图的交互过程，相当于servletstruts1是基于MVC设计模式hibernate是基于ORM对象关系映射 5.struts是什么？
Java 三大框架期末复习试题 大学准备期末复习以及准备职业面试之用 本资料有齐全的选择题，简单题，编程题； 绝对实用； Hibernate部分 一、单选题(共50题,每题2分) 1．下面不属于持久化的是（a）。 A．把对象转换为字符串的形式通过网络传输，在另一端接收到这个字符串后能把 对象还原出来 B．把程序数据从数据库中读出来 C．从XML配置文件中读取程序的配置信息 D．把程序数据保存为文件 2．下面（a ）不属于关系—对象映射的映射信息。 A．程序包名到数据库库名的映射 B．程序类名到数据库表名的映射 C．实体属性名到数据库表字段的映射 D．实体属性类型到数据库表字段类型的映射 3．下面（ab）不是Hibernate 映射文件中包含的内容。（选两项） A．数据库连接信息 B．Hibernate 属性参数 C．主键生成策略 D．属性数据类型 4．下面的程序执行后没有报错，但数据总保存不到数据库，最可能的原因是（d ）。 public static void main(String[] args) { SessionFactory sf = new Configuration().configure().buildSessionFactory(); Session session = sf.openSession(); Medal medal = new Medal(); medal.setOwner("Shen Baozhi"); medal.setSport("Table Tennis-Women's Singles"); medal.setType("Gold Medal"); session.save(user); session.close(); }
Oracle锁是数据库用于保持并发访问数据的安全性，为了防止数据位滥用 悲观锁：在事务开始是就枷锁，当提交，或者回滚时，释放锁，所以数据量大的时候，用悲观锁 乐观锁：一开始时，不加锁，等提交或者撤销时，才释放锁，数据量小的时候用乐观锁 锁的级别：行级锁，表级锁，表空间级，数据库级 缓存的作用：减少数据库的访问量，保证缓存中的对象与数据库的相关记录同步 缓存使用的范围：很少被修改的数据，不是很重要的数据，允许出现偶尔并发的问题，不会被并发访问的数据，参考数据 不适合使用缓存的范围：经常被修改的数据，财务数据，其他应用共享的数据 1.servlet： servlet的实现： <1>实现servlet接口 <2>继承httpservlet <3>继承GenericServlet servlet的定义： Servlet是一种服务器端的Java应用程序，也是一种使用Java编写的CGI（通用网关接口）程序，具有独立于平台和协议的特性,可以生成动态的Web页面。它担当客户请求（Web 浏览器或其他HTTP客户程序）与服务器响应（HTTP服务器上的数据库或应用程序）的中
间层。Servlet是位于Web 服务器内部的服务器端的Java应用程序，与传统的从命令行启动的Java应用程序不同，Servlet由Web服务器进行加载，该Web服务器必须包含支持Servlet 的Java虚拟机 servlet的生命周期： servlet有良好的生存期的定义，包括如何加载、实例化、初始化、处理客户端请求以及销毁。 <1>、加载和实例化 web容器负责加载和实例化一个servlet。实例化和加载可以发生在引擎启动的时候，也可以推迟到容器需要该servlet为客户请求服务的时候.首先容器必须先定位servlet类，在必要的情况下，web容器使用Java类加载工具加载该servlet(),
1.Hibernate工作原理及为什么要用？ 工作原理： 1.读取并解析配置文件 2.读取并解析映射信息，创建SessionFactory 3.打开Session 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory 为什么要用： 1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的 重复性代码。 2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM 实现。他很大程度的简化DAO层的编码工作 3. hibernate使用Java反射机制，而不 是字节码增强程序来实现透明性。 4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。 2．Hibernate是如何延迟加载? 1. Hibernate2延迟加载实现：a)实体对象 b)集合（Collection） 2. Hibernate3 提供了属性的延迟加载功能当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟 加载，他节省了服务器的内存开销，从而提高了服务器的性能。 3．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系) 类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、 one-to-many、many-to-many 4.Struts1流程： 1、客户端浏览器发出HTTP请求。 2、根据web.xml配置，该请求被ActionServlet接收。 3、根据struts-config.xml配置， ActionServlet先将请求中的参数填充到ActionForm中，然后ActionServlet再将请求发送到Action 进行处理。 4、是否验证， 需要验证则调用ActionForm的validate方法，验证失败则跳转到input，成功则继续。 5、Action从ActionForm获得数据，调用javabean 中的业务方法处理数据。 6、Action返回ActionForward对象，跳转到相应JSP页面或Action。 7、返回HTTP响应 到客户端浏览器。
JAVA三大框架用来做WEN应用。 struts主要负责表示层的显示 spring利用它的IOC和AOP来处理控制业务（负责对数据库的操作）hibernate主要是数据的持久化到数据库 Struts、Hibernate和Spring是我们Java开发中的常用关键，他们分别针对不同的应用场景给出最合适的解决方案。但你是否知道，这些知名框架最初是怎样产生的? 我们知道，传统的Java Web应用程序是采用JSP+Servlet+Javabean来实现的，这种模式实现了最基本的MVC分层，使的程序结构分为几层，有负责前台展示的JSP、负责流程逻辑控制的Servlet以及负责数据封装的Javabean。但是这种结构仍然存在问题：如JSP页面中需要使用符号嵌入很多的Java代码，造成页面结构混乱，Servlet和Javabean负责了大量的跳转和运算工作，耦合紧密，程序复用度低等等。 Struts 为了解决这些问题，出现了Struts框架，它是一个完美的MVC实现，它有一个中央控制类(一个Servlet)，针对不同的业务，我们需要一个Action类负责页面跳转和后台逻辑运算，一个或几个JSP页面负责数据的输入和输出显示，还有一个Form类负责传递Action和JSP中间的数据。JSP中可以使用Struts框架提供的一组标签，就像使用HTML标签一样简单，但是可以完成非常复杂的逻辑。从此JSP页面中不需要出现一行包围的Java代码了。 可是所有的运算逻辑都放在Struts的Action里将使得Action类复用度低和逻辑混乱，所以通常人们会把整个Web 应用程序分为三层，Struts负责显示层，它调用业务层完成运算逻辑，业务层再调用持久层完成数据库的读写。 使用JDBC连接来读写数据库，我们最常见的就是打开数据库连接、使用复杂的SQL语句进行读写、关闭连接，获得的数据又需要转换或封装后往外传，这是一个非常烦琐的过程。 Hibernate 这时出现了Hibernate框架，它需要你创建一系列的持久化类，每个类的属性都可以简单的看做和一张数据库表的属性一一对应，当然也可以实现关系数据库的各种表件关联的对应。当我们需要相关操作是，不用再关注数据库表。我们不用再去一行行的查询数据库，只需要持久化类就可以完成增删改查的功能。使我们的软件开发真正面向对象，而不是面向混乱的代码。我的感受是，使用Hibernate比JDBC方式减少了80%的编程量。 现在我们有三个层了，可是每层之间的调用是怎样的呢?比如显示层的Struts需要调用一个业务类，就需要new一个业务类出来，然后使用;业务层需要调用持久层的类，也需要new一个持久层类出来用。通过这种new的方式互相调用就是软件开发中最糟糕设计的体现。简单的说，就是调用者依赖被调用者，它们之间形成了强耦合，如果我想在其他地方复用某个类，则这个类依赖的其他类也需要包含。程序就变得很混乱，每个类互相依赖互相调用，复用度极低。如果一个类做了修改，则依赖它的很多类都会受到牵连。为此，出现Spring框架。 Spring Spring的作用就是完全解耦类之间的依赖关系，一个类如果要依赖什么，那就是一个接口。至于如何实现这个接口，这都不重要了。只要拿到一个实现了这个接口的类，就可以轻松的通过xml配置文件把实现类注射到调用接口的那个类里。所有类之间的这种依赖关系就完全通过配置文件的方式替代了。所以Spring框架最核心的就是所谓的依赖注射和控制反转。 现在的结构是，Struts负责显示层，Hibernate负责持久层，Spring负责中间的业务层，这个结构是目前国内最流行的Java Web应用程序架构了。另外，由于Spring使用的依赖注射以及AOP(面向方面编程)，所以它的这种内部模式非常优秀，以至于Spring自己也实现了一个使用依赖注射的MVC框架，叫做Spring MVC，同时为了很好的处理事物，Spring集成了Hibernate，使事物管理从Hibernate的持久层提升到了业务层，使用更加方便和强大。
Tomcat （服务器） Client （客户） Struts2Filter (配置在web.xml 中拦截过滤) 依赖web.xml(过滤) struts.xml namespac Service (层) (业务逻辑层) DB (数据库) Action (层) (控制层) DAO (层) (数据持久化、基于对象pojo ) pojo (实体类) Interceptor (过滤器、过滤) 通过action 中set 方法过滤(类型匹配) result （input 视图） 通过tomcat 响应到客户端 找 到 result Action 中得到Service 层对象是通过Spring 注入 Service 层得到DAO 层对象也是通过Spring 注入的。 要把数据保存+开启事务+提交事务 由Spring 来管理的。 Spring 穿插于整个请求过程中（或流程中） ~~~~~~~~~~~~~~~~~★ 三 层 架 构 ★ ★三层架构流程图★ Spring 注入HibernateTemplate 对象 Spring 注入DAO (层) 对象、并管理事务 Spring 注入Service (层)对象
说明: 三大框架整合称为三层架构。三层架构不是MVC，可以牵强的认为是MVC。 三层架构有三个MVC: 其中Struts2就是个MVC框架（就是指三层架构中的视图层）、 Spring内部有一个MVC框架（Spring内部包含一个MVC）、 三层架构本身也是一个MVC（牵强的认为）。 Client + Tomcat + web.xml + Struts2Filter + Struts.xml + Action（控制器） ★★★★（视图层） 三层架构思想：Service（层）（业务逻辑层）DAO + pojo + DB （模型层:model）
中移动杭州研究院 Java web开发三大框架整理报告 Java web开发三大框架整理 目录 1．引言 (1) 2Java Web开发三大框架 (2) 2.1Struts框架 (2) 2.1.1Struts框架概述 (2) 2.1.2Struts2处理流程 (3) 2.1.3Struts框架的组件分析 (4)
2.2Hibernate框架 (6) 2.2.1Hibernate工作原理和工作流程 (6) 2.2.2Hibernate框架的组件分析 (7) 2.2.3Hibernate核心接口 (8) 2.2.4Hibernate缓存管理 (8) 2.2.5Hibernate框架优势 (9) 2.3Spring框架 (9) 2.3.1Spring框架模块 (10) 2.3.2控制反转（IoC）和依赖注入（DI） (11) 2.3.3面相切面编程（AOP） (12) 2.3.4Spring框架优势 (12) 3SSH框架整合 (12) 3.1整合理念 (12) 3.2整合方案 (14) 3.2.1Spring与Struts的集成 (14) 3.2.2Spring与Hibernate的集成 (15) 3.2.3系统分析 (15) 4小结 (16) 1．引言 随着计算机网络技术的日益普及，基于Java的Web技术也得到了广泛的应用。然而，利用Java进行Web应用程序的软件架构非常复杂，这在很大程度上限制了Web系统的开发效率，因此轻量级J2EE框架应运而生。优秀的轻量级J2EE框架不仅保留了传统J2EE框架良好的可扩展性、可维护性等特点，还具有开发效率高、各层无缝集成等优点。
框架和项目模拟面试题目 -------- 于洋整理 1. Struts2 框架题目 1.1. struts2 工作流程 Struts 2框架本身大致可以分为3个部分： 核心控制器FilterDispatcher、业务控制器Action和用户实现的企业业务逻辑组件。
核心控制器FilterDispatcher是Struts 2框架的基础， 包含了框架内部的控制流程和处理机制。 业务控制器Action和业务逻辑组件是需要用户来自己实现的。 用户在开发Action和业务逻辑组件的同时，还需要编写相关的配置文件， 供核心控制器FilterDispatcher来使用。 Struts 2的工作流程相对于Struts 1要简单，与WebWork框架基本相同， 所以说Struts 2是WebWork的升级版本。基本简要流程如下： 1 、客户端初始化一个指向Servlet容器的请求； 2、这个请求经过一系列的过滤器（Filter） （这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器， 这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin） 3 、接着FilterDispatcher被调用， F ilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action 4、如果ActionMapper决定需要调用某个Action， F ilterDispatcher把请求的处理交给ActionProxy 5、ActionProxy通过Configuration Manager询问框架的配置文件， 找到需要调用的Action类 6、ActionProxy创建一个ActionInvocation的实例。 7、ActionInvocation实例使用命名模式来调用， 在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。 8、一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是（但不总是，也可能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2 框架中继承的标签。在这个过程中需要涉及到ActionMapper 9、响应的返回是通过我们在web.xml中配置的过滤器 10、如果ActionContextCleanUp是当前使用的，则FilterDispatecher将不会清理sreadlocal ActionContext;如果ActionContextCleanUp不使用，则将会去清理sreadlocals。 1.2.过滤器Filter和struts2拦截器的区别 1、拦截器是基于java反射机制的，而过滤器是基于函数回调的。 2、过滤器依赖于servlet容器，而拦截器不依赖于servlet容器。 3、拦截器只能对Action请求起作用，而过滤器则可以对几乎所有请求起作用。 4、拦截器可以访问Action上下文、值栈里的对象，而过滤器不能。 1.3.为什么要使用struts2框架 Struts2 是一个相当强大的Java Web开源框架，是一个基于POJO的Action的MVC Web 框架。它基于当年的Webwork和XWork框架，继承其优点，同时做了相当的改进。