三大框架的基础知识

1，hibernate的工作原理及为什么要用？

（1）通过Configuration().configure();读取并解析hibernate.cfg.xml配置文件；

（2）由 hibernate.cfg.xml读取并解析映射信息；

（3）通过config.buildSessionFactory(); //创建SessionFactory;

(4) sessionFactory.openSession(); //打开session

(5) session.beginTransaction(); //创建事务Transation

(6) persistent operate 持久化操作

(7) session.getTransactionFactory.commit();//提交事务

(8) 关闭session

(9) 关闭sessionFactory

2,为什么要用？

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

（2） Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作（3） hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。

（4） hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

3，Hibernate是如何延迟加载?

（1）Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）

（2）Hibernate3 提供了属性的延迟加载功能：

当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。

4，Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)

类与类之间的关系主要体现在表与表之间的关系进行操作，它们都是对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many实现。

5，说下Hibernate的缓存机制

（1）内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存

（2）二级缓存： a) 应用及缓存 b) 分布式缓存条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非关键数据 c) 第三方缓存的实现一级缓存：session级的缓存也叫事务级的缓存，只缓存实体，生命周期和session一致。不能对其进行管理。

二级缓存：sessionFactory缓存，也叫进程级的缓存，使用第3方插件实现的，也值缓存实体，生命周期和sessionFactory一致，可以进行管理。首先配置第3放插件，我们用的是EHCache，在hibernate.cfg.xml文件中加入 true 在映射中也要显示的调用，二级缓存之查询缓存：对普通属性进行缓存。如果关联的表发生了修改，那么查询缓存的生命周期也结束了。在程序中必须手动启用查询缓存：query.setCacheable(true);/

6．如何优化Hibernate？

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

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

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

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

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

6. 继承类使用显式多态

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

7，阐述struts2的执行流程。

Struts 2框架本身大致可以分为3个部分：核心控制器FilterDispatcher、业务控制器Action和用户实现的企业业务逻辑组件。

核心控制器FilterDispatcher是Struts 2框架的基础，包含了框架内部的控制流程和处理机制。业务控制器Action和业务逻辑组件是需要用户来自己实现的。用户在开发Action和业务逻辑组件的同时，还需要编写相关的配置文件，供核心控制器FilterDispatcher来使用。 Struts 2的工作流程相对于Struts 1要简单，与WebWork框架基本相同，所以说Struts 2是WebWork的升级版本。

基本简要流程如下：

1、客户端浏览器发出HTTP请求。

2、根据web.xml配置，该请求被FilterDispatcher接收。

3、根据struts.xml配置，找到需要调用的Action类和方法，并通过IOC方式，将值注入给Aciton。

4、Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。

5、Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面。

6、返回HTTP响应到客户端浏览器。

8,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类组件构成：控制器组件、模型组件、视图组件

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生成动态的网页，返回给客户。

MVC模式知识点 ——补充：

MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。MVC被独特的发展起来用于映射传统的输入、处理和输出功能在一个逻辑的图形化用户界面的结构中。

MVC开始是存在于桌面程序中的，M是指业务模型，V是指用户界面，C则是控制器，使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。比如一批统计数据可以分别用柱状图、饼图来表示。C存在的目的则是确保M和V的同步，一旦M改变，V应该同步更新。

spring工作机制及为什么要用?

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 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。}

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图 1 所示。组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下： ☆ 核心容器：核心容器提供 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。 Spring 框架的功能可以用在任何 J2EE 服务器中，大多数功能也适用于不受管理的环境。

Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同 J2EE 环境（Web 或 EJB）、独立应用程序、测试环境之间重用。 IOC 和 AOP 控制反转模式（也称作依赖性介入）的基本概念是：不创建对象，但是描述创建它们的方式。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。容器（在 Spring 框架中是 IOC 容器）负责将这些联系在一起。在典型的 IOC 场景中，容器创建了所有对象，并设置必要的属性将它们连接在一起，决定什么时间调用方法。下表列出了 IOC 的一个实现模式。

