Top Description Methods
org.springframework.transaction.annotation

public Interface TransactionManagementConfigurer

Imports
org.springframework.transaction.TransactionManager
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.

Author
Chris Beams
Since
3.1
See Also
EnableTransactionManagement, org.springframework.context.annotation.Primary, org.springframework.transaction.PlatformTransactionManager, org.springframework.transaction.ReactiveTransactionManager

Method Summary

Modifier and TypeMethod and Description
public TransactionManager

Returns:

a org.springframework.transaction.PlatformTransactionManager or org.springframework.transaction.ReactiveTransactionManager implementation
annotationDrivenTransactionManager()

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

Method Detail

annotationDrivenTransactionManagerback to summary
public 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:TransactionManager

a org.springframework.transaction.PlatformTransactionManager or org.springframework.transaction.ReactiveTransactionManager implementation