首页 > 其他分享 >session

session

时间：2023-07-19 18:04:13浏览次数：19  
标签：Hibernate Session Spring SessionFactory HibernateTemplate session


getCurrentSession () 使用当前的session
openSession()          重新建立一个新的session

在一个应用程序中，如果DAO 层使用Spring 的hibernate 模板，通过Spring 来控制session 的生命周期，则首选getCurrentSession ()。
    1. 如果使用的是getCurrentSession来创建session的话，在commit后，session就自动被关闭了，
         也就是不用再session.close()了。但是如果使用的是openSession方法创建的session的话，
         那么必须显示的关闭session，也就是调用session.close()方法。这样commit后，session并没有关闭
 2. getCurrentSession的使用可以参见hibernate\hibernate-3.2\doc\tutorial\src项目
 3.  使用SessionFactory.getCurrentSession()需要在hibernate.cfg.xml中如下配置：
  * 如果采用jdbc独立引用程序配置如下：
    <property name="hibernate.current_session_context_class">thread</property>
  * 如果采用了JTA事务配置如下 
    <property name="hibernate.current_session_context_class">jta</property>

Hibernate代码:

Session session = HibernateUnit.getSessionFactory().getCurrentSession();
session.beginTransaction();
....
session.getTransaction().commit();
getcurrentSession()方法总是会返回“当前的”工作单元。


Session 在第一次被使用的时候，即第一次调用getCurrentSession()的时候，其生命周期就开始。然后她被Hibernate绑定到当前线程。当事物结束的时候，不管是提交还是回滚，Hibernate会自动把Session从当前线程剥离，并且关闭。若在次调用 getCurrentSession()，会得到一个新的Session,并且开始一个新的工作单元。这是Hibernate最广泛的thread- bound model，支持代码灵活分层(事物划分和数据访问代码的分离)。

从实现的功能上看Spring与Hibernate的整合
2008年02月27日 星期三 03:26
1.管理SessionFactory

   使用Spring整合Hibernate时我们不需要hibernate.cfg.xml文件。首先，在applicationContext.xml中配置数据源（dataSource）bean和session工厂（sessionFactory）bean。其中，在配置session工厂bean 时，应该注入三个方面的信息：

      ●数据源bean

      ●所有持久化类的配置文件

      ●Hibernate的SessionFactory的属性

Hibernate的SessionFactory的属性信息又包括两个内容，一，Hibernate的连接方法；二，不同数据库连接，启动时的选择。

2.为HibernateTemplate注入SessionFactory对象，通过HibernateTemplate来持久化对象

   Spring提供了HibernateTemplate，用于持久层访问，该模板无需打开Session及关闭Session。它只要获得 SessionFactory的引用，将可以只能地打开Session，并在持久化访问结束后关闭Session，程序开发只需完成持久层逻辑，通用的操作（如对数据库中数据的增，删，改，查）则有HibernateTemplate完成。

   HibernateTemplate有三个构造函数，不论是用哪一种构造，要使HibernateTemplate能完成持久化操作，都必须向其传入一个SessionFactory的引用。

   HibernateTemplate的用法有两种，一种是常规的用法，另一种是复杂的用。

      一，常规的用法

         HibernateTemplate通过它自己的delete(Object entity) ，find(String queryString)，save(Object entity)等等常用的方法即可完成大多数DAO对象的增，删，改，查等操作。

      二，复杂的用法

         HibernateTemplate的复杂的用法是通过如下的两个方法来完成的：

            ●Object execute(HibernateCallback action)

            ●List execute(HibernateCallback action)

         这两个方法都需要一个HibernateCallback实例，程序开发者通过HibernateCallback，可以完全使用Hibernate灵活的方式来访问数据库，解决了Spring封装Hibernate后灵活不足的缺陷。HibernateCallback是一个接口，该接口只有一个方法 doInHibernate(org.hibernate.Session session)，该方法只有一个参数Session。

         通常，程序中采用实现HibernateCallback的匿名内部类来获取HibernateCallback的实例，方法doInHibernate就是Spring执行的持久化操作。具体的代码实例如下：

   

