Automatically close SessionFactory objects

SessionFactory objects created by
SessionFactoryBuilderSupport#buildSessionFactory are now DisposableBean
proxies that call SessionFactory#close and release any threadlocal
DataSource object.

This is the same behavior that has always occurred during LSFBean and
ASFBean destruction lifecycles (and still does). This destruction logic
has now been factored out into
SessionFactoryBuilderSupport#closeHibernateSessionFactory such that all
SFB types can reuse it easily.

Note that LSFBean and ASFBean are subclasses, respectively, of SFBuilder
and ASFBuilder and they each must disable the DisposableBean proxying in
order to avoid duplicate attempts at closing the SessionFactory. See
the implementations of wrapSessionFactoryIfNeccesary() for details.

Issue: SPR-8114

git-svn-id: https://src.springframework.org/svn/spring-framework/trunk@4240 50f2f4bb-b051-0410-bef5-90022cba6387

org.springframework.integration-tests/src/test/java/org/springframework/orm/hibernate3/HibernateSessionFactoryConfigurationTests.java

@@ -19,7 +19,9 @@ package org.springframework.orm.hibernate3;
 import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.Matchers.startsWith;
 import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
 
 import java.io.File;
 import java.util.List;
@@ -34,6 +36,7 @@ import org.hibernate.classic.Session;
 import org.junit.Ignore;
 import org.junit.Test;
 import org.springframework.beans.factory.BeanCreationException;
+import org.springframework.beans.factory.DisposableBean;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -130,6 +133,16 @@ public class HibernateSessionFactoryConfigurationTests {
 		}
 	}
 
+	@Test
+	public void builtSessionFactoryIsDisposableBeanProxy() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(AnnotationSessionFactoryConfig.class);
+		SessionFactory sessionFactory = ctx.getBean(SessionFactory.class);
+		assertThat(sessionFactory, instanceOf(DisposableBean.class));
+		assertThat(sessionFactory.toString(), startsWith("DisposableBean proxy for SessionFactory"));
+		ctx.close();
+		assertTrue("SessionFactory was not closed as expected", sessionFactory.isClosed());
+	}
+
 
 	private void saveAndRetriveEntity(Class<?> configClass) {
 		SessionFactory sessionFactory = new AnnotationConfigApplicationContext(configClass).getBean(SessionFactory.class);

org.springframework.orm/src/main/java/org/springframework/orm/hibernate3/LocalSessionFactoryBean.java

@@ -17,8 +17,8 @@
 package org.springframework.orm.hibernate3;
 
 import org.hibernate.HibernateException;
-
 import org.hibernate.SessionFactory;
+
 import org.springframework.dao.DataAccessException;
 import org.springframework.jdbc.support.SQLExceptionTranslator;
 
@@ -110,6 +110,11 @@ public class LocalSessionFactoryBean extends SessionFactoryBuilder implements Se
 		delegate.setPersistenceExceptionTranslator(hibernateExceptionTranslator);
 	}
 
+	@Override
+	public SessionFactory wrapSessionFactoryIfNecessary(SessionFactory rawSf) {
+		return delegate.wrapSessionFactoryIfNecessary(rawSf);
+	}
+
 	/**
 	 * @deprecated as of Spring 3.1 in favor of {@link #newSessionFactory()} which
 	 * can access the internal {@code Configuration} instance via {@link #getConfiguration()}.

org.springframework.orm/src/main/java/org/springframework/orm/hibernate3/SessionFactoryBeanDelegate.java

@@ -16,8 +16,6 @@
 
 package org.springframework.orm.hibernate3;
 
-import javax.sql.DataSource;
-
 import org.hibernate.HibernateException;
 import org.hibernate.SessionFactory;
 import org.hibernate.cache.RegionFactory;
@@ -115,23 +113,7 @@ public class SessionFactoryBeanDelegate implements SessionFactoryBeanOperations
 	}
 
 	public void destroy() throws HibernateException {
-		builder.logger.info("Closing Hibernate SessionFactory");
+		SessionFactoryBuilderSupport.closeHibernateSessionFactory(this.builder, this.sessionFactory);
-		DataSource dataSource = builder.getDataSource();
-		if (dataSource != null) {
-			// Make given DataSource available for potential SchemaExport,
-			// which unfortunately reinstantiates a ConnectionProvider.
-			SessionFactoryBuilderSupport.configTimeDataSourceHolder.set(dataSource);
-		}
-		try {
-			builder.beforeSessionFactoryDestruction();
-		}
-		finally {
-			this.sessionFactory.close();
-			if (dataSource != null) {
-				// Reset DataSource holder.
-				SessionFactoryBuilderSupport.configTimeDataSourceHolder.remove();
-			}
-		}
 	}
 
 	public void setJdbcExceptionTranslator(SQLExceptionTranslator jdbcExceptionTranslator) {
@@ -142,6 +124,11 @@ public class SessionFactoryBeanDelegate implements SessionFactoryBeanOperations
 		return hibernateExceptionTranslator.translateExceptionIfPossible(ex);
 	}
 
+	public SessionFactory wrapSessionFactoryIfNecessary(SessionFactory rawSf) {
+		return rawSf;
+	}
+
+
 	/**
 	 * @see SessionFactoryBuilderSupport#preBuildSessionFactory()
 	 */

org.springframework.orm/src/main/java/org/springframework/orm/hibernate3/SessionFactoryBeanOperations.java

@@ -125,4 +125,12 @@ public interface SessionFactoryBeanOperations
 	 */
 	DataAccessException translateExceptionIfPossible(RuntimeException ex);
 
