Hibernate中的Session管理

一、前言：

无论多复杂，hibernate终究是一个和数据库打交道的框架，与jdbc功能一样。所以没有理由畏惧hibernate. hibernate的难点我觉得有两方面：一是性能优化，二是session管理。性能优化是个经验活；关于session管理，单纯的hibernate可以使用ThreadLocal来解决，如果和spring结合，使用spring提供的session管理方案很不错。

二、Hibernate提供的Session管理：

1.管理 Session

　　1）Hibernate 自身提供了三种管理 Session 对象的方法

　　　　① Session 对象的生命周期与本地线程绑定

　　　　② Session 对象的生命周期与 JTA 事务绑定

　　　　③ Hibernate 委托程序管理 Session 对象的生命周期

　　2）在 Hibernate 的配置文件中,hibernate.current_session_context_class 属性用于指定 Session 管理方式, 可选值包括

　　　　① thread: Session 对象的生命周期与本地线程绑定

　　　　② jta*: Session 对象的生命周期与 JTA 事务绑定

　　　　③ managed: Hibernate 委托程序来管理 Session 对象的生命周期

2、JTA事务绑定：

JTA(Java Transaction API)Java事务架构，允许用户进行分布式事务处理(spring中讲解)。

3、本地线程管理：

我们知道Session是由SessionFactory负责创建的，而SessionFactory的实现是线程安全的，多个并发的线程可以同时访问一个SessionFactory并从中获取Session实例，那么Session是否是线程安全的呢？很遗憾，答案是否定的。Session中包含了数据库操作相关的状态信息，那么说如果多个线程同时使用一个Session实例进行CRUD，就很有可能导致数据存取的混乱。

 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()   
   6.                                    .buildSessionFactory();   
   7.            } catch (Throwable ex) {   
   8.                 throw new ExceptionInInitializerError(ex);   
   9.            }   
  10.        }   
  11.        public static final ThreadLocal session =    
  12.                                             new ThreadLocal();   
  13.        public static Session currentSession() throws HibernateException {   
  14.                Session s = session.get();   
  15.                if(s == null) {   
  16.                      s = sessionFactory.openSession();   
  17.                      session.set(s);   
  18.                }   
  19.                return s;   
  20.        }   
  21.        public static void closeSession() throws HibernateException {   
  22.                 Session s = session.get();   
  23.                 if(s != null) {   
  24.                       s.close();   
  25.                 }   
  26.                 session.set(null);   
  27.        }   
  28. }  

     只要借助上面的工具类获取Session实例，我们就可以实现线程范围内的Session共享，从而避免了线程中频繁的创建和销毁Session实例。当然，不要忘记在用完后关闭Session。 
     写到这里，想再多说一些，也许大多数时候我们的DAO并不会涉及到多线程的情形，比如我们不会将DAO的代码写在Servlet之中，那样不是良好的设计，我自己通常会在service层的代码里访问DAO的方法。但是我还是建议采用以上的工具类来管理Session，毕竟我们不能仅仅考虑今天为自己做什么，还应该考虑明天为自己做什么！ 

三、spring中的session管理

1、在spring中提供了两种方法来管理session 
第一种是用户直接getSession()，在这种情况下请注意了,如果你没有配置事务的话，请注意关闭session 

第二种是用spring的HibernateTemplate进行管理,除了通常的crud，HibernateTemplate都为我们封装好了，直接调用就行了，但如果想自己封装的话 
就得调用HibernateTemplate中的方法execute(HibernateCallBack action) 
调用这个方法时要注意重写HibernateCallBack中的方法doInHibernate(Session session),在这种情况下很简单..session的开关，不用你来管，直接由hibernate事务管理器进行管理了 

2、请注意以下 
以下均为同一线程 
1）、spring中的session在没有配置事务的前提下session事务默认是自动提交的 
  可以由以下的代码得知: 
 

Java代码  

1. getSession().connection().getAutoCommit()//true  

    

NOTE:在spring中getSession() 
  
   (1)假如你没有配置事务,则其每次都会产生一个新的session对象 
  
   你可以在没有配置事务的前提下用以下的代码测试: 
 

Java代码  

1. getSession() == getSession()//false  

    
    (2)假如你配置了事务，则每次getSession()得到了都是同一个对象 
       
    

Java代码  

1. getSession() == getSession()//true  

    但在配置了事务的前提下有一种情况判断session相等其结果为false 
    例如:在HibernateTemplate中代码如下: 
   

Java代码  

1. doExecute(HibernateCallback<T> action, boolean    
2.    enforceNewSession, boolean enforceNativeSession);  
3. /* 
4.    调用这个方法时，如果参数enforceNativeSession的值为false的话 
5.      则在HibernateCallback的方法 
6.      public Object doInHibernate(Session argsession){  
7.       System.out.println(argsession == getSession()); 
8.       //输出为false,这是为什么呢，原因是enforceNativeSession传入的 
9.          //值如果是false,表示不把这个doExecute方法中得到的session暴露给 
10.          //用户,所以其返回给用户的是session的代理，也就是说argsession只 
11.          //是一个代理，所以argsession == getSession()得到的结果为 
12.          //false,如果enforceNativeSession为true,则相反，可以得到true 
13.    } 
14.  */  

    
     

  
2）、spring中，假如在配置文件中配置了事务，则其session事务则不是自动提交的 
  可以通过 
  

Java代码  

1. getSession().connection().getAutoCommit()//false  

3）、单独使用hibernate时，其session事务是不会自动提交的，请注意 

所以个人认为最好在配置中将hibernate.autocommit设置为false