Hibernate - Dicas de desempenho

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

static {

try {

// Cria o SessionFactory

sessionFactory = new Configuration().configure(“hibernate.cfg.xml”)

.buildSessionFactory();

} catch (Throwable ex) {

// Cria um log caso haja uma exeção

log.error(“Initial SessionFactory creation failed.”, ex);

throw new ExceptionInInitializerError(ex);

}

}

public static Session currentSession() {

Session s = (Session) session.get();

// Open a new Session, if this Thread has none yet

if (s == null) {

s = sessionFactory.openSession();

session.set(s);

}

return s;

}

public static void closeSession() {

Session s = (Session) session.get();

if (s != null)

s.close();

session.set(null);

}

}

import org.hibernate.<em>;

import org.hibernate.cfg.Configuration;

import org.apache.commons.logging.</em>;

private static Log log = LogFactory.getLog(HibernateUtil.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();


static {
	try {
		configuration = new Configuration();
		sessionFactory = configuration.configure("hibernate.cfg.xml").buildSessionFactory();

	} catch (Throwable ex) {
		
		log.error("Building SessionFactory failed.", ex);
		throw new ExceptionInInitializerError(ex);
	}
}


public static SessionFactory getSessionFactory() {

	return sessionFactory;
}

public static Configuration getConfiguration() {
	return configuration;
}

/**
 * Rebuild the SessionFactory with the static Configuration.
 * 
 */
public static void rebuildSessionFactory() {
	synchronized (sessionFactory) {
		try {
			sessionFactory = getConfiguration().buildSessionFactory();
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

/**
 * Rebuild the SessionFactory with the given Hibernate Configuration.
 * 
 * @param cfg
 */
public static void rebuildSessionFactory(Configuration cfg) {
	synchronized (sessionFactory) {
		try {
			sessionFactory = cfg.buildSessionFactory();
			configuration = cfg;
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

/**
 * 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() {
	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) {
		ex.printStackTrace();
	}
	return s;
}

/**
 * Closes the Session local to the thread.
 */
public static void closeSession(){
	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) {
		ex.printStackTrace();
	}
}

/**
 * Start a new database transaction.
 */
public static void beginTransaction(){
	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) {
		ex.printStackTrace();
	}
}

/**
 * Commit the database transaction.
 */
public static void commitTransaction() {
	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();
		ex.printStackTrace();
	}
}

/**
 * Commit the database transaction.
 */
public static void rollbackTransaction() {
	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) {
		ex.printStackTrace();
	} finally {
		closeSession();
	}
}

/**
 * Reconnects a Hibernate Session to the current Thread.
 * 
 * @param session
 *            The Hibernate Session to be reconnected.
 */
public static void reconnect(Session session) {
	try {
		session.reconnect();
		threadSession.set(session);
	} catch (HibernateException ex) {
		ex.printStackTrace();
	}
}

/**
 * Disconnect and return Session from current Thread.
 * 
 * @return Session the disconnected Session
 */
public static Session disconnectSession(){

	Session session = getSession();
	try {
		threadSession.set(null);
		if (session.isConnected() && session.isOpen())
			session.disconnect();
	} catch (HibernateException ex) {
		ex.printStackTrace();
	}
	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;
}