org.springframework.transaction.annotation

Interface TransactionManagementConfigurer

public interface TransactionManagementConfigurer

Interface to be implemented by @Configuration classes annotated with @EnableTransactionManagement that wish to (or need to) explicitly specify the default PlatformTransactionManager bean (or ReactiveTransactionManager bean) to be used for annotation-driven transaction management, as opposed to the default approach of a by-type lookup. One reason this might be necessary is if there are two PlatformTransactionManager beans (or two ReactiveTransactionManager beans) present in the container.

See @EnableTransactionManagement for general examples and context; see annotationDrivenTransactionManager() for detailed instructions.

Note that in by-type lookup disambiguation cases, an alternative approach to implementing this interface is to simply mark one of the offending PlatformTransactionManager @Bean methods (or ReactiveTransactionManager @Bean methods) as @Primary. This is even generally preferred since it doesn't lead to early initialization of the TransactionManager bean.

Since:

3.1

Author:

Chris Beams

See Also:

EnableTransactionManagement, Primary, PlatformTransactionManager, ReactiveTransactionManager

Method Summary

Modifier and Type	Method and Description
TransactionManager	annotationDrivenTransactionManager() Return the default transaction manager bean to use for annotation-driven database transaction management, i.e.

Method Detail

annotationDrivenTransactionManager

TransactionManager annotationDrivenTransactionManager()

Return the default transaction manager bean to use for annotation-driven database transaction management, i.e. when processing @Transactional methods.

There are two basic approaches to implementing this method:

1. Implement the method and annotate it with @Bean

In this case, the implementing @Configuration class implements this method, marks it with @Bean, and configures and returns the transaction manager directly within the method body:

 @Bean
 @Override
 public PlatformTransactionManager annotationDrivenTransactionManager() {
     return new DataSourceTransactionManager(dataSource());
 }

2. Implement the method without @Bean and delegate to another existing @Bean method

 @Bean
 public PlatformTransactionManager txManager() {
     return new DataSourceTransactionManager(dataSource());
 }

 @Override
 public PlatformTransactionManager annotationDrivenTransactionManager() {
     return txManager(); // reference the existing @Bean method above
 }

If taking approach #2, be sure that only one of the methods is marked with @Bean!

In either scenario #1 or #2, it is important that the PlatformTransactionManager instance is managed as a Spring bean within the container since most PlatformTransactionManager implementations take advantage of Spring lifecycle callbacks such as InitializingBean and BeanFactoryAware. Note that the same guidelines apply to ReactiveTransactionManager beans.

Returns:

a PlatformTransactionManager or ReactiveTransactionManager implementation