三大框架顾名思义就是非常有名的Struts2 ，Hibernate，Spring，

框架整合的方法很多，现在我写一个非常简单的整合过程，相信大家一看就会！

这里使用的struts-2.2.1.1、hibernate-3.2.0、spring2.5.6

第一步，搭建Struts2环境

　　1、导入struts2的jar包(直接把struts-blank项目下的依赖库coypy到自己项目中)

　　2、配置web.xml，增加struts2提供的过滤器(参考struts-blank项目)

   View Code 

　　3、建立包：com.qcf.struts.test，并增加普通java类，代码如下：

   View Code 

　　4、在src下增加struts.xml，并增加FirstAction类的配置内容：

   View Code 

　　5、增加ok.jsp页面，用来显示FirstAction中的属性msg：

   View Code 

　　测试成功！

第二步：搭建Hibernate环境

　　1、导入hibernate所需要的基本的jar包

　　2、添加hibernate.cfg.xml配置文件

　　　　打开etc目录，将hibernate.cfg.xml拷贝到项目src下

　　　　修改配置文件hibernate.cfg.xml内容，结合etc/hibernate.properties（文件中搜索”mysql”），完成后配置内容如下：

   View Code 

　　3、新建pojo类(Plain Old Java Objects 简单的java对象，实际上就是我们讲的普通javabean对象)：User

   View Code 

　　4、增加映射文件User.hbm.xml（写法可以参考：eg/User.hbm.xml）

　　　　映射文件hbm.xml说明了pojo类和表的对应关系，以及pojo类中属性和表中字段的对应关系。

　　　　注：本映射文件增加到跟pojo同一个包中

   View Code 

　　5、在hibernate.cfg.xml中增加User.hbm.xml文件的配置，让hibernate知道本映射关系。在<session-factory>元素下增加：

　　6、修改hibernate.cfg.xml文件，在<session-factory>下增加hbm2ddl.auto的配置：

　　<property name="hibernate.hbm2ddl.auto">update</property>

– create-drop: 运行时，先创建，运行完，在删除。

– create:每次运行前都会删除已有的。在创建。测试时，可以使用create.

– update:映射文件和表。不会重新创建表及不会重新执行ddl语句，只会更新表中的记录。

– validate:看映射文件和表是不是对应，如果不对应，他也不会更新，会报错。经常用它，保险一些。

　　7、增加Test.java测试类：

   View Code 

　　8、上一次执行，我们发现表创建成功但是数据记录并没有插入表中。jdbc是自动提交，autocommit。hibernate缺省是false. 因此，我们必须很明确的开启事务才行。我们将Test.java文件内容修改如下：

   View Code 

　　测试成功，数据库中也有相应的数据添加成功！

第三步：搭建Spring环境

　　1、导入Spring所需要的jar包

　　　　spring.jar这一个即可！

　　2、写一个测试类

   View Code 

　　3、增加配置文件beans.xml，内容如下：

   View Code 

通过上面的配置文件，spring框架知道了UserDao类的存在！可以通过反射机制自动将UserDao类的对象new出！ 所以注意托管给spring的类必须符合基本的javabean规范：
1.    如果有属性，则必须有相应的get/set方法。 
2.    必须要无参的构造器

　　4、建立Test.java类

   View Code 

