I was running into the caching issue too. I have a HibernateUtility class that handles Hibernate sessions for threads using ThreadLocal variables. Since my server opens a bunch of threads, then leaves them open to service future requests, the cache for one thread would be updated, but all other threads would have old data. As a temporary fix, I added a clear(); to the HibernateUtility class to clear the session every time it was retrieved. That's when I ran into the problem described here (call to update() after call to clear() produces an error). I fixed this by passing the HttpServetRequest into the HibernateUtility class and storing its hash in a ThreadLocal variable. If a session is retrieved twice in the same request, it is only cleared the first time. This may not be the best way, but it's easy and it works!
Oh! Much props to the authors of Hibernate in Action. This is their code. I just modified it slightly for web use.
package com.idex.hibernate;
import javax.servlet.http.HttpServletRequest;
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;
/**
* Basic Hibernate helper class, handles SessionFactory, Session and
* Transaction.
* <p>
* Uses a static initializer for the initial SessionFactory creation and holds
* Session and Transactions in thread local variables. All exceptions are
* wrapped in an unchecked InfrastructureException.
* @author christian@hibernate.org
*/
public class HibernateUtility {
private static Log log = LogFactory.getLog(HibernateUtility.class);
private static Configuration configuration;
private static SessionFactory sessionFactory;
private static final ThreadLocal<Session> threadSession =
new ThreadLocal<Session>();
private static final ThreadLocal<Transaction> threadTransaction =
new ThreadLocal<Transaction>();
private static final ThreadLocal<Integer> threadRequestHash =
new ThreadLocal<Integer>();
private static final ThreadLocal<Interceptor> threadInterceptor =
new ThreadLocal<Interceptor>();
// 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 InfrastructureException {
synchronized (sessionFactory) {
try {
sessionFactory = getConfiguration().buildSessionFactory();
}
catch (Exception ex) {
throw new InfrastructureException(ex);
}
}
}
/**
* Rebuild the SessionFactory with the given Hibernate Configuration.
* @param cfg
*/
public static void rebuildSessionFactory(Configuration cfg)
throws InfrastructureException {
synchronized (sessionFactory) {
try {
sessionFactory = cfg.buildSessionFactory();
configuration = cfg;
}
catch (Exception ex) {
throw new InfrastructureException(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
*/
private static Session getSession(Integer requestHash) {
Session s = threadSession.get();
try {
if (s == null) {
log.debug("Opening new Session for this thread.");
if (HibernateUtility.getInterceptor() != null) {
log.debug("Using interceptor: " + HibernateUtility.getInterceptor().
getClass());
s = getSessionFactory().openSession(
HibernateUtility.getInterceptor());
}
else {
s = getSessionFactory().openSession();
}
threadSession.set(s);
}
}
catch (HibernateException ex) {
throw new InfrastructureException(ex);
}
if (threadRequestHash.get() == null) {
threadRequestHash.set(requestHash);
}
else if (requestHash != threadRequestHash.get()) {
threadRequestHash.set(requestHash);
s.flush();
s.clear();
}
return s;
}
/**
* 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(HttpServletRequest request)
throws InfrastructureException {
return HibernateUtility.getSession(request.hashCode());
}
/**
* Closes the Session local to the thread.
*/
public static void closeSession() throws InfrastructureException {
try {
Session s = threadSession.get();
threadSession.set(null);
if (s != null && s.isOpen()) {
log.debug("Closing Session of this thread.");
s.close();
}
}
catch (HibernateException ex) {
throw new InfrastructureException(ex);
}
}
/**
* Start a new database transaction.
*/
public static void beginTransaction() throws InfrastructureException {
Transaction tx = threadTransaction.get();
try {
if (tx == null) {
log.debug("Starting new database transaction in this thread.");
tx = getSession(threadRequestHash.get()).beginTransaction();
threadTransaction.set(tx);
}
}
catch (HibernateException ex) {
throw new InfrastructureException(ex);
}
}
/**
* Commit the database transaction.
*/
public static void commitTransaction() throws InfrastructureException {
Transaction tx = 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) {
HibernateUtility.rollbackTransaction();
throw new InfrastructureException(ex);
}
}
/**
* Commit the database transaction.
*/
public static void rollbackTransaction() throws InfrastructureException {
Transaction tx = 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 InfrastructureException(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 InfrastructureException {
try {
session.reconnect();
threadSession.set(session);
}
catch (HibernateException ex) {
throw new InfrastructureException(ex);
}
}
/**
* Disconnect and return Session from current Thread.
* @return Session the disconnected Session
*/
public static Session disconnectSession() throws InfrastructureException {
Session session = getSession(threadRequestHash.get());
try {
threadSession.set(null);
if (session.isConnected() && session.isOpen())
session.disconnect();
}
catch (HibernateException ex) {
throw new InfrastructureException(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 = threadInterceptor.get();
return interceptor;
}
}
Login
FAQ
Search