public class PersonDaoImpl {
                 private SessionFactory sessionFactory;
                 public void setSessionFactory(SessionFactory sessionFactory) {
                         this.sessionFactory = sessionFactory;
                 }
                 public List findPersonByName(final String name) {
                         HibernateTemplate hibernateTemplate =
                                            new HibernateTemplate(this.sessionFactory);
                         return (List)hibernateTemplate.execute(
                                   public Object doInHibernate(Session session) throws Hibernate Exception {
                                           List result =session.createCriteria(Person.clsss)
                                                                         .add(Restrictions.like("name",name+"%")).list();
                                           return result;
                                   }
                         );
                 }
        }

       注：在方法doInHibernate内可以访问Session，该Session对象是绑定到该线程的Session实例，该方法内的持久层操作与不使用Spring时的持久层操作完全相同，这保证了对于复杂的持久层访问时，依然可以使用Hibernate的访问方式。

3.DAO的实现

   DAO的实现有两种方式：一，继承HibernateDaoSupport实现DAO；二，基于Hibernate3.0实现DAO。

      一，继承HibernateDaoSupport实现DAO

         Spring为Hibernate的DAO提供了工具类HibernateDaoSupport。该类主要提供了如下两个方法来方便DAO的实现：

         ●public final HibernateTemplate getHibernateTemplate()

         ●public final void setSessionFactory(SessionFactory sessionFactory)

         其中，setSessionFactory方法用来接收Spring的ApplicationContext依赖注入的SessionFactory实例；getHibernateTemplate方法则用来根据刚才的SessionFactory产生Session，最后由 HibernateTemplate来完成数据库访问。

      二，基于Hibernate3.0实现DAO

        在Hibernate处于事务的管理下时（通常Spring为Hibernate提供事务管理），通过SessionFactory的 getCurrentSession()方法可以返回当前的Session，如果当前的JTA事务关联的Session不存在，则系统打开一次新的 Session，并关联到当前的JTA事务；如果当前JTA事务关联的Session已经存在，则直接返回该Session。获得了当前的Session 后就可以进行持久化操作了。

      可见，不论使用上面的哪一种方式实现DAO都需要用Spring来注入SessionFactory实例。

4.事务的管理

   Hibernate建议所有的对数据库的访问都应放在事务内进行，即使进行的只是读操作。Spring同时支持编程式事务和声明式事务。通常推荐使用声明式事务。

    编程式事务管理：

   编程式事务提供了TransactionTemplate模板类，用的时候必须向其体提供一个PlatformTransactionManager实例。只要TransactionTemplate获取了PlatformTransactionManager的引用，TransactionTemplate就可以完成事务操作了。TransactionTemplate提供了一个execute方法，它接收一个 TransactionCallback实例。TransactionCallback包含如下方法：

      ●Object doInTransaction(TransactionStatus status)

这是需要有返回值的情况。如果不需要有返回值的话，我们可以用TransactionCallbackWithOutResult类来代替TransactionCallback类，它也有一个方法：

      ●void doInTransaction(TransactionStatus status)

    在这个两个方法中，在出现异常时，TransactionStatus的实例status可以调用setRollbackOnly()方法进行回滚。

   一般情况下，向execute方法传入TransactionCallback或TransactionCallbackWithOutResult实例时，采用的是匿名内部类的形式。

   声明式事务管理：

   声明式事务管理的配置方式通常有三种：

      ●使用TransactionProxyFactoryBean为目标bean生成事务代理的配置。

      ●使用BeanNameAutoProxyCreator，根据bean name自动生成事务代理的方式，这是直接利用Spring的AOP框架配置事务代理的方式，需要对Spring的AOP框架有所了解。

      ●使用DefaultAdvisorAutoProxyCreator，这也是直接利用Spring的AOP框架配置事务代理的方式，只是这种配置方式的可读性不如使用BeanNameAutoProxyCreator的配置方式。
------------------------------------------------------------------

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
           
<!-- 数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
     <property name="driverClassName">
     <value>COM.ibm.db2.jdbc.net.DB2Driver</value>
     </property>
     <property name="url">
    <value>jdbc:db2://localhost:6789/GUOZIWEI</value>
     </property>
     <property name="username">
    <value>db2admin</value>
     </property>
     <property name="password">
    <value>db2admin</value>
     </property>
