org.springframework.transaction.annotation Documentation Differences

This file contains all the changes in documentation in the package org.springframework.transaction.annotation as colored differences. Deletions are shown like this, and additions are shown like this.

If no deletions or additions are shown in an entry, the HTML tags will be what has changed. The new HTML tags are shown in the differences. If no documentation existed, and then some was added in a later version, this change is noted in the appropriate class pages of differences, but the change is not shown on this page. Only changes in existing text are shown here. Similarly, documentation which was inherited from another class or interface is not shown here.

Note that an HTML error in the new documentation may cause the display of other documentation changes to be presented incorrectly. For instance, failure to close a <code> tag will cause all subsequent paragraphs to be displayed differently.

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

There are two basic approaches to implementing this method:

1. Implement the method and annotate it with {@code @Bean}

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

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

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

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

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

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

In either scenario #1 or #2, it is important that the {@code PlatformTransactionManager} instance is managed as a Spring bean within the container as all {@code PlatformTransactionManager} implementations take advantage of Spring lifecycle callbacks such as {@code InitializingBean} and {@code BeanFactoryAware}.