Support spring transaction manager properties

Add Spring TransactionManager properties to allow timeout and rollback
settings to be configured.

See gh-7561

Author: kazuki43zoo

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/batch/BasicBatchConfigurer.java

@@ -30,6 +30,7 @@
 import org.springframework.batch.core.launch.support.SimpleJobLauncher;
 import org.springframework.batch.core.repository.JobRepository;
 import org.springframework.batch.core.repository.support.JobRepositoryFactoryBean;
+import org.springframework.boot.autoconfigure.transaction.TransactionProperties;
 import org.springframework.jdbc.datasource.DataSourceTransactionManager;
 import org.springframework.orm.jpa.JpaTransactionManager;
 import org.springframework.transaction.PlatformTransactionManager;
@@ -40,13 +41,16 @@
  *
  * @author Dave Syer
  * @author Andy Wilkinson
+ * @author Kazuki Shimizu
  */
 public class BasicBatchConfigurer implements BatchConfigurer {
 
 	private static final Log logger = LogFactory.getLog(BasicBatchConfigurer.class);
 
 	private final BatchProperties properties;
 
+	private final TransactionProperties transactionProperties;
+
 	private final DataSource dataSource;
 
 	private final EntityManagerFactory entityManagerFactory;
@@ -62,21 +66,24 @@ public class BasicBatchConfigurer implements BatchConfigurer {
 	/**
 	 * Create a new {@link BasicBatchConfigurer} instance.
 	 * @param properties the batch properties
+	 * @param transactionProperties the transaction properties
 	 * @param dataSource the underlying data source
 	 */
-	protected BasicBatchConfigurer(BatchProperties properties, DataSource dataSource) {
-		this(properties, dataSource, null);
+	protected BasicBatchConfigurer(BatchProperties properties, TransactionProperties transactionProperties, DataSource dataSource) {
+		this(properties, transactionProperties, dataSource, null);
 	}
 
 	/**
 	 * Create a new {@link BasicBatchConfigurer} instance.
 	 * @param properties the batch properties
+	 * @param transactionProperties the transaction properties
 	 * @param dataSource the underlying data source
 	 * @param entityManagerFactory the entity manager factory (or {@code null})
 	 */
-	protected BasicBatchConfigurer(BatchProperties properties, DataSource dataSource,
+	protected BasicBatchConfigurer(BatchProperties properties, TransactionProperties transactionProperties, DataSource dataSource,
 			EntityManagerFactory entityManagerFactory) {
 		this.properties = properties;
+		this.transactionProperties = transactionProperties;
 		this.entityManagerFactory = entityManagerFactory;
 		this.dataSource = dataSource;
 	}
@@ -150,10 +157,15 @@ protected JobRepository createJobRepository() throws Exception {
 	}
 
 	protected PlatformTransactionManager createTransactionManager() {
+		PlatformTransactionManager txManager;
 		if (this.entityManagerFactory != null) {
-			return new JpaTransactionManager(this.entityManagerFactory);
+			txManager = new JpaTransactionManager(this.entityManagerFactory);
+		}
+		else {
+			txManager = new DataSourceTransactionManager(this.dataSource);
 		}
-		return new DataSourceTransactionManager(this.dataSource);
+		this.transactionProperties.applyTo(txManager);
+		return txManager;
 	}
 
 }

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/batch/BatchAutoConfiguration.java

@@ -37,11 +37,13 @@
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
+import org.springframework.boot.autoconfigure.transaction.TransactionProperties;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.io.ResourceLoader;
 import org.springframework.jdbc.core.JdbcOperations;
+import org.springframework.transaction.PlatformTransactionManager;
 import org.springframework.util.StringUtils;
 
 /**
@@ -57,6 +59,7 @@
  *
  * @author Dave Syer
  * @author Eddú Meléndez
+ * @author Kazuki Shimizu
  */
 @Configuration
 @ConditionalOnClass({ JobLauncher.class, DataSource.class, JdbcOperations.class })
@@ -133,15 +136,18 @@ public SimpleJobOperator jobOperator(JobExplorer jobExplorer, JobLauncher jobLau
 		return factory;
 	}
 
-	@ConditionalOnClass(name = "javax.persistence.EntityManagerFactory")
+	@EnableConfigurationProperties({BatchProperties.class, TransactionProperties.class})
+	@ConditionalOnClass(value = PlatformTransactionManager.class, name = "javax.persistence.EntityManagerFactory")
 	@ConditionalOnMissingBean(BatchConfigurer.class)
 	@Configuration
 	protected static class JpaBatchConfiguration {
 
 		private final BatchProperties properties;
+		private final TransactionProperties transactionProperties;
 
-		protected JpaBatchConfiguration(BatchProperties properties) {
+		protected JpaBatchConfiguration(BatchProperties properties, TransactionProperties transactionProperties) {
 			this.properties = properties;
+			this.transactionProperties = transactionProperties;
 		}
 
 		// The EntityManagerFactory may not be discoverable by type when this condition
@@ -151,14 +157,14 @@ protected JpaBatchConfiguration(BatchProperties properties) {
 		@ConditionalOnBean(name = "entityManagerFactory")
 		public BasicBatchConfigurer jpaBatchConfigurer(DataSource dataSource,
 				EntityManagerFactory entityManagerFactory) {
-			return new BasicBatchConfigurer(this.properties, dataSource,
+			return new BasicBatchConfigurer(this.properties, this.transactionProperties, dataSource,
 					entityManagerFactory);
 		}
 
 		@Bean
 		@ConditionalOnMissingBean(name = "entityManagerFactory")
 		public BasicBatchConfigurer basicBatchConfigurer(DataSource dataSource) {
-			return new BasicBatchConfigurer(this.properties, dataSource);
+			return new BasicBatchConfigurer(this.properties, this.transactionProperties, dataSource);
 		}
 
 	}

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/data/neo4j/Neo4jDataAutoConfiguration.java

@@ -29,6 +29,7 @@
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
 import org.springframework.boot.autoconfigure.domain.EntityScanPackages;
+import org.springframework.boot.autoconfigure.transaction.TransactionProperties;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.Bean;
@@ -48,12 +49,13 @@
  * @author Josh Long
  * @author Vince Bickers
  * @author Stephane Nicoll
+ * @author Kazuki Shimizu
  * @since 1.4.0
  */
 @Configuration
-@ConditionalOnClass(SessionFactory.class)
+@ConditionalOnClass({SessionFactory.class, PlatformTransactionManager.class})
 @ConditionalOnMissingBean(SessionFactory.class)
-@EnableConfigurationProperties(Neo4jProperties.class)
+@EnableConfigurationProperties({Neo4jProperties.class, TransactionProperties.class})
 @SuppressWarnings("deprecation")
 public class Neo4jDataAutoConfiguration {
 
@@ -87,8 +89,11 @@ public Neo4jTemplate neo4jTemplate(SessionFactory sessionFactory) {
 
 	@Bean
 	@ConditionalOnMissingBean(PlatformTransactionManager.class)
-	public Neo4jTransactionManager transactionManager(SessionFactory sessionFactory) {
-		return new Neo4jTransactionManager(sessionFactory);
+	public Neo4jTransactionManager transactionManager(SessionFactory sessionFactory,
+			TransactionProperties transactionProperties) {
+		Neo4jTransactionManager transactionManager = new Neo4jTransactionManager(sessionFactory);
+		transactionProperties.applyTo(transactionManager);
+		return transactionManager;
 	}
 
 	private String[] getPackagesToScan(ApplicationContext applicationContext) {

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceTransactionManagerAutoConfiguration.java

@@ -23,6 +23,8 @@
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
+import org.springframework.boot.autoconfigure.transaction.TransactionProperties;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.Ordered;
@@ -39,6 +41,7 @@
  * @author Dave Syer
  * @author Stephane Nicoll
  * @author Andy Wilkinson
+ * @author Kazuki Shimizu
  */
 @Configuration
 @ConditionalOnClass({ JdbcTemplate.class, PlatformTransactionManager.class })
@@ -47,6 +50,7 @@ public class DataSourceTransactionManagerAutoConfiguration {
 
 	@Configuration
 	@ConditionalOnSingleCandidate(DataSource.class)
+	@EnableConfigurationProperties(TransactionProperties.class)
 	static class DataSourceTransactionManagerConfiguration {
 
 		private final DataSource dataSource;
@@ -57,8 +61,10 @@ static class DataSourceTransactionManagerConfiguration {
 
 		@Bean
 		@ConditionalOnMissingBean(PlatformTransactionManager.class)
-		public DataSourceTransactionManager transactionManager() {
-			return new DataSourceTransactionManager(this.dataSource);
+		public DataSourceTransactionManager transactionManager(TransactionProperties transactionProperties) {
+			DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(this.dataSource);
+			transactionProperties.applyTo(transactionManager);
+			return transactionManager;
 		}
 
 	}

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/orm/jpa/JpaBaseConfiguration.java

@@ -34,6 +34,7 @@
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
 import org.springframework.boot.autoconfigure.domain.EntityScanPackages;
+import org.springframework.boot.autoconfigure.transaction.TransactionProperties;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
 import org.springframework.context.annotation.Bean;
@@ -59,8 +60,9 @@
  * @author Dave Syer
  * @author Oliver Gierke
  * @author Andy Wilkinson
+ * @author Kazuki Shimizu
  */
-@EnableConfigurationProperties(JpaProperties.class)
+@EnableConfigurationProperties({JpaProperties.class, TransactionProperties.class})
 @Import(DataSourceInitializedPublisher.Registrar.class)
 public abstract class JpaBaseConfiguration implements BeanFactoryAware {
 
@@ -81,8 +83,10 @@ protected JpaBaseConfiguration(DataSource dataSource, JpaProperties properties,
 
 	@Bean
 	@ConditionalOnMissingBean(PlatformTransactionManager.class)
-	public PlatformTransactionManager transactionManager() {
-		return new JpaTransactionManager();
+	public PlatformTransactionManager transactionManager(TransactionProperties transactionProperties) {
+		JpaTransactionManager transactionManager = new JpaTransactionManager();
+		transactionProperties.applyTo(transactionManager);
+		return transactionManager;
 	}
 
 	@Bean

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/transaction/TransactionProperties.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2012-2016 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.boot.autoconfigure.transaction;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.support.AbstractPlatformTransactionManager;
+
+/**
+ * External configuration properties for a {@link org.springframework.transaction.PlatformTransactionManager} created by
+ * Spring. All {@literal spring.transaction.} properties are also applied to the {@code PlatformTransactionManager}.
+ *
+ * @author Kazuki Shimizu
+ * @since 1.5.0
+ */
+@ConfigurationProperties(prefix = "spring.transaction")
+public class TransactionProperties {
+
+	/**
+	 * The default transaction timeout (sec).
+	 */
+	private Integer defaultTimeout;
+
+	/**
+	 * The indicating flag whether perform the rollback processing on commit failure (If perform rollback, set to the true).
+	 */
+	private Boolean rollbackOnCommitFailure;
+
+	public Integer getDefaultTimeout() {
+		return this.defaultTimeout;
+	}
+
+	public void setDefaultTimeout(Integer defaultTimeout) {
+		this.defaultTimeout = defaultTimeout;
+	}
+
+	public Boolean getRollbackOnCommitFailure() {
+		return this.rollbackOnCommitFailure;
+	}
+
+	public void setRollbackOnCommitFailure(Boolean rollbackOnCommitFailure) {
+		this.rollbackOnCommitFailure = rollbackOnCommitFailure;
+	}
+
+	/**
+	 * Apply all transaction custom properties to a specified {@link PlatformTransactionManager} instance.
+	 *
+	 * @param transactionManager the target transaction manager
+	 * @see AbstractPlatformTransactionManager#setDefaultTimeout(int)
+	 * @see AbstractPlatformTransactionManager#setRollbackOnCommitFailure(boolean)
+	 */
+	public void applyTo(PlatformTransactionManager transactionManager) {
+		if (transactionManager instanceof AbstractPlatformTransactionManager) {
+			AbstractPlatformTransactionManager abstractPlatformTransactionManager =
+					(AbstractPlatformTransactionManager) transactionManager;
+			if (this.defaultTimeout != null) {
+				abstractPlatformTransactionManager.setDefaultTimeout(this.defaultTimeout);
+			}
+			if (this.rollbackOnCommitFailure != null) {
+				abstractPlatformTransactionManager.setRollbackOnCommitFailure(this.rollbackOnCommitFailure);
+			}
+		}
+	}
+
+}

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/transaction/jta/AtomikosJtaConfiguration.java

@@ -30,6 +30,7 @@
 import org.springframework.boot.ApplicationHome;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.transaction.TransactionProperties;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.boot.jta.XAConnectionFactoryWrapper;
 import org.springframework.boot.jta.XADataSourceWrapper;
@@ -50,18 +51,21 @@
  * @author Phillip Webb
  * @author Andy Wilkinson
  * @author Stephane Nicoll
+ * @author Kazuki Shimizu
  * @since 1.2.0
  */
 @Configuration
-@EnableConfigurationProperties(AtomikosProperties.class)
+@EnableConfigurationProperties({AtomikosProperties.class, JtaProperties.class, TransactionProperties.class})
 @ConditionalOnClass({ JtaTransactionManager.class, UserTransactionManager.class })
 @ConditionalOnMissingBean(PlatformTransactionManager.class)
 class AtomikosJtaConfiguration {
 
 	private final JtaProperties jtaProperties;
+	private final TransactionProperties transactionProperties;
 
-	AtomikosJtaConfiguration(JtaProperties jtaProperties) {
+	AtomikosJtaConfiguration(JtaProperties jtaProperties, TransactionProperties transactionProperties) {
 		this.jtaProperties = jtaProperties;
+		this.transactionProperties = transactionProperties;
 	}
 
 	@Bean(initMethod = "init", destroyMethod = "shutdownForce")
@@ -111,7 +115,9 @@ public static AtomikosDependsOnBeanFactoryPostProcessor atomikosDependsOnBeanFac
 	@Bean
 	public JtaTransactionManager transactionManager(UserTransaction userTransaction,
 			TransactionManager transactionManager) {
-		return new JtaTransactionManager(userTransaction, transactionManager);
+		JtaTransactionManager jtaTransactionManager = new JtaTransactionManager(userTransaction, transactionManager);
+		this.transactionProperties.applyTo(jtaTransactionManager);
+		return jtaTransactionManager;
 	}
 
 	@Configuration