详解Hibernate Session & Transaction

53 阅读 0 评论 35 点赞

我是靠谱客的博主魔幻云朵，最近开发中收集的这篇文章主要介绍详解Hibernate Session & Transaction，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

HIbernate中的Session
　　Session是JAVA应用程序和Hibernate进行交互时使用的主要接口，它也是持久化操作核心API，注意这里的Session的含义，它与传统意思上web层的HttpSession并没有关系，Hibernate Session之与Hibernate，相当于JDBC Connection相对与JDBC。
　　
　　Session对象是有生命周期的，它以Transaction对象的事务开始和结束边界
　　
　　Session作为贯穿Hibernate的持久化管理器核心，提供了众多的持久化的方法，如save(), update ,delete ,find(Hibernate 3中已经取消了此方法)等，通过这些方法我们可以透明的完成对象的增删改查（CRUD– create read update delete），这里所谓的透明是指，Session在读取，创建和删除影射的实体对象的实例时，这一系列的操作将被转换为对数据库表中数据的增加，修改，查询和删除操作。

　　SessionFactory负责创建Session，SessionFactory是线程安全的，多个并发线程可以同时访问一个SessionFactory 并从中获取Session实例。而Session并非线程安全，也就是说，如果多个线程同时使用一个Session实例进行数据存取，则将会导致Session 数据存取逻辑混乱.因此创建的Session实例必须在本地存取空上运行，使之总与当前的线程相关。

Session有以下的特点
　　1,不是线程安全的，应该避免多个线程共享同一个Session实例
　　2,Session实例是轻量级的，所谓轻量级：是指他的创建和删除不需要消耗太多资源
　　3,Session对象内部有一个缓存，被称为Hibernate第一缓存，他存放被当前工作单元中加载的对象，每个Session实例都有自己的缓存。

Hibernate Session缓存被称为Hibernate的第一级缓存。SessionFactory的外置缓存称为Hibernate的二级缓存。这两个缓存都位于持久层，它们存放的都是数据库数据的拷贝。SessionFactory的内置缓存存放元数据和预定义SQL， SessionFactory的内置缓存是只读缓存。

Hibernate Session缓存的三大作用：
1，减少数据库的访问频率，提高访问性能。
2，保证缓存中的对象与数据库同步，位于缓存中的对象称为持久化对象。
3，当持久化对象之间存在关联时，Session 保证不出现对象图的死锁。
Session 如何判断持久化对象的状态的改变呢？
Session 加载对象后会为对象值类型的属性复制一份快照。当Session 清理缓存时，比较当前对象和它的快照就可以知道那些属性发生了变化。

Session 什么时候清理缓存？
1，commit（）方法被调用时
2，查询时会清理缓存，保证查询结果能反映对象的最新状态。
3，显示的调用session 的 flush方法。
session 清理缓存的特例：
当对象使用 native 生成器时会立刻清理缓存向数据库中插入记录。

org.hibernate Interface Session
　　public interface Session extends Serializable: 是一个Java application 和Hibernate之间主要的运行时接口，这是执行持久化服务的中心API
　　主要方法：
　　public Transaction beginTransaction() throws HibernateException【1】：返回和当前Session对象相互联系的Transaction对象(表示在数据库中重新开始一个事务)
　　public Transaction getTransaction()：返回和当前session联系的Transaction对象
　　public Connection connection close() throws HibernateExcepton：结束当前的Session对象
　　public void clear()：清空Session，清除所有保存在当前Session缓存中的实体对象，终止所有正在执行的方法(eg: save() , update() ,delete() …..)
　　public Serializable save(Object object)throws HibernateException 对当前参数指定的对象进行持久化(系统会首先赋予参数对象一个标识符OID)，他相当于insert语句后面在详细介绍
　　public Connection connection() throws HibernateException 得到当前Session 中包含的Connection对象。
　　public boolean contains(Object object):判断参数给出的对象（持久化类）是否在当前Session的缓存中
　　public void evict(Object object) throws HibernateException ：将参数给出的Object从当前Session对象类中删除，使这个对象从持久态变成游离态，这种状态的改变不会引起对数据库的同步，后面详细介绍
　　public Object load(Class theclass ,Serializable id) throws HibernateException返回第一个参数指定类对应的表中，第二个参数指定的行（第二个参数就是要取得对象的OID，他对应表中主键列的值）
　　public void update(Object object) throws HibernateException：更新一个对象到数据库中，后面在详细介绍
　　public void delete (Object object)throws HibernateException：从数据库中删除和参数指定的对象对应的记录
　　public Object get(Class class,Serializable id) throws HibernateException：和load（）方法一样区别在于，如果数据库表中没有对应的记录，get()方法返回null,load()方法将报异常
Transaction
　　Transanction接口是Hibernate的数据库事务接口，用于管理事务，他对底层的事务作出了封装，用户可以使用Transanction对象定义自己的对数据库的原子操作，底层事务包括：JDBC API ,JTA(Java Transaction API)。。。。。
　　一个Transaction对象的事务可能会包括多个对数据库进行的操作
　　org.hibernate Interface Transaction
　　public interface Transaction
常用方法：
　　public void commit() throws HibernateException刷新当前的Session以及结束事务的工作，这个方法将迫使数据库对当前的事务进行提交
　　public void rollback() throws HibernateException：强迫回滚当前事务
　　public boolean isActive() throws HibernateException：这个事务是否存活
　　—————————————————————————————-

