线程安全hibernate的session管理类实现

序：最近在学hibernate框架，按照threadlocal的思维来实现了一个hibernate的session管理类，因为一本书上的资料，但是发现他的写法不是线程安全的，所以这里我实现了一个线程安全的session管理类，顺便复习一下锁的知识。

代码：

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class HibernateUtil {
    //会话工厂
    private static SessionFactory sessionFactory;

    //读写锁
    private static ReadWriteLock rwlock=new ReentrantReadWriteLock();

    //ThreadLocal类
    private static final ThreadLocal<Session> threadLocal =new ThreadLocal<Session>(){
        @Override
        protected Session initialValue() {
            //获取session可以并行执行，但与重构factory互斥，所以上读锁。
            rwlock.readLock().lock();
            try {
                return sessionFactory.openSession();
            }catch (Exception ex){
                //创建session失败
                ex.printStackTrace();
                return null;
            }finally {
                rwlock.readLock().unlock();
            }
        }

        @Override
        public void remove() {
            Session session=get();
            session.close();
            set(null);
        }
    };

    static {
        //初始化时创建session工厂
        Configuration cfg=new Configuration().configure();
        sessionFactory=cfg.buildSessionFactory();
    }

    //获取Session
    public static Session getSession() throws HibernateException{
        return threadLocal.get();
    }

    //获取会话工厂
    public static SessionFactory getSessionFactory(){
        return sessionFactory;
    }

    //关闭Session
    public static void closeSession() throws HibernateException{
        threadLocal.remove();
    }

    //重建会话工厂
    public static void rebuildSessionFactory(){
        //重构factory与所有相关操作互斥，所以上写锁。
        rwlock.writeLock().lock();
        try {
            Configuration cfg=new Configuration().configure();
            sessionFactory.close();
            sessionFactory=cfg.buildSessionFactory();
        }catch (Exception ex){
            ex.printStackTrace();
        }finally {
            rwlock.writeLock().unlock();
        }
    }
}

这里我选择把session创建和关闭的过程都封装到threadlocal的重构方法中，这样可以方便实现和减少程序耦合度。