Package 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: A `TransactionManagementConfigurer` will get initialized early. Do not inject common dependencies into autowired fields directly; instead, consider declaring a lazy `ObjectProvider` for those.

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
Description
`TransactionManager`
`annotationDrivenTransactionManager()`
Return the default transaction manager bean to use for annotation-driven database transaction management, i.e.

## Method Details

### 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