</bean><!--数据库会话工厂 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
   <property name="dataSource">
    <ref local="dataSource" />
   </property>
   <property name="mappingResources">
    <list>
     <value>com/becom/ins/dto/User.hbm.xml</value>
     <value>com/becom/ins/dto/InsFunds.hbm.xml</value>
     <value>com/becom/ins/dto/Company.hbm.xml</value>
     <value>com/becom/ins/dto/Group.hbm.xml</value>
     <value>com/becom/ins/dto/OtherFunds.hbm.xml</value>
    </list>
   </property>  
  
   <property name="hibernateProperties">
    <props>
     <prop key="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop>
     <prop key="hibernate.show_sql">true</prop>
     <prop key="hibernate.cglib.use_reflection_optimizer">true</prop>
    </props>
   </property>  
</bean><!-- 事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
   <property name="sessionFactory"><ref local="sessionFactory"/></property>
</bean><!-- Spring 事务管理器代理 -->
<bean id="transactionProxyFactory" abstract="true" lazy-init="true" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <property name="transactionManager">
         <ref local="transactionManager"/>
    </property>
    <property name="transactionAttributes">
         <props>
          <prop key="save*">PROPAGATION_REQUIRED</prop>
           <prop key="insert*">PROPAGATION_REQUIRED</prop>
           <prop key="del*">PROPAGATION_REQUIRED</prop>
           <prop key="add*">PROPAGATION_REQUIRED</prop>
           <prop key="update*">PROPAGATION_REQUIRED</prop>
           <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
           <prop key="search*">PROPAGATION_REQUIRED,readOnly</prop>
           <prop key="remove*">PROPAGATION_REQUIRED,readOnly</prop>
           <prop key="query*">PROPAGATION_REQUIRED,readOnly</prop>
           <prop key="list*">PROPAGATION_REQUIRED,readOnly</prop>
           <prop key="count*">PROPAGATION_REQUIRED,readOnly</prop>
           <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
    </props>
   </property>
</bean><!-- Hibernate模板 -->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
   <property name="sessionFactory">
    <ref local="sessionFactory" />
   </property>
</bean><!-- 用户服务对象 -->
<bean id="userService" parent="transactionProxyFactory">
   <property name="target">
    <bean class="com.becom.ins.user.service.UserService">
     <property name="userDAO">
      <ref local="userDAO"/>
     </property> 
    </bean>
   </property>
</bean><!-- 用户数据访问对象 -->
<bean id="userDAO" class="com.becom.ins.user.dao.UserDAO">
   <property name="hibernateTemplate" ref="hibernateTemplate"/>
</bean><!-- 破产服务对象 -->
<bean id="insService" parent="transactionProxyFactory">
   <property name="target">
    <bean class="com.becom.ins.insolvency.service.InsFundsService">
     <property name="insDAO">
      <ref local="insDAO"/>
     </property> 
    </bean>
   </property>
</bean><!-- 用户数据访问对象 -->
<bean id="insDAO" class="com.becom.ins.insolvency.dao.InsFundsDAO">
   <property name="hibernateTemplate" ref="hibernateTemplate"/>
</bean>  <!-- 集团服务对象 -->
<bean id="groupService" parent="transactionProxyFactory">
   <property name="target">
    <bean class="com.becom.ins.group.service.GroupServiceImpl">
     <property name="groupDAO">
      <ref local="groupDAO"/>
     </property> 
    </bean>
   </property>
</bean><!-- 用户数据访问对象 -->
<bean id="groupDAO" class="com.becom.ins.group.dao.GroupDAOImpl">
   <property name="hibernateTemplate" ref="hibernateTemplate"/>
</bean>  <!-- 公司服务对象 -->
<bean id="companyService" parent="transactionProxyFactory">
   <property name="target">
    <bean class="com.becom.ins.company.service.CompanyServiceImpl">
     <property name="companyDAO">
      <ref local="companyDAO"/>
     </property> 
    </bean>
   </property>