+	/**
+	 * Override the default {@link DisposableBean} proxying behavior in
+	 * {@link SessionFactoryBuilderSupport#wrapSessionFactoryIfNecessary(SessionFactory)}
+	 * and return the raw {@code SessionFactory} instance, as {@link SessionFactory#close()}
+	 * will be called during this FactoryBean's normal {@linkplain #destroy() destruction lifecycle}.
+	 */
+	SessionFactory wrapSessionFactoryIfNecessary(SessionFactory rawSf);
+
 }

org.springframework.orm/src/main/java/org/springframework/orm/hibernate3/SessionFactoryBuilderSupport.java

@@ -18,7 +18,9 @@ package org.springframework.orm.hibernate3;
 
 import java.io.File;
 import java.lang.reflect.Array;
+import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
 import java.sql.Connection;
 import java.sql.SQLException;
 import java.sql.Statement;
@@ -32,6 +34,7 @@ import javax.transaction.TransactionManager;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+
 import org.hibernate.HibernateException;
 import org.hibernate.Interceptor;
 import org.hibernate.Session;
@@ -45,7 +48,10 @@ import org.hibernate.engine.SessionFactoryImplementor;
 import org.hibernate.event.EventListeners;
 import org.hibernate.tool.hbm2ddl.DatabaseMetadata;
 import org.hibernate.transaction.JTATransactionFactory;
+
 import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.DisposableBean;
+import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.core.io.Resource;
 import org.springframework.dao.DataAccessException;
@@ -552,16 +558,37 @@ public abstract class SessionFactoryBuilderSupport<This extends SessionFactoryBu
 	}
 
 	/**
-	 * Wrap the given SessionFactory with a proxy, if demanded.
+	 * Wrap the given {@code SessionFactory} with a proxy, if demanded.
-	 * <p>The default implementation simply returns the given SessionFactory as-is.
+	 * <p>The default implementation wraps the given {@code SessionFactory} as a Spring
-	 * Subclasses may override this to implement transaction awareness through
+	 * {@link DisposableBean} proxy in order to call {@link SessionFactory#close()} on
-	 * a SessionFactory proxy, for example.
+	 * {@code ApplicationContext} {@linkplain ConfigurableApplicationContext#close() shutdown}.
-	 * @param rawSf the raw SessionFactory as built by {@link #buildSessionFactory()}
+	 * <p>Subclasses may override this to implement transaction awareness through
-	 * @return the SessionFactory reference to expose
+	 * a {@code SessionFactory} proxy for example, or even to avoid creation of the
+	 * {@code DisposableBean} proxy altogether.
+	 * @param rawSf the raw {@code SessionFactory} as built by {@link #buildSessionFactory()}
+	 * @return the {@code SessionFactory} reference to expose
 	 * @see #buildSessionFactory()
 	 */
-	protected SessionFactory wrapSessionFactoryIfNecessary(SessionFactory rawSf) {
+	protected SessionFactory wrapSessionFactoryIfNecessary(final SessionFactory rawSf) {
-		return rawSf;
+		return (SessionFactory) Proxy.newProxyInstance(
+			this.beanClassLoader,
+			new Class<?>[] {
+				SessionFactory.class,
+				DisposableBean.class
+			},
+			new InvocationHandler() {
+				public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+					if (ReflectionUtils.isToStringMethod(method)) {
+						return String.format("DisposableBean proxy for SessionFactory [%s]", rawSf.toString());
+					}
+					if (method.equals(DisposableBean.class.getMethod("destroy"))) {
+						closeHibernateSessionFactory(SessionFactoryBuilderSupport.this, rawSf);
+						rawSf.close();
+						return null;
+					}
+					return method.invoke(rawSf, args);
+				}
+			});
 	}
 
 	/**
@@ -1409,4 +1436,24 @@ public abstract class SessionFactoryBuilderSupport<This extends SessionFactoryBu
 		return configTimeLobHandlerHolder.get();
 	}
 
+	static void closeHibernateSessionFactory(SessionFactoryBuilderSupport<?> builder, SessionFactory sessionFactory) {
+		builder.logger.info("Closing Hibernate SessionFactory");
+		DataSource dataSource = builder.getDataSource();
+		if (dataSource != null) {
+			// Make given DataSource available for potential SchemaExport,
+			// which unfortunately reinstantiates a ConnectionProvider.
+			SessionFactoryBuilderSupport.configTimeDataSourceHolder.set(dataSource);
+		}
+		try {
+			builder.beforeSessionFactoryDestruction();
+		}
+		finally {
+			sessionFactory.close();
+			if (dataSource != null) {
+				// Reset DataSource holder.
+				SessionFactoryBuilderSupport.configTimeDataSourceHolder.remove();
+			}
+		}
+	}
+
 }

org.springframework.orm/src/main/java/org/springframework/orm/hibernate3/annotation/AnnotationSessionFactoryBean.java

@@ -18,6 +18,7 @@ package org.springframework.orm.hibernate3.annotation;
 
 import org.hibernate.HibernateException;
 import org.hibernate.SessionFactory;
+
 import org.springframework.context.ResourceLoaderAware;
 import org.springframework.core.io.ResourceLoader;
 import org.springframework.core.io.support.ResourcePatternUtils;
@@ -134,6 +135,11 @@ public class AnnotationSessionFactoryBean extends AnnotationSessionFactoryBuilde
 		delegate.setPersistenceExceptionTranslator(hibernateExceptionTranslator);
 	}
 
+	@Override
+	public SessionFactory wrapSessionFactoryIfNecessary(SessionFactory rawSf) {
+		return delegate.wrapSessionFactoryIfNecessary(rawSf);
+	}
+
 	/**
 	 * @deprecated as of Spring 3.1 in favor of {@link #scanPackages()} which
 	 * can access the internal {@code AnnotationConfiguration} instance via