　　Session：当中包含一个Connection对象
　　Connection c =session.getConnection();
　　Session的缓存用于临时保存持久化的对象，等到一定时候，再将缓存中的对象保存到数据库中。
　　应用程序事务：如果一个Session中包含有多个Transaction（数据库事务）,这些Transaction的集合称为应用程序事务
标准使用形式：

　　Configuration config=new Configuration().configure("hibernate.cfg.xml"); 
　　SessionFactory sessionfactory=config.buildSessionFactory(); 
　　Session session=sessionfactory.openSession(); 
　　Transaction tx=session.beginTransaction(); 
　　try { 
            session.save(); 
            tx.commit(); 
　　} catch(Exception e) { 
        　　if(tx!=null) tx.rollback(); 
　　} finally { 
    　　session.close (); 
　　}

保证session的线程安全

ThreadLocal，在很多种Session 管理方案中都用到了它.ThreadLocal 是Java中一种较为特殊的线程绑定机制，通过ThreadLocal存取的数据，总是与当前线程相关，也就是说，JVM 为每个运行的线程，绑定了私有的本地实例存取空间，从而为多线程环境常出现的并发访问问题提供了一种隔离机制，ThreadLocal并不是线程本地化的实现，而是线程局部变量。

也就是说每个使用该变量的线程都必须为该变量提供一个副本，每个线程改变该变量的值仅仅是改变该副本的值，而不会影响其他线程的该变量的值，ThreadLocal是隔离多个线程的数据共享，不存在多个线程之间共享资源，因此不再需要对线程同步。

请看一下代码:

public class HibernateUtil {  

    public static final SessionFactory sessionFactory;  
    public static final ThreadLocal session = new ThreadLocal(); 

    static{  
        try{  
            Configuration configuration=new Configuration().configure();   
            sessionFactory = configuration.buildSessionFactory();  
        }catch (Throwable ex){  
            System.err.println("Initial SessionFactory creation failed." + ex);  
            throw new ExceptionInInitializerError(ex);  
        }  
    } 

    public static Session currentSession() throws HibernateException{  
        Session s = (Session) session.get(); 

        if (s == null) {  
            s = sessionFactory.openSession();  
            session.set(s);  
        }  
        return s;  
    }  

    public static void closeSession() throws HibernateException {  
        Session s = (Session) session.get();  
        if (s != null)  
        s.close();  
        session.set(null);  
    }  
}

不安全解释，例如：Servlet 运行是多线程的，而应用服务器并不会为每个线程都创建一个Servlet实例，也就是说，TestServlet在应用服务器中只有一个实例（在Tomcat中是这样，其他的应用服务器可能有不同的实现），而这个实例会被许多个线程并发调用，doGet 方法也将被不同的线程反复调用，可想而知，每次调用doGet 方法，这个唯一的TestServlet 实例的session 变量都会被重置

在代码中，只要借助上面这个工具类获取Session 实例，我们就可以实现线程范围内的Session 共享，从而避免了在线程中频繁的创建和销毁Session 实例。不过注意在线程结束时关闭Session。同时值得一提的是，新版本的Hibernate在处理Session的时候已经内置了延迟加载机制，只有在真正发生数据库操作的时候，才会从数据库连接池获取数据库连接，我们不必过于担心Session的共享会导致整个线程生命周期内数据库连接被持续占用。

对于Web程序而言，我们可以借助Servlet2.3规范中新引入的Filter机制，轻松实现线程生命周期内的Session管理（关于Filter的具体描述，请参考Servlet2.3规范）。Filter的生命周期贯穿了其所覆盖的Servlet（JSP也可以看作是一种特殊的Servlet）
及其底层对象。Filter在Servlet被调用之前执行，在Servlet调用结束之后结束。因此，在Filter 中管理Session 对于Web 程序而言就显得水到渠成。下面是一个通过Filter 进行Session管理的典型案例：
Java代码


