diff --git a/spring-orm/src/main/java/org/springframework/orm/hibernate4/ConfigurableJtaPlatform.java b/spring-orm/src/main/java/org/springframework/orm/hibernate4/ConfigurableJtaPlatform.java new file mode 100644 index 0000000000..76d1fc63b8 --- /dev/null +++ b/spring-orm/src/main/java/org/springframework/orm/hibernate4/ConfigurableJtaPlatform.java @@ -0,0 +1,74 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.orm.hibernate4; + +import javax.transaction.TransactionManager; +import javax.transaction.UserTransaction; + +import org.hibernate.service.jta.platform.internal.AbstractJtaPlatform; + +import org.springframework.transaction.jta.UserTransactionAdapter; +import org.springframework.util.Assert; + +/** + * Implementation of Hibernate 4's {@link org.hibernate.service.jta.platform.spi.JtaPlatform} + * SPI, exposing passed-in {@link TransactionManager} and {@link UserTransaction} references. + * + * @author Juergen Hoeller + * @since 3.1.2 + */ +class ConfigurableJtaPlatform extends AbstractJtaPlatform { + + private final TransactionManager transactionManager; + + private final UserTransaction userTransaction; + + + /** + * Create a new ConfigurableJtaPlatform instance with the given + * JTA TransactionManager and optionally a given UserTransaction. + * @param tm the JTA TransactionManager reference (required) + * @param ut the JTA UserTransaction reference (optional) + */ + public ConfigurableJtaPlatform(TransactionManager tm, UserTransaction ut) { + Assert.notNull(tm, "TransactionManager reference must not be null"); + this.transactionManager = tm; + this.userTransaction = (ut != null ? ut : new UserTransactionAdapter(tm)); + } + + + @Override + protected TransactionManager locateTransactionManager() { + return this.transactionManager; + } + + @Override + protected UserTransaction locateUserTransaction() { + return this.userTransaction; + } + + @Override + protected boolean canCacheTransactionManager() { + return true; + } + + @Override + protected boolean canCacheUserTransaction() { + return true; + } + +} diff --git a/spring-orm/src/main/java/org/springframework/orm/hibernate4/LocalSessionFactoryBean.java b/spring-orm/src/main/java/org/springframework/orm/hibernate4/LocalSessionFactoryBean.java index 075a5f6cee..779d5aca01 100644 --- a/spring-orm/src/main/java/org/springframework/orm/hibernate4/LocalSessionFactoryBean.java +++ b/spring-orm/src/main/java/org/springframework/orm/hibernate4/LocalSessionFactoryBean.java @@ -48,6 +48,12 @@ import org.springframework.core.io.support.ResourcePatternUtils; * However, in practice, it is closer to AnnotationSessionFactoryBean since * its core purpose is to bootstrap a SessionFactory from annotation scanning. * + *

