三大框架的基础知识

三大框架的基础知识

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>元素下增加:

  <mapping resource="com/qcf/hib/bean/User.hbm.xml"/>

  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

 

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

 

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

 

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

 

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

 

有两种方式可以配置实现OpenSessionInView,分别是 OpenSessionInViewInterceptorOpenSessionInViewFilter,功能完全相同,只不过一个在 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  null17      }
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组件请求的数据,并返回处理结果。

发布了37 篇原创文章 · 获赞 12 · 访问量 6万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览