tangled up with session management 101

[Stuart Rogers]

Greetings all,

I've created a standalone (not webapp) Java/Hibernate application, roughly patterned after the HelloWorld example from hibernate.org .
I'm trying to use the "thread-bound strategy" (should I be? Future bigger apps will be webapps on a Tomcat server w/o JNDI )
All looks good until execution when it starts throwing messages like "session already closed", etc.

my hibernate.cfg.xml contains:

    <property name="current_session_context_class">thread</property>

my HibernateUtil.java :

package sais.persistence;

import org.hibernate.*;
import org.hibernate.cfg.*;
import org.apache.commons.logging.*;

import javax.naming.*;

/**
 * Basic Hibernate helper class for Hibernate configuration and startup.
 * <p>
 * Uses a static initializer to read startup options and initialize
 * <tt>Configuration</tt> and <tt>SessionFactory</tt>.
 * <p>
 * This class also tries to figure out if JNDI binding of the <tt>SessionFactory</tt>
 * is used, otherwise it falls back to a global static variable (Singleton). If
 * you use this helper class to obtain a <tt>SessionFactory</tt> in your code,
 * you are shielded from these deployment differences.
 * <p>
 * Another advantage of this class is access to the <tt>Configuration</tt> object
 * that was used to build the current <tt>SessionFactory</tt>. You can access
 * mapping metadata programmatically with this API, and even change it and rebuild
 * the <tt>SessionFactory</tt>.
 * <p>
 * Note: This class supports annotations if you replace the line that creates
 * a Configuration object.
 * <p>
 * Note: This class supports only one data store. Support for several
 * <tt>SessionFactory</tt> instances can be easily added (through a static <tt>Map</tt>,
 * for example). You could then lookup a <tt>SessionFactory</tt> by its name.
 *
 * @author Christian Bauer
 */
public class HibernateUtil {

    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();

    private static boolean isUseAnnotations = true;

    // Create the initial SessionFactory from the default configuration files
    static {
        try {
            log.debug("Initializing Hibernate");

            if( isUseAnnotations) {
              configuration = new AnnotationConfiguration();
            } else {
              configuration = new Configuration();
            }

            // Read hibernate.cfg.xml (has to be present)
            configuration.configure();

            // Build and store (either in JNDI or static variable)
            rebuildSessionFactory(configuration);

            log.debug("Hibernate initialized, call HibernateUtil.getSessionFactory()");
        } 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 Hibernate configuration that was used to build the SessionFactory.
     *
     * @return Configuration
     */
    public static Configuration getConfiguration() {
        return configuration;
    }

    /**
     * Returns the global SessionFactory either from a static variable or a JNDI lookup.
     *
     * @return SessionFactory
     */
    public static SessionFactory getSessionFactory() {
        String sfName = configuration.getProperty(Environment.SESSION_FACTORY_NAME);
        if ( sfName != null) {
            log.debug("Looking up SessionFactory in JNDI");
            try {
                return (SessionFactory) new InitialContext().lookup(sfName);
            } catch (NamingException ex) {
                throw new RuntimeException(ex);
            }
        } else if (sessionFactory == null) {
            rebuildSessionFactory();
        }
        return sessionFactory;
    }

    /**
     * Closes the current SessionFactory and releases all resources.
     * <p>
     * The only other method that can be called on HibernateUtil
     * after this one is rebuildSessionFactory(Configuration).
     */
    public static void shutdown() {
        log.debug("Shutting down Hibernate");
        // Close caches and connection pools
        getSessionFactory().close();

        // Clear static variables
        sessionFactory = null;
    }


    /**
     * Rebuild the SessionFactory with the static Configuration.
     * <p>
     * Note that this method should only be used with static SessionFactory
     * management, not with JNDI or any other external registry. This method also closes
     * the old static variable SessionFactory before, if it is still open.
     */
     public static void rebuildSessionFactory() {
        log.debug("Using current Configuration to rebuild SessionFactory");
        rebuildSessionFactory(configuration);
     }

    /**
     * Rebuild the SessionFactory with the given Hibernate Configuration.
     * <p>
     * HibernateUtil does not configure() the given Configuration object,
     * it directly calls buildSessionFactory(). This method also closes
     * the old static variable SessionFactory before, if it is still open.
     *
     * @param cfg
     */
     public static void rebuildSessionFactory(Configuration cfg) {
        log.debug("Rebuilding the SessionFactory from given Configuration");
        if (sessionFactory != null && !sessionFactory.isClosed())
            sessionFactory.close();
        if (cfg.getProperty(Environment.SESSION_FACTORY_NAME) != null) {
            log.debug("Managing SessionFactory in JNDI");
            cfg.buildSessionFactory();
        } else {
            log.debug("Holding SessionFactory in static variable");
            sessionFactory = cfg.buildSessionFactory();
        }
        configuration = cfg;
     }

}

my StateCodeDAOHibernate.java

package sais.dao.hibernate;

import org.hibernate.*;
import sais.model.StateCode;
import sais.dao.StateCodeDAO;

import static org.hibernate.criterion.Expression.*;

import java.util.List;

/**
 * Hibernate-specific implementation of the <tt>UserDAO</tt>
 * non-CRUD data access object.
 *
 * @author Christian Bauer
 */
public class StateCodeDAOHibernate extends GenericHibernateDAO<StateCode, Long> implements StateCodeDAO
{
  @SuppressWarnings("unchecked")
  public List<StateCode> getAll()
  {
    List<StateCode> results = null;

    Query hqlQuery = getSession().createQuery( "FROM StateCode "); // HQL uses CLASS names not TABLE names
    results = hqlQuery.list();

    return results;
  }

  @SuppressWarnings("unchecked")
  public StateCode getRowGivenCode( char[] cdde)
  {
    List<StateCode> results = null;
    StateCode result = null;
    String sqlcmd = "";
    
    sqlcmd = "SELECT * FROM StateCode WHERE code = :kxa ";
    Query hqlQuery = getSession().createQuery( sqlcmd); // HQL uses CLASS names not TABLE names
    hqlQuery.setParameter( "kxa", cdde);
    results = hqlQuery.list();
    if( results.size() == 1) {
    	result = results.get(0);
    }

    return result;
  }

}

my StateCodeDAO.java :

package sais.dao;

import sais.model.*;

import java.util.List;

/**
 * Business DAO operations related to the <tt>User</tt> entity.
 *
 * @see User
 * @author Christian Bauer
 */
public interface StateCodeDAO extends GenericDAO<StateCode, Long>
{
  public List<StateCode> getAll();
  public StateCode getRowGivenCode( char[] cdde);
}

and finally my application class (containing main() ) :

.....
    
    public static void main( String[] args)
    {
        SessionFactory sf = HibernateUtil.getSessionFactory();
        Session aSession = sf.getCurrentSession();
        Transaction tx = aSession.beginTransaction();
        
        StateCodeDAO stateCodeDAO = new StateCodeDAOHibernate();
        
        List<StateCode> bonker = new LinkedList<StateCode>();
        bonker = stateCodeDAO.getAll();
 
        tx.commit();
        aSession.close();

        System.out.println("finishing");
        sf.close();
        HibernateUtil.shutdown();
    }
    ....
}

I think my problem(s) lie in my HibernateUtil - there's quite a few to choose from on the 'net, all based on different examples under different assumptions.

Any and all help/suggestions/hints/fixes/constructive criticisms are welcome.

TIA,

Still-learning Steve

[Bosun Bello]

I noticed that you closed the session factory twice.

# sf.close();
# HibernateUtil.shutdown();