　　5、上面的代码中，我们可以使用context.getBean("userDao")代替了new UserDao(这样的代码，也就是spring内部有个工厂类，替我们完成了new对象的操作！而这个工厂类是通过读取beans.xml文件知道了字符串”userDao”和com.sxt.test.UserDao类之间的关系！

　　直接运行Test.java类即可。

第四步：已经将三个框架各自搭建完毕。现在先整合Struts和spring

　　整合struts2和spring非常简单只需两步：

　　1、在web.xml下面添加一个spring的过滤器(添加到最上面，在struts2的配置文件上面)

1     <listener>
2       <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
3     </listener>
4     <context-param>
5       <param-name>contextConfigLocation</param-name>
6       <param-value>classpath:application.xml</param-value>
7     </context-param>

　　2、添加一个struts-spring.plus的插件，这个可以再struts官方提供的jar中即可找到

　　注：action中的class不用填写全名，直接写spring中注册的id即可，如：testAction

1     <package name="default" namespace="/" extends="struts-default">
2         <action name="testAction" class="testAction">
3             <result name="success">index.jsp</result>
4         </action>
5     </package>

第五步：整合spring和hibernate

　　1、首先将web.xml添加头文件

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 4     xmlns:aop="http://www.springframework.org/schema/aop"
 5     xmlns:tx="http://www.springframework.org/schema/tx"
 6     xmlns:context="http://www.springframework.org/schema/context"
 7     xsi:schemaLocation="
 8 http://www.springframework.org/schema/beans 
 9 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
10 http://www.springframework.org/schema/tx
11 http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
12 http://www.springframework.org/schema/aop 
13 http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
14   http://www.springframework.org/schema/context   
15    http://www.springframework.org/schema/context/spring-context-2.5.xsd
16 ">

　　2、配置sessionFactory（配置了C3P0数据库连接池）

    <!-- 导入jdbc.properties --><context:property-placeholder location="classpath:jdbc.properties"/><!-- 配置sessionfactory --><bean name="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"><!-- 配置application.xml路径 --><property name="configLocation" value="classpath:hibernate.cfg.xml"></property><!-- 配置c3p0连接池 --><property name="dataSource"><bean class="com.mchange.v2.c3p0.ComboPooledDataSource"><!-- 数据库连接信息 --><property name="driverClass" value="${driverClass}"></property><property name="jdbcUrl" value="${jdbcUrl}"></property><property name="user" value="${user}"></property><property name="password" value="${password}"></property><!-- 其它配置 --><!-- 数据库初始化时获取三个链接，取值应该在min --><property name="initialPoolSize" value="3"></property><!-- 连接池中保留的最小连接数 --><property name="minPoolSize" value="3"></property><!-- 连接池中保留的最大连接数 --><property name="maxPoolSize" value="10"></property><!-- 当连接池中连接耗尽时c3p0一次获取的连接数 --><property name="acquireIncrement" value="3"></property><!-- 配置数据源内加载的preparestatement数量 --><property name="maxStatements" value="3"></property><!-- 单个连接所拥有的最大statments缓存数 --><property name="maxStatementsPerConnection" value="3"></property><!-- 设置最大空闲时间不使用自动丢弃，如果为0永远不丢弃 --><property name="maxIdleTime" value="1800"></property></bean></property></bean>

　　3、配置事务管理（XML）

 1 <!-- 配置声明事务管理 -->
 2     <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
 3         <property name="sessionFactory" ref="sessionFactory"></property>
 4     </bean>
 5     <!-- AOP核心配置 -->
 6     <aop:config>
 7         <!-- 定义aop切面 -->
 8         <aop:pointcut expression="execution(public * com.qcf.test.*.*(..))" id="testa"/>
 9         <aop:advisor advice-ref="txadvice" pointcut-ref="testa"/>
10     </aop:config>
11     <!-- 定义切割方法 -->
12     <tx:advice id="txadvice" transaction-manager="txManager">
13         <tx:attributes>
14             <tx:method name="save*" propagation="REQUIRED"/>
15         </tx:attributes>
16     </tx:advice>
17     <!--  -->

　　配置事务(annotation)

 1      <!-- 自动扫面
 2       -->
 3      <context:component-scan base-package="com.qcf"></context:component-scan>
 4      
 5 
 6     <!-- 配置事务 -->
 7     <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
 8         <property name="sessionFactory" ref="sessionFactory"></property>
 9     </bean>
10     
11     <!-- annotation配置事务     -->
12     <tx:annotation-driven transaction-manager="txManager"/>

　　测试方法：

   View Code 

　　4、配置HibernateTemplate

　　　HibernateTemplate类可让我们将Hibernate的使用模板化，使我们对hibernate的调用更加简单！使用他，我们只需要在配置文件中增加：

1     <!-- 配置hibernatetempter -->
2     <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
3         <property name="sessionFactory" ref="sessionFactory"></property>
4     </bean>
5

　　hibernateTemplate常用方法：　　

　　　　◦ void delete(Object entity)：删除指定持久化实例

　　　　◦ deleteAll(Collection entities)：删除集合内全部持久化类实例

　　　　◦ find(String queryString)：根据HQL查询字符串来返回实例集合

　　　　◦ get(Class entityClass, Serializable id)：根据主键加载特定持久化类的实例

　　　　◦ save(Object entity)：保存新的实例

　　　　◦ saveOrUpdate(Object entity)：根据实例状态，选择保存或者更新

　　　　◦ update(Object entity)：更新实例的状态，要求entity是持久状态

　　　　◦ setMaxResults(int maxResults)：设置分页的大小(无setFirstResult方法)

　　HibernateTemplate的典型用法：

1. 　　需要直接获得session对象的处理方式(比如：分页处理)

1         hibernateTemplate.execute(new HibernateCallback() {
2             
3             public Object doInHibernate(Session session) throws HibernateException,
4                     SQLException {
5                 // TODO Auto-generated method stub
6                 session.save(new User(0, "lisi", 19));
7                 return null;
8             }
9         });

　　　　　　2. 不需要直接获得session对象的情况

 1     public List<User> getAllUser(){
 2             List<User> list=hibernateTemplate.find("from User");
 3             for (int i = 0; i < list.size(); i++) {
 4                 System.out.println(list.get(i).getId());
 5                 
 6             }
 7             
 8             List list2 = hibernateTemplate.find("from User where name=? and id=?", new Object[]{"zhangsan",1});
 9             for (int i = 0; i < list2.size(); i++) {
10                 System.out.println(list2.get(i).toString());
11             }
12             
13         return null;
14     }

　　5、HibernateDaoSupport

　　　　封装了HibernateTemplate！常见用法如下：

public class UserDaoImpl3 extends HibernateDaoSupport  {public void add(User u) {this.getHibernateTemplate().save(u);}
}
public class UserDaoImpl3 extends HibernateDaoSupport  {public void add(User u) {Session s = this.getSession();s.save(u);releaseSession(s); //手动释放session资源
    }
}

　　6、JDBCTemplate的使用

　　　dbcTemplate类是spring为了让我们更加容易使用jdbc而提供的封装。JdbcTemplate对jdbc操作做了简单的封装。内部也使用了类似HibernateTemplate中使用的模板方法模式。JdbcTemplate在工作中用的不多。本节为自学内容，目的是让大家开阔眼界。

　　要使用JdbcTemplate，我们必须要在spring中增加配置：

1 <!--配置一个JdbcTemplate实例-->  
2 <bean id="jdbcTemplate"  class="org.springframework.jdbc.core.JdbcTemplate">   
3      <property name="dataSource" ref="dataSource"/>   
4 </bean>

　　测试类如下：

   View Code 

　　7、OpenSessionInView管理session

　　OpenSessionInViewFilter是Spring提供的一个针对Hibernate的一个支持类，其主要意思是在发起一个页面请求时打开 Hibernate的Session，一直保持这个Session，直到这个请求结束，具体是通过一个Filter来实现的。

由于Hibernate引入了Lazy Load特性，使得脱离Hibernate的Session周期的对象如果再想通过getter方法取到其关联对象的值，Hibernate会抛出一个 LazyLoad的Exception。所以为了解决这个问题，Spring引入了这个Filter，使得Hibernate的Session的生命周期变长。

OpenSessionInViewFilter：org.springframework.orm.hibernate3.support.OpenSessionInViewFilter]是 Spring提供的一个针对Hibernate的一个支持类，其主要意思是在发起一个页面请求时打开Hibernate的Session，一直保持这个 Session，直到这个请求结束，具体是通过一个Filter来实现的。