NOTE: To set up Hibernate 4 for Spring-driven JTA transactions, make + * sure to either specify the {@link #setJtaTransactionManager "jtaTransactionManager"} + * bean property or to set the "hibernate.transaction.factory_class" property to + * {@link org.hibernate.engine.transaction.internal.jta.CMTTransactionFactory}. + * Otherwise, Hibernate's smart flushing mechanism won't work properly. + * * @author Juergen Hoeller * @since 3.1 * @see #setDataSource @@ -82,6 +88,8 @@ public class LocalSessionFactoryBean extends HibernateExceptionTranslator private String[] packagesToScan; + private Object jtaTransactionManager; + private ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver(); private Configuration configuration; @@ -250,6 +258,16 @@ public class LocalSessionFactoryBean extends HibernateExceptionTranslator this.packagesToScan = packagesToScan; } + /** + * Set the Spring {@link org.springframework.transaction.jta.JtaTransactionManager} + * or the JTA {@link javax.transaction.TransactionManager} to be used with Hibernate, + * if any. + * @see LocalSessionFactoryBuilder#setJtaTransactionManager + */ + public void setJtaTransactionManager(Object jtaTransactionManager) { + this.jtaTransactionManager = jtaTransactionManager; + } + public void setResourceLoader(ResourceLoader resourceLoader) { this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader); } @@ -330,6 +348,10 @@ public class LocalSessionFactoryBean extends HibernateExceptionTranslator sfb.scanPackages(this.packagesToScan); } + if (this.jtaTransactionManager != null) { + sfb.setJtaTransactionManager(this.jtaTransactionManager); + } + // Build SessionFactory instance. this.configuration = sfb; this.sessionFactory = buildSessionFactory(sfb); diff --git a/spring-orm/src/main/java/org/springframework/orm/hibernate4/LocalSessionFactoryBuilder.java b/spring-orm/src/main/java/org/springframework/orm/hibernate4/LocalSessionFactoryBuilder.java index 23ace2b401..0113d07b6d 100644 --- a/spring-orm/src/main/java/org/springframework/orm/hibernate4/LocalSessionFactoryBuilder.java +++ b/spring-orm/src/main/java/org/springframework/orm/hibernate4/LocalSessionFactoryBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2011 the original author or authors. + * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -22,12 +22,16 @@ import javax.persistence.Embeddable; import javax.persistence.Entity; import javax.persistence.MappedSuperclass; import javax.sql.DataSource; +import javax.transaction.TransactionManager; import org.hibernate.HibernateException; import org.hibernate.MappingException; import org.hibernate.SessionFactory; +import org.hibernate.cfg.AvailableSettings; import org.hibernate.cfg.Configuration; import org.hibernate.cfg.Environment; +import org.hibernate.engine.transaction.internal.jta.CMTTransactionFactory; +import org.hibernate.service.jta.platform.internal.WebSphereExtendedJtaPlatform; import org.springframework.core.io.Resource; import org.springframework.core.io.ResourceLoader; @@ -39,6 +43,8 @@ import org.springframework.core.type.classreading.MetadataReader; import org.springframework.core.type.classreading.MetadataReaderFactory; import org.springframework.core.type.filter.AnnotationTypeFilter; import org.springframework.core.type.filter.TypeFilter; +import org.springframework.transaction.jta.JtaTransactionManager; +import org.springframework.util.Assert; import org.springframework.util.ClassUtils; import org.springframework.util.ReflectionUtils; @@ -50,6 +56,11 @@ import org.springframework.util.ReflectionUtils; *

This is designed for programmatic use, e.g. in {@code @Bean} factory methods. * Consider using {@link LocalSessionFactoryBean} for XML bean definition files. * + *

NOTE: To set up Hibernate 4 for Spring-driven JTA transactions, make + * sure to either use the {@link #setJtaTransactionManager} method or to set the + * "hibernate.transaction.factory_class" property to {@link CMTTransactionFactory}. + * Otherwise, Hibernate's smart flushing mechanism won't work properly. + * * @author Juergen Hoeller * @since 3.1 * @see LocalSessionFactoryBean @@ -97,18 +108,60 @@ public class LocalSessionFactoryBuilder extends Configuration { * Create a new LocalSessionFactoryBuilder for the given DataSource. * @param dataSource the JDBC DataSource that the resulting Hibernate SessionFactory should be using * (may be null) - * @param classLoader the ResourceLoader to load application classes from + * @param resourceLoader the ResourceLoader to load application classes from */ public LocalSessionFactoryBuilder(DataSource dataSource, ResourceLoader resourceLoader) { getProperties().put(Environment.CURRENT_SESSION_CONTEXT_CLASS, SpringSessionContext.class.getName()); if (dataSource != null) { getProperties().put(Environment.DATASOURCE, dataSource); } - getProperties().put("hibernate.classLoader.application", resourceLoader.getClassLoader()); + getProperties().put(AvailableSettings.APP_CLASSLOADER, resourceLoader.getClassLoader()); this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader); } + /** + * Set the Spring {@link JtaTransactionManager} or the JTA {@link TransactionManager} + * to be used with Hibernate, if any. Allows for using a Spring-managed transaction + * manager for Hibernate 4's session and cache synchronization, with the + * "hibernate.transaction.jta.platform" automatically set to it. Also sets + * "hibernate.transaction.factory_class" to {@link CMTTransactionFactory}, + * instructing Hibernate to interact with externally managed transactions. + *

A passed-in Spring {@link JtaTransactionManager} needs to contain a JTA + * {@link TransactionManager} reference to be usable here, except for the WebSphere + * case where we'll automatically set {@link WebSphereExtendedJtaPlatform} accordingly. + *

Note: If this is set, the Hibernate settings should not contain a JTA platform + * setting to avoid meaningless double configuration. + */ + public LocalSessionFactoryBuilder setJtaTransactionManager(Object jtaTransactionManager) { + Assert.notNull(jtaTransactionManager, "Transaction manager reference must not be null"); + if (jtaTransactionManager instanceof JtaTransactionManager) { + boolean webspherePresent = ClassUtils.isPresent("com.ibm.wsspi.uow.UOWManager", getClass().getClassLoader()); + if (webspherePresent) { + getProperties().put(AvailableSettings.JTA_PLATFORM, new WebSphereExtendedJtaPlatform()); + } + else { + JtaTransactionManager jtaTm = (JtaTransactionManager) jtaTransactionManager; + if (jtaTm.getTransactionManager() == null) { + throw new IllegalArgumentException( + "Can only apply JtaTransactionManager which has a TransactionManager reference set"); + } + getProperties().put(AvailableSettings.JTA_PLATFORM, + new ConfigurableJtaPlatform(jtaTm.getTransactionManager(), jtaTm.getUserTransaction())); + } + } + else if (jtaTransactionManager instanceof TransactionManager) { + getProperties().put(AvailableSettings.JTA_PLATFORM, + new ConfigurableJtaPlatform((TransactionManager) jtaTransactionManager, null)); + } + else { + throw new IllegalArgumentException( + "Unknown transaction manager type: " + jtaTransactionManager.getClass().getName()); + } + getProperties().put(AvailableSettings.TRANSACTION_STRATEGY, new CMTTransactionFactory()); + return this; + } + /** * Add the given annotated classes in a batch. * @see #addAnnotatedClass