Spring Transaction Management abstraction is designed around an interface named PlatformTransactionManager, which you need to configure as a Spring bean in your Spring metadata. PlatformTransactionManager manages the actual transaction instance that performs the transaction operations such as commit and rollback, based on a TransactionDefinition instance that defines the transaction strategy. TransactionDefinition defines the critical transaction attributes such as isolation, propagation, transaction timeout, and the read-only status of a given transaction instance.

Depending on your environment (standalone, web/app server) and the persistence mechanism you use (such as plain JDBC, JPA, and Hibernate), you choose the appropriate implementation of PlatformTransactionManager and configure it as required, in your Spring metadata. Under the hood, using Spring AOP, Spring injects TransactionManager into your proxy DAO (or EntityManager, in the case of JPA) and executes your transactional methods, applying transaction semantics declared in your Spring configuration, either using the @Transactional annotation or the equivalent XML notations. We will discuss the @Transactional annotation and its XML equivalent later on in this chapter.

For applications that operate on a single DataSource object, Spring provides DataSourceTransactionManager. The following shows how to configure it in XML:

<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="taskifyDS" />
</bean>

For multiple DataSource objects or transactional resources, you need a JtaTransactionManager with JTA capabilities, which usually delegates to a container JTA provider. You need to use DataSource objects in Java EE application servers, defined with the server, and looked up via JNDI along with JtaTransactionManager. A typical combination should look like the following code fragment:

<bean id="txManager" class="org.springframework.transaction.jta.JtaTransactionManager" />
</bean>
<jee:jndi-lookup id="taskifyDS" jndi-name="java:jboss/datasources/taskify" expected-type="javax.sql.DataSource/>

If you are using Hibernate and just a single DataSource (and no other transactional resource), then the best option is to use HibernateTransactionManager, which requires you to pass the session factory as a dependency. For JPA, Spring provides JpaTransactionManager, which binds a single JPA EntityManager instance. However, it is advisable to use JtaTransactionManager in application-container environments.

Spring provides specialized transaction managers for application servers for WebLogic and WebSphere in order to leverage full power from container-specific transaction coordinators. Use WebLogicTransactionManager and WebsphereUowTransactionManager in the respective environments.

Separating Transaction semantics out of your business code into an XML file or annotations above the methods is usually called declarative transaction management. Spring Framework allows you to apply transactional behavior into your beans transparently and non-invasively using its declarative transaction management feature.

You can apply Spring Transaction declaratively on any Spring bean, unlike EJB CMT. With Spring Transaction, you can specify transactional advices around your bean methods inside the metadata in an AOP style; then Spring will apply your those advices at runtime using AOP. You can set rollback rules to specify which exceptions around which beans or methods cause automatic rollback or non-rollback.

<!-- transactional advices --> 
<tx:advice id="txAdvice" transaction-manager="transactionManager">
  <!-- the transactional semantics... -->
  <tx:attributes>
    <!-- all methods starting with 'get' are read-only -->
    <tx:method name="find*" read-only="true" />
    <!-- other methods use the default transaction settings (see below) -->
    <tx:method name="*" isolation="DEFAULT" propagation="REQUIRED" />
  </tx:attributes>
</tx:advice>

<!-- Applying the above advices to the service layer methods -->
<aop:config>
  <aop:pointcut id="allServiceMethods"
  expression="execution(* com.taskify.service.*.*(..))" />
  <aop:advisor advice-ref="txAdvice" pointcut- ref="allServiceMethods" />
</aop:config>

<tx:advice id="txAdvice" transaction-manager="transactionManager">
  <tx:attributes>
    ...
    <tx:method name="completeTask" propagation="REQUIRED" rollback-for="NoTaskFoundException"/>
    <tx:method name="findOpenTasksByAssignee" read-only="true" no-rollback-for="InvalidUserException"/>
    <tx:method name="*" isolation="DEFAULT" propagation="REQUIRED" />
  </tx:attributes>
</tx:advice>

The @Transactional annotation describes transactional attributes on a method or class. Class-level annotation applies to all methods unless explicitly annotated at method level. It supports all the attributes you otherwise set at the XML configuration. See the following example:

@Service
@Transactional
public class TaskServiceImpl implements TaskService {
  ...
  public Task createTask(Task task) {
    if (StringUtils.isEmpty(task.getStatus()))
      task.setStatus("Open");
    taskDAO.save(task);
    return task;
  }

  @Transactional(propagation = Propagation.REQUIRED, rollbackFor = NoUserFoundException)
  public Task createTask(String name, int priority, Long createdByuserId, Long assigneeUserId, String comments) {
    Task task = new Task(name, priority, "Open", userService.findById(createdByuserId), null, userService.findById(assigneeUserId), comments);
    taskDAO.save(task);
    logger.info("Task created: " + task);
    return task;
  }

  @Transactional(readOnly = true)
  public Task findTaskById(Long taskId) {
    return taskDAO.findOne(taskId);
  }
  ...
}

In the preceding example, the transactional method createTask with propagation REQUIRED rolls back for NoUserFoundException. Similarly, you can set no-rollback rules at the same level too.

<tx:annotation-driven transaction-manager="transactionManager" />

@Configuration
@EnableTransactionManagement
public class JpaConfiguration {
}

<tx:annotation-driven transaction-manager="transactionManager" mode="aspectj"/>

Spring provides comprehensive support for programmatic transaction management using two components: TransactionTemplate and PlatformTransactionManager. The following code snippet illustrates the usage of TransactionTemplate:

@Service
public class TaskServiceImpl implements TaskService {
  @Autowired
  private TransactionTemplate trxTemplate;
  ...
  public Task createTask(String name, int priority, Long createdByuserId, Long assigneeUserId, String comments) {

    return trxTemplate.execute(new TransactionCallback<Task>() {
      @Override
      public Task doInTransaction(TransactionStatus status) {
        User createdUser = userService.findById(createdByuserId);
        User assignee = userService.findById(assigneeUserId);
        Task task = new Task(name, priority, "Open", createdUser, null, assignee, comments);
        taskDAO.save(task);
        logger.info("Task created: " + task);
        return task;
      }
    });
  }
}

TransactionTemplate supports the setting of all transaction attributes, as in the case of XML configuration, which gives you more granular control at the expense of mixing your business code with transactional concerns. Use it only if you need absolute control over a particular feature that cannot be achieved with declarative transaction management. Use declarative transaction management if possible, for better maintainability and management of your application.