public interface TransactionManagementConfigurer
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.
EnableTransactionManagement,
Primary,
PlatformTransactionManager,
ReactiveTransactionManager| Modifier and Type | Method and Description |
|---|---|
TransactionManager |
annotationDrivenTransactionManager()
Return the default transaction manager bean to use for annotation-driven database
transaction management, i.e.
|
TransactionManager annotationDrivenTransactionManager()
@Transactional methods.
There are two basic approaches to implementing this method:
@Bean@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());
}
@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.
PlatformTransactionManager or
ReactiveTransactionManager implementation