有两种方式可以配置实现OpenSessionInView，分别是 OpenSessionInViewInterceptor和OpenSessionInViewFilter，功能完全相同，只不过一个在 web.xml配置，另一个在application.xml配置而已。

　　我们可以在web.xml中配置opensessioninview，代码如下：

 1 <!-- 配置Spring自动管理Session. 要配置到struts过滤器之前！-->  
 2  <filter>  
 3      <filter-name>hibernateSessionFilter</filter-name>  
 4      <filter-class>  
 5  org.springframework.orm.hibernate3.support.OpenSessionInViewFilter   
 6      </filter-class>  
 7  </filter>  
 8  <filter-mapping>  
 9      <filter-name>hibernateSessionFilter</filter-name>  
10      <url-pattern>/*</url-pattern>  
11  </filter-mapping>

　　8、ThreadLocal模式管理session

我们知道Session是由SessionFactory负责创建的，而SessionFactory的实现是线程安全的，多个并发的线程可以同时访问一个SessionFactory并从中获取Session实例，那么Session是否是线程安全的呢？很遗憾，答案是否定的。

早在Java1.2推出之时，Java平台中就引入了一个新的支持：java.lang.ThreadLocal，给我们在编写多线程程序时提供了一种新的选择。ThreadLocal是什么呢？其实ThreadLocal并非是一个线程的本地实现版本，它并不是一个Thread，而是thread local variable(线程局部变量)。也许把它命名为ThreadLocalVar更加合适。线程局部变量(ThreadLocal)其实的功用非常简单，就是为每一个使用某变量的线程都提供一个该变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有一个该变量。

ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。

比如下面的示例实现(为了简单，没有考虑集合的泛型)：

 1 public  class  ThreadLocal  {
 2 　   private  Map  values  =  Collections.synchronizedMap(new  HashMap());
 3 　   public  Object  get()  {
 4 　　 Thread  currentThread  =  Thread.currentThread();  
 5 　   Object  result  =  values.get(currentThread);  
 6 　　   if(result  ==  null&&!values.containsKey(currentThread))  {
 7 　　　    result  =  initialValue();
 8 　　　    values.put(currentThread,  result);  
 9 　　       }
10 　　       return  result;  
11 　       }
12 　   public  void  set(Object  newValue)  {
13 　　   values.put(Thread.currentThread(),  newValue);
14 　      }
15      public  Object  initialValue()  {
16 　　   return  null;  
17 　    }
18    }

那麽具体如何利用ThreadLocal来管理Session呢？Hibernate官方文档手册的示例之中，提供了一个通过ThreadLocal维护Session的好榜样：

 1 public  class  HibernateUtil  {
 2   public  static  final  SessionFactory  sessionFactory;
 3     static  {
 4       try  {
 5         sessionFactory  =  new  Configuration().configure().buildSessionFactory();
 6         } catch (Throwable  ex) {
 7           throw  new  ExceptionInInitializerError(ex);
 8            }
 9          }
10    public static final ThreadLocal<Session>session=new ThreadLocal<Session>();
11    public  static  Session  currentSession()  throws  HibernateException  {
12        Session  s  =  session.get();
13        if(s  ==  null)  {
14          s  =  sessionFactory.openSession();
15          session.set(s);
16           }
17          return  s;
18          }
19    public  static  void  closeSession()  throws  HibernateException  {
20          Session  s  =  session.get();
21         if(s  !=  null)  {
22            s.close();
23           }
24           session.set(null);
25         }
26      }

ssh基本知识：

在表示层中，首先由JSP页面做交互界面，负责接收请求request和传送响应response,然后由struts根据配置文件(struts-config.xml)将ActionServlet接收到的request委派给相应的action处理。在业务层，spring负责向Action提供业务模型完成业务逻辑。在持久层中，依赖hibernate处理Dao组件请求的数据，并返回处理结果。