public class PersistenceFilter implements Filter {  

    protected static ThreadLocal hibernateHolder = new ThreadLocal();  
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {  
        hibernateHolder.set(getSession());  
        try {  
             //......  
             chain.doFilter(request, response);  
             //......  
        } finally {  
           Session sess = (Session)hibernateHolder.get();  
           if (sess != null) {  
               hibernateHolder.set(null);  
               try {  
                   sess.close();  
               } catch (HibernateException ex) {  
                   throw new ServletException(ex);  
               }  
           }  
       }  
     }  
   }

通过在doFilter中获取和关闭Session，并在周期内运行的所有对象（Filter链中其余的Filter，及其覆盖的Servlet 和其他对象）对此Session 实例进行重用，保证了一个Http Request处理过程中只占用一个Session，提高了整体性能表现。在实际设计中，Session的重用做到线程级别一般已经足够，企图通过HttpSession实现用户级的Session重用反而可能导致其他的问题。凡事不能过火，Session重用也一样。

Hibernate中的Transaction

Hibernate是对JDBC的轻量级对象封装，Hibernate本身是不具备Transaction处理功能的，Hibernate的Transaction实际上是底层的JDBC Transaction的封装，或者是JTA Transaction的封装，下面我们详细的分析：

Hibernate可以配置为JDBCTransaction或者是JTATransaction，这取决于你在hibernate.properties中的配置:

引用
hibernate.transaction.factory_class net.sf.hibernate.transaction.JTATransactionFactory
hibernate.transaction.factory_class net.sf.hibernate.transaction.JDBCTransactionFactory
如果你什么都不配置，默认情况下使用JDBCTransaction，不管你准备让Hibernate使用JDBCTransaction，还是JTATransaction，我的忠告就是什么都不配，将让它保持默认状态，如下：
在下面的分析中我会给出原因。

一、JDBC Transaction

看看使用JDBC Transaction的时候我们的代码例子：

Java代码

Session session = sf.openSession(); 
Transaction tx = session.beginTransactioin();  
...   
session.flush();   
tx.commit();
session.close();

这是默认的情况，当你在代码中使用Hibernate的Transaction的时候实际上就是JDBCTransaction。那么JDBCTransaction究竟是什么东西呢？来看看源代码就清楚了：

Hibernate2.0.3源代码中的类
Java代码

//net.sf.hibernate.transaction.JDBCTransaction:   
 public void begin(); throws HibernateException {   
    log.debug("begin");;       
    try {   
        toggleAutoCommit = session.connection();.getAutoCommit();;   
        if (toggleAutoCommit); session.connection();.setAutoCommit(false);;   
    }   
    catch (SQLException e); {   
        log.error("Begin failed", e);;   
        throw new TransactionException("Begin failed with SQL exception: ", e);;   
    }      
    begun = true;   
}

这是启动Transaction的方法，看到 connection().setAutoCommit(false) 了吗？是不是很熟悉？

public void commit(); throws HibernateException {      
    if (!begun); throw new TransactionException("Transaction not successfully started");     
    log.debug("commit");   
    try {   
        if ( session.getFlushMode();!=FlushMode.NEVER ); session.flush();   
        try {   
            session.connection().commit();   
            committed = true;   
        }   
        catch (SQLException e){   
            log.error("Commit failed", e);   
            throw new TransactionException("Commit failed with SQL exception: ", e);
        }   
    }   
    finally {   
        session.afterTransactionCompletion();   
    }   
    toggleAutoCommit();   
}

这是提交方法，看到connection().commit() 了吗？下面就不用我多说了，这个类代码非常简单易懂，通过阅读使我们明白Hibernate的Transaction都在干了些什么？我现在把用Hibernate写的例子翻译成JDBC，大家就一目了然了：

Java代码
Connection conn = …; <— session = sf.openSession();;
conn.setAutoCommit(false);; <— tx = session.beginTransactioin();;
… <— …
conn.commit();; <— tx.commit();; (对应左边的两句);
conn.setAutoCommit(true);;
conn.close();; <— session.close();;

看明白了吧，Hibernate的JDBCTransaction根本就是conn.commit而已，根本毫无神秘可言，只不过在Hibernate中，Session打开的时候，就会自动conn.setAutoCommit(false)，不像一般的JDBC，默认都是true，所以你最后不写commit也没有关系，由于Hibernate已经把AutoCommit给关掉了，所以用Hibernate的时候，你在程序中不写Transaction的话，数据库根本就没有反应。