</bean><!-- 公司数据访问对象 -->
<bean id="companyDAO" class="com.becom.ins.company.dao.CompanyDAOImpl">
   <property name="hibernateTemplate" ref="hibernateTemplate"/>
</bean>  </beans>

标签：Hibernate,Session,Spring,SessionFactory,HibernateTemplate,session
From： https://blog.51cto.com/u_16193056/6778793

相关文章

  • @EnableRedisIndexedHttpSession
    使用@EnableRedisIndexedHttpSession增强SpringSession在Spring框架中，Session管理是Web应用开发中常见的需求之一。SpringSession是Spring提供的解决方案之一，它可以用于替代传统的Servlet容器提供的Session管理机制。SpringSession提供了一种使用不同的存储后端（如内存、Redis、......
  • Linux命令-按照与使用(17）（转载）解决同一台服务器上部署多个tomcat的同一个项目session冲
    ————————————————版权声明：本文为CSDN博主「strive_or_die」的原创文章，遵循CC4.0BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/strive_or_die/article/details/103191546————————————————版权声明：本文为CS......
  • 翻译文件存到sessionStorage，减少请求
    测试本地翻译文件，格式正不正确，检查JSON格式可以一部分str_info_english1.js,一部分的检查，是否报错<script>functionfoo(){varformData=newFormData();//提交表单varxhr=newXMLHttpRequest();xhr......
  • 【13.0】Django框架之Cookie和Session
    【一】Cookie与Session的发展史详解Cookie和Session是用来在Web应用程序中跟踪用户会话数据的两种常用技术。【1】Cookie的发展史：1994年，网景通信公司推出了第一个浏览器Cookie技术。Cookie是存储在用户计算机上的小型文本文件，用于跟踪用户在网站上的活动。初始版本的Cookie只......
  • Statement not bound, 使用MybatisPlus时的SqlSessionFactory和MybatisSqlSessionFact
    最近首次在真实项目中，实践用SpingBoot整合Mybatis、MybatisPlus、Spring、多数据源等常见SSH整合问题。遇到一个难题，MybatisPlus遇到了经典的问题“Statementnotbound”。如果是Mybatis，很容易解决，扫描到Mapper接口文件和Mapper.xml文件，肯定能搞定。这次整合进了MybatisPlus，之前......
  • iis7中session丢失的解决方法小结
    WindowsServer2008+IIS+ASP.net+SQLServer2008搭建的内部WEB系统。 用户Session总是丢失，可能是IIS的不稳定性将导致Session频繁丢失。 用的是Session=SQLSEVER，即把Session保存到数据库。 解决方法： 1，在命令行进入如下地址（InstallSqlState.sql文件目录） cd"C:\WINDOWS\Mic......
  • 【笔记整理】使用Session会话保持
    importrequestsif__name__=='__main__':#Session对象实现了客户端和服务器端的每次会话保持功能。session=requests.Session()resp=session.get("http://www.baidu.com")#使用Session会自动携带cookie每次请求后的cookieresp2=session.g......
  • pom.xml增加Mybatisplus的依赖后报错：Factory method 'sqlSessionFactory' threw excep
    出现上面的问题，是版本不匹配导致。<dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.2.0</version></dependency&......
  • finshell 连接不到服务器，报Session.connect: java.net.SocketException: Connection r
    用finshell一段时间了，非常不错，但是有段时间突然连接不上服务器，各种重装，重启服务器都不行，在网上搜方法也没有好的办法。在我一次实在烦的不得了的时候，让我发现一个好的解决方案。先上图： 是不是出现这个问题，那么我的解决方案是啥呢？看我的手速，就是点击红色的闪电图标，一般连续点击......
  • sessionStorage可以在多个Tab之间共享数据吗？
    不可以。sessionStorage是浏览器会话级别的存储机制，它只在单个浏览器标签页（tab）或窗口之间共享数据。每当用户打开一个新的标签页或窗口时，会话存储会被重新初始化，每个标签页或窗口都会有自己的独立的sessionStorage。如果您需要在多个标签页或窗口之间共享数据，可以考虑使用其他的......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99