Hibernate Util种
Hibernate Util类
import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.hibernate.HibernateException; import org.hibernate.Interceptor; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.hibernate.cfg.Configuration; /** * * @author fei * */ public class HibernateUtil2 { private static Log log = LogFactory.getLog(HibernateUtil2.class); private static Configuration configuration; private static SessionFactory sessionFactory; private static final ThreadLocal threadSession = new ThreadLocal(); private static final ThreadLocal threadTransaction = new ThreadLocal(); private static final ThreadLocal threadInterceptor = new ThreadLocal(); // Create the initial SessionFactory from the default configuration files static { try { configuration = new Configuration(); sessionFactory = configuration.configure().buildSessionFactory(); // We could also let Hibernate bind it to JNDI: // configuration.configure().buildSessionFactory() } catch (Throwable ex) { // We have to catch Throwable, otherwise we will miss // NoClassDefFoundError and other subclasses of Error log.error("Building SessionFactory failed.", ex); throw new ExceptionInInitializerError(ex); } } /** * Returns the SessionFactory used for this static class. * * @return SessionFactory */ public static SessionFactory getSessionFactory() { // Instead of a static variable, use JNDI: // SessionFactory sessions = null; // try { // Context ctx = new InitialContext(); // String jndiName = "java:hibernate/HibernateFactory"; // sessions = (SessionFactory)ctx.lookup(jndiName); // } catch (NamingException ex) { // throw new InfrastructureException(ex); // } // return sessions; return sessionFactory; } /** * Returns the original Hibernate configuration. * * @return Configuration */ public static Configuration getConfiguration() { return configuration; } /** * Rebuild the SessionFactory with the static Configuration. * */ public static void rebuildSessionFactory() throws ExceptionInInitializerError { synchronized (sessionFactory) { try { sessionFactory = getConfiguration().buildSessionFactory(); } catch (Exception ex) { throw new ExceptionInInitializerError(ex); } } } /** * Rebuild the SessionFactory with the given Hibernate Configuration. * * @param cfg */ public static void rebuildSessionFactory(Configuration cfg) throws ExceptionInInitializerError { synchronized (sessionFactory) { try { sessionFactory = cfg.buildSessionFactory(); configuration = cfg; } catch (Exception ex) { throw new ExceptionInInitializerError(ex); } } } /** * Retrieves the current Session local to the thread. * <p/> * If no Session is open, opens a new Session for the running thread. * * @return Session */ public static Session getSession() throws ExceptionInInitializerError { Session s = (Session) threadSession.get(); try { if (s == null) { log.debug("Opening new Session for this thread."); if (getInterceptor() != null) { log.debug("Using interceptor: " + getInterceptor().getClass()); s = getSessionFactory().openSession(getInterceptor()); } else { s = getSessionFactory().openSession(); } threadSession.set(s); } } catch (HibernateException ex) { throw new ExceptionInInitializerError(ex); } return s; } /** * Closes the Session local to the thread. */ public static void closeSession() throws ExceptionInInitializerError { try { Session s = (Session) threadSession.get(); threadSession.set(null); if (s != null && s.isOpen()) { log.debug("Closing Session of this thread."); s.close(); } } catch (HibernateException ex) { throw new ExceptionInInitializerError(ex); } } /** * Start a new database transaction. */ public static void beginTransaction() throws ExceptionInInitializerError { Transaction tx = (Transaction) threadTransaction.get(); try { if (tx == null) { log.debug("Starting new database transaction in this thread."); tx = getSession().beginTransaction(); threadTransaction.set(tx); } } catch (HibernateException ex) { throw new ExceptionInInitializerError(ex); } } /** * Commit the database transaction. */ public static void commitTransaction() throws ExceptionInInitializerError { Transaction tx = (Transaction) threadTransaction.get(); try { if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack()) { log.debug("Committing database transaction of this thread."); tx.commit(); } threadTransaction.set(null); } catch (HibernateException ex) { rollbackTransaction(); throw new ExceptionInInitializerError(ex); } } /** * Commit the database transaction. */ public static void rollbackTransaction() throws ExceptionInInitializerError { Transaction tx = (Transaction) threadTransaction.get(); try { threadTransaction.set(null); if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack()) { log.debug("Tyring to rollback database transaction of this thread."); tx.rollback(); } } catch (HibernateException ex) { throw new ExceptionInInitializerError(ex); } finally { closeSession(); } } /** * Reconnects a Hibernate Session to the current Thread. * * @param session * The Hibernate Session to be reconnected. */ public static void reconnect(Session session) throws ExceptionInInitializerError { try { session.reconnect(); threadSession.set(session); } catch (HibernateException ex) { throw new ExceptionInInitializerError(ex); } } /** * Disconnect and return Session from current Thread. * * @return Session the disconnected Session */ public static Session disconnectSession() throws ExceptionInInitializerError { Session session = getSession(); try { threadSession.set(null); if (session.isConnected() && session.isOpen()) session.disconnect(); } catch (HibernateException ex) { throw new ExceptionInInitializerError(ex); } return session; } /** * Register a Hibernate interceptor with the current thread. * <p> * Every Session opened is opened with this interceptor after registration. * Has no effect if the current Session of the thread is already open, * effective on next close()/getSession(). */ public static void registerInterceptor(Interceptor interceptor) { threadInterceptor.set(interceptor); } private static Interceptor getInterceptor() { Interceptor interceptor = (Interceptor) threadInterceptor.get(); return interceptor; } }