Annotation-Based Transactions in Spring

In this article, I'm going to show you how to use transaction management annotations in Spring. I'm using Spring 2.5 though these features have been available at least since Spring 2.0.

Spring provides several different approaches to transaction management:

• Programmatic: You can write your transactions using Java source code directly. Normally you wouldn't do this unless you needed fine-grained control over some particular transaction.
• Declarative: You can declare transaction definitions in either a centralized way using XML or in a distributed way using annotations:
  • XML-based: You can configure transactions in Spring's centralized application context file. Once again you have options:
    • Proxy-based: In this approach you wrap your service beans with transactional proxies. The proxy and the service bean both implement the same Java interface so the application can't tell them apart. This is a fairly verbose approach with respect to the actual context configuration though there are techniques you can use to streamline the configuration.
    • AOP-based: Here you define AOP aspects to endow your service beans with transactional semantics. Not quite as verbose as the proxy-based approach.
  • Annotation-based: You can use Java 5 annotations to distribute transaction configuration across Java classes.

As the title suggests, this article deals with annotation-based configuration. In my opinion this is the cleanest and most sensible approach: context file configuration is almost nil and the transaction definitions are conveniently located with the service interfaces and/or beans themselves.

Let's start with a basic overview of transactions, and then we'll get to the good stuff.