En réalité, je travaille sur une application J2EE et l'ouverture et la fermeture de la session se fait dans un Filter qui est appelé à chaque requête.
La session n'est pas refermée, elle est stockée dans une variable ThreadLocal (cf code de HibernateUtil ci-dessous) et, dans le cas du test unitaire, je ne la referme pas (dans le cas de l'application J2EE, elle est refermée dans le Filter).
Donc si j'ai bien compris, ce que tu as décrit n'est pas correct pour ce cas précis.
Dans la méthode getSession de HibernatUtil, j'ai mis un log.info qui m'affiche une ligne dans la console lorsqu'une session est ouverte, et la session n'est ouverte qu'une seule fois.
J'espère que tu voudras bien me faire partager ton expérience encore un peu pour me permettre d'avancer, en attendant je vais essayer de contourner le problème en enlevant le "lazy=true".
package bab.admin.model;
import org.apache.commons.logging.*;
import org.hibernate.*;
import org.hibernate.cfg.*;
import bab.admin.model.exceptions.*;
public class HibernateUtil
{
private static Log log = LogFactory.getLog( HibernateUtil.class );
private static int configurationReaded = 0;
private static int openedSessions = 0;
private static transient Configuration configuration;
private static transient SessionFactory sessionFactory;
private static transient final ThreadLocal threadSession = new ThreadLocal();
private static transient final ThreadLocal threadTransaction = new ThreadLocal();
private static transient final ThreadLocal threadInterceptor = new ThreadLocal();
// Create the initial SessionFactory from the default configuration files
static
{
try
{
configuration = new Configuration();
sessionFactory = configuration.configure().buildSessionFactory();
log.debug( "configuration lue : " +(++configurationReaded)+ " fois." );
// 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
*/
public static Session getSession() throws InfrastructureException
{log.debug( "HibernateUtil.getSession" );
Session s = (Session)threadSession.get();
try
{
if ( s == null )
{
log.info( "Opening new Session for this thread. (" +(++openedSessions)+ " sessions ouvertes)" );
if ( getInterceptor() != null )
{
log.info( "Using interceptor: " + getInterceptor().getClass() );
s = getSessionFactory().openSession( getInterceptor() );
}
else
{
s = getSessionFactory().openSession();
}
threadSession.set( s );
}
}
catch ( HibernateException ex )
{
throw new InfrastructureException( ex );
}
return s;
}
/**
* Closes the Session local to the thread.
*/
public static void closeSession() throws InfrastructureException
{
try
{
Session s = (Session)threadSession.get();
threadSession.set( null );
if ( s != null && s.isOpen() )
{
log.info( "Closing Session of this thread. (" +(--openedSessions)+ " sessions ouvertes" );
s.clear();
s.close();
}
}
catch ( HibernateException ex )
{
throw new InfrastructureException( ex );
}
}
/**
* Start a new database transaction.
*/
public static void beginTransaction() throws InfrastructureException
{
Transaction tx = (Transaction)threadTransaction.get();
try
{
if ( tx == null )
{
System.out.println( "Début d'une nouvelle transaction pour ce Thread" );
log.debug( "Starting new database transaction in this thread." );
tx = getSession().beginTransaction();
threadTransaction.set( tx );
}
}
catch ( HibernateException ex )
{
throw new InfrastructureException( ex );
}
}
/**
* Commit the database transaction.
*/
public static void commitTransaction() throws InfrastructureException
{
Transaction tx = (Transaction)threadTransaction.get();
try
{
if ( tx != null && !tx.wasCommitted() && !tx.wasRolledBack() )
{
System.out.println( "Commit de la transaction pour ce thread" );
log.debug( "Committing database transaction of this thread." );
tx.commit();
}
threadTransaction.set( null );
}
catch ( HibernateException ex )
{
rollbackTransaction();
throw new InfrastructureException( ex );
}
}
/**
* Commit the database transaction.
*/
public static void rollbackTransaction() throws InfrastructureException
{
Transaction tx = (Transaction)threadTransaction.get();
try
{
threadTransaction.set( null );
if ( tx != null && !tx.wasCommitted() && !tx.wasRolledBack() )
{
System.out.println( "Rollback de la transaction pour ce thread ");
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
{
System.out.println( "reconnect session");
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();
try
{
System.out.println( "disconnect session ");
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 = (Interceptor)threadInterceptor.get();
return interceptor;
}
}
Login
FAQ
Search
