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 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 as
 @Primary.
 This is even generally preferred since it doesn't lead to early initialization
 of the PlatformTransactionManager 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 as all PlatformTransactionManager implementations take advantage
 of Spring lifecycle callbacks such as InitializingBean and
 BeanFactoryAware.
PlatformTransactionManager or
 ReactiveTransactionManager implementation