注意

尽管使用Spring声明式事务管理不需要AOP（尤其是Spring AOP）的知识，但了解这些是很有帮助的。你可以在 使用Spring进行面向切面编程（AOP） 章找到关于Spring AOP的全部内容。

// 我们想做成事务性的服务接口package x.y.service;public interface FooService {  Foo getFoo(String fooName);  Foo getFoo(String fooName, String barName);  void insertFoo(Foo foo);  void updateFoo(Foo foo);}

// 上述接口的一个实现package x.y.service;public class DefaultFooService implements FooService {  public Foo getFoo(String fooName) {    throw new UnsupportedOperationException();  }  public Foo getFoo(String fooName, String barName) {    throw new UnsupportedOperationException();  }  public void insertFoo(Foo foo) {    throw new UnsupportedOperationException();  }  public void updateFoo(Foo foo) {    throw new UnsupportedOperationException();  }}

<!-- from the file ‘context.xml‘ --><?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xmlns:aop="http://www.springframework.org/schema/aop"     xmlns:tx="http://www.springframework.org/schema/tx"     xsi:schemaLocation="     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">    <!-- this is the service object that we want to make transactional -->  <bean id="fooService" class="x.y.service.DefaultFooService"/>  <!-- the transactional advice (what ‘happens‘; see the <aop:advisor/> bean below) -->  <tx:advice id="txAdvice" transaction-manager="txManager">  <!-- the transactional semantics... -->  <tx:attributes>    <!-- all methods starting with ‘get‘ are read-only -->    <tx:method name="get*" read-only="true"/>    <!-- other methods use the default transaction settings (see below) -->    <tx:method name="*"/>  </tx:attributes>  </tx:advice>    <!-- ensure that the above transactional advice runs for any execution    of an operation defined by the FooService interface -->  <aop:config>  <aop:pointcut id="fooServiceOperation" expression="execution(* x.y.service.FooService.*(..))"/>  <aop:advisor advice-ref="txAdvice" pointcut-ref="fooServiceOperation"/>  </aop:config>    <!-- don‘t forget the DataSource -->  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>  <property name="url" value="jdbc:oracle:thin:@rj-t42:1521:elvis"/>  <property name="username" value="scott"/>  <property name="password" value="tiger"/>  </bean>  <!-- similarly, don‘t forget the PlatformTransactionManager -->  <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  <property name="dataSource" ref="dataSource"/>  </bean>    <!-- other <bean/> definitions here --></beans>

提示

事实上，如果 PlatformTransactionManager bean的名字是 ‘transactionManager‘ 的话，你的事务通知（<tx:advice/>）中的 ‘transaction-manager‘ 属性可以忽略。否则你则需要像上例那样明确指定。

<aop:config>  <aop:pointcut id="fooServiceMethods" expression="execution(* x.y.service.*.*(..))"/>  <aop:advisor advice-ref="txAdvice" pointcut-ref="fooServiceMethods"/></aop:config>

public final class Boot {  public static void main(final String[] args) throws Exception {    ApplicationContext ctx = new ClassPathXmlApplicationContext("context.xml", Boot.class);    FooService fooService = (FooService) ctx.getBean("fooService");    fooService.insertFoo (new Foo());  }}

<!-- Spring容器开始启动... -->				[AspectJInvocationContextExposingAdvisorAutoProxyCreator] - Creating implicit proxy        for bean ‘fooService‘ with 0 common interceptors and 1 specific interceptors    <!-- the DefaultFooService is actually proxied -->    [JdkDynamicAopProxy] - Creating JDK dynamic proxy for [x.y.service.DefaultFooService]    <!-- ... the insertFoo(..) method is now being invoked on the proxy -->    [TransactionInterceptor] - Getting transaction for x.y.service.FooService.insertFoo    <!-- the transactional advice kicks in here... -->    [DataSourceTransactionManager] - Creating new transaction with name [x.y.service.FooService.insertFoo][DataSourceTransactionManager] - Acquired Connection        [org.apache.commons.dbcp.PoolableConnection@a53de4] for JDBC transaction    <!-- the insertFoo(..) method from DefaultFooService throws an exception... -->    [RuleBasedTransactionAttribute] - Applying rules to determine whether transaction should        rollback on java.lang.UnsupportedOperationException[TransactionInterceptor] - Invoking rollback for transaction on x.y.service.FooService.insertFoo        due to throwable [java.lang.UnsupportedOperationException]   <!-- and the transaction is rolled back (by default, RuntimeException instances cause rollback) -->   [DataSourceTransactionManager] - Rolling back JDBC transaction on Connection        [org.apache.commons.dbcp.PoolableConnection@a53de4][DataSourceTransactionManager] - Releasing JDBC Connection after transaction[DataSourceUtils] - Returning JDBC Connection to DataSourceException in thread "main" java.lang.UnsupportedOperationException	at x.y.service.DefaultFooService.insertFoo(DefaultFooService.java:14)   <!-- AOP infrastructure stack trace elements removed for clarity -->   	at $Proxy0.insertFoo(Unknown Source)	at Boot.main(Boot.java:11)

三、回滚

<tx:advice id="txAdvice" transaction-manager="txManager">  <tx:attributes>  <tx:method name="get*" read-only="true" rollback-for="NoProductInStockException"/>  <tx:method name="*"/>  </tx:attributes></tx:advice>

<tx:advice id="txAdvice">  <tx:attributes>  <tx:method name="updateStock" no-rollback-for="InstrumentNotFoundException"/>  <tx:method name="*"/>  </tx:attributes></tx:advice>

<tx:advice id="txAdvice">  <tx:attributes>  <tx:method name="*" rollback-for="Throwable" no-rollback-for="InstrumentNotFoundException"/>  </tx:attributes></tx:advice>

public void resolvePosition() {  try {    // some business logic...  } catch (NoProductInStockException ex) {    // trigger rollback programmatically    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();  }}

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xmlns:aop="http://www.springframework.org/schema/aop"  xmlns:tx="http://www.springframework.org/schema/tx"  xsi:schemaLocation="  http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">  <aop:config>    <aop:pointcut id="serviceOperation"          expression="execution(* x.y.service..*Service.*(..))"/>    <aop:advisor pointcut-ref="serviceOperation" advice-ref="txAdvice"/>  </aop:config>  <!-- these two beans will be transactional... -->  <bean id="fooService" class="x.y.service.DefaultFooService"/>  <bean id="barService" class="x.y.service.extras.SimpleBarService"/>  <!-- ... and these two beans won‘t -->  <bean id="anotherService" class="org.xyz.SomeService"/> <!-- (not in the right package) -->  <bean id="barManager" class="x.y.service.SimpleBarManager"/> <!-- (doesn‘t end in ‘Service‘) -->  <tx:advice id="txAdvice">    <tx:attributes>      <tx:method name="get*" read-only="true"/>      <tx:method name="*"/>    </tx:attributes>  </tx:advice>  <!-- other transaction infrastructure beans such as a PlatformTransactionManager omitted... --></beans>

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xmlns:aop="http://www.springframework.org/schema/aop"  xmlns:tx="http://www.springframework.org/schema/tx"  xsi:schemaLocation="  http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">  <aop:config>    <aop:pointcut id="defaultServiceOperation"          expression="execution(* x.y.service.*Service.*(..))"/>    <aop:pointcut id="noTxServiceOperation"          expression="execution(* x.y.service.ddl.DefaultDdlManager.*(..))"/>    <aop:advisor pointcut-ref="defaultServiceOperation" advice-ref="defaultTxAdvice"/>    <aop:advisor pointcut-ref="noTxServiceOperation" advice-ref="noTxAdvice"/>  </aop:config>  <!-- this bean will be transactional (see the ‘defaultServiceOperation‘ pointcut) -->  <bean id="fooService" class="x.y.service.DefaultFooService"/>  <!-- this bean will also be transactional, but with totally different transactional settings -->  <bean id="anotherFooService" class="x.y.service.ddl.DefaultDdlManager"/>  <tx:advice id="defaultTxAdvice">    <tx:attributes>      <tx:method name="get*" read-only="true"/>      <tx:method name="*"/>    </tx:attributes>  </tx:advice>  <tx:advice id="noTxAdvice">    <tx:attributes>      <tx:method name="*" propagation="NEVER"/>    </tx:attributes>  </tx:advice>  <!-- other transaction infrastructure beans such as a PlatformTransactionManager omitted... --></beans>

• 事务传播设置 是 REQUIRED

• 隔离级别是DEFAULT

• 事务是 读/写

• 事务超时默认是依赖于事务系统的，或者事务超时没有被支持。

• 任何 RuntimeException 将触发事务回滚，但是任何 checked Exception 将不触发事务回滚

注意

@Transactional 注解及其支持类所提供的功能最低要求使用Java 5（Tiger）。

// the service class that we want to make transactional@Transactionalpublic class DefaultFooService implements FooService {  Foo getFoo(String fooName);  Foo getFoo(String fooName, String barName);  void insertFoo(Foo foo);  void updateFoo(Foo foo);}

<!-- from the file ‘context.xml‘ --><?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xmlns:aop="http://www.springframework.org/schema/aop"     xmlns:tx="http://www.springframework.org/schema/tx"     xsi:schemaLocation="     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">    <!-- this is the service object that we want to make transactional -->  <bean id="fooService" class="x.y.service.DefaultFooService"/>  <!-- enable the configuration of transactional behavior based on annotations -->  <tx:annotation-driven transaction-manager="txManager"/>  <!-- a PlatformTransactionManager is still required -->  <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  <!-- (this dependency is defined somewhere else) -->  <property name="dataSource" ref="dataSource"/>  </bean>    <!-- other <bean/> definitions here --></beans>

提示

实际上，如果你用 ‘transactionManager‘ 来定义 PlatformTransactionManager bean的名字的话，你就可以忽略 <tx:annotation-driven/> 标签里的 ‘transaction-manager‘ 属性。 如果 PlatformTransactionManager bean你要通过其它名称来注入的话，你必须用 ‘transaction-manager‘ 属性来指定它，如上所示。

方法的可见度和 @Transactional

在使用代理的时候，@Transactional 注解应该只被应用到 public 可见度的方法上。 如果你在 protected、private 或者 package-visible 的方法上使用 @Transactional 注解，系统也不会报错， 但是这个被注解的方法将不会执行已配置的事务设置。如果你非要注解非公共方法的话，请参考使用AspectJ (参见下面)。

表 9.2. <tx:annotation-driven/> 设置

注意

在<tx:annotation-driven/>元素上的"proxy-target-class" 属性 控制了有什么类型的事务性代理会为使用@Transactional 来注解的类创建代理。 如果"proxy-target-class" 属性被设为"true"，那么基于类的代理就会被创建。 如果"proxy-target-class" 属性被设为"false" 或者没设，那么会创建基于接口的标准JDK代理。（关于不同代理类型的解释请参见 第 6.6 节 “代理机制”)

@Transactional(readOnly = true)public class DefaultFooService implements FooService {  public Foo getFoo(String fooName) {    // do something  }    // these settings have precedence for this method    @Transactional(readOnly = false, propagation = Propagation.REQUIRES_NEW)    public void updateFoo(Foo foo) {        // do something            }}

@Transactional 注解是用来指定接口、类或方法必须拥有事务语义的元数据。 如：“当一个方法开始调用时就开启一个新的只读事务，并停止掉任何现存的事务”。 默认的 @Transactional 设置如下：

这些默认的设置当然也是可以被改变的。 @Transactional 注解的各种属性设置总结如下：

在写代码的时候，不可能对事务的名字有个很清晰的认识，这里的名字是指会在事务监视器（比如WebLogic的事务管理器）或者日志输出中显示的名字， 对于声明式的事务设置，事务名字总是全限定名+"."+事务通知的类的方法名。比如BusinessService类的handlePayment(..)方法启动了一个事务，事务的名称是：

com.foo.BusinessService.handlePayment

当事务传播被设置PROPAGATION_REQUIRED的时候， 会为每一个被应用到的方法创建一个逻辑事务作用域。 每一个这样的逻辑事务作用域都可以自主地决定rollback-only状态，当这样的逻辑事务作用域被外部的一个逻辑事务作用域所包含的时候， 他们在逻辑上是独立的。当然了，对于正常的 PROPAGATION_REQUIRED设置来说，他会被映射到相同的物理事务上。 所以一个标记有rollback-only的内部逻辑事务作用域的确会影响到外部的逻辑事务作用域（就像你所预料的那样）。

然而，当内部的事务作用域标记为rollback-only，同时外部的事务作用域并没有决定要回滚， 这样的回滚是意料不到的（静悄悄地由内部事务作用域触发的）： 一个对应的UnexpectedRollbackException 异常会在这个时候被抛出。这是 可以预料到的行为， 只有这样，这个事务的调用者才不会被误导，在事务没有提交的情况下误以为事务已经提交。所以如果内部的事务（外部的调用者并不知情）标记该事务为 rollback-only，而外部的调用者却依旧在不知情的情况下提交后，它需要收到一个 UnexpectedRollbackException 异常来清楚的了解事务并没有提交而是发生了回滚。

PROPAGATION_REQUIRES_NEW，与之前相反，为每一个相关的事务作用域使用了一个完全 独立的事务。在这种情况下，物理事务也将是不同的，因此外部事务可以不受内部事务回滚状态的影响独立提交或者回滚。

PROPAGATION_NESTED 是一个完全不同的设置。它使用了一个单独的物理事务， 这个事务拥有多个可以回滚的保存点。这样部分回滚允许内部事务在它的作用域内触发一个回滚， 并且外部事务能够不受影响的继续。 这通常是对应于JDBC的保存点，所以只会在 JDBC 资源事务管理上起效 (具体请参见 Spring的DataSourceTransactionManager).

• 配置的剖析切面（profiling aspect）开始启动，

• 然后进入事务通知（根据配置创建一个新事务或加入一个已经存在的事务），

• 然后执行原始对象的方法，

• 然后事务提交（我们假定这里一切正常），

• 最后剖析切面报告整个事务方法执行过程花了多少时间。

注意

这章不会专门讲述AOP的所有细节（除了应用于事务方面的之外）。 请参考 第 6 章 使用Spring进行面向切面编程（AOP） 章节以获得对各种AOP配置及其一般概念的详细叙述。

package x.y;import org.aspectj.lang.ProceedingJoinPoint;import org.springframework.util.StopWatch;import org.springframework.core.Ordered;public class SimpleProfiler implements Ordered {  private int order;  // allows us to control the ordering of advice  public int getOrder() {    return this.order;  }  public void setOrder(int order) {    this.order = order;  }  // this method is the around advice  public Object profile(ProceedingJoinPoint call) throws Throwable {    Object returnValue;    StopWatch clock = new StopWatch(getClass().getName());    try {      clock.start(call.toShortString());      returnValue = call.proceed();    } finally {      clock.stop();      System.out.println(clock.prettyPrint());    }    return returnValue;  }}

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xmlns:aop="http://www.springframework.org/schema/aop"     xmlns:tx="http://www.springframework.org/schema/tx"     xsi:schemaLocation="   http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">  <bean id="fooService" class="x.y.service.DefaultFooService"/>  <!-- this is the aspect -->  <bean id="profiler" class="x.y.SimpleProfiler">    <!-- execute before the transactional advice (hence the lower order number) -->    <property name="order" value="1"/>  </bean>  <tx:annotation-driven transaction-manager="txManager" order="200"/>  <aop:config>    <!-- this advice will execute around the transactional advice -->    <aop:aspect id="profilingAspect" ref="profiler">      <aop:pointcut id="serviceMethodWithReturnValue"              expression="execution(!void x.y..*Service.*(..))"/>      <aop:around method="profile" pointcut-ref="serviceMethodWithReturnValue"/>    </aop:aspect>  </aop:config>  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">    <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>    <property name="url" value="jdbc:oracle:thin:@rj-t42:1521:elvis"/>    <property name="username" value="scott"/>    <property name="password" value="tiger"/>  </bean>  <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">    <property name="dataSource" ref="dataSource"/>  </bean></beans>

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xmlns:aop="http://www.springframework.org/schema/aop"     xmlns:tx="http://www.springframework.org/schema/tx"     xsi:schemaLocation="   http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">  <bean id="fooService" class="x.y.service.DefaultFooService"/>  <!-- the profiling advice -->  <bean id="profiler" class="x.y.SimpleProfiler">    <!-- execute before the transactional advice (hence the lower order number) -->    <property name="order" value="1"/>  </bean>  <aop:config>    <aop:pointcut id="entryPointMethod" expression="execution(* x.y..*Service.*(..))"/>    <!-- will execute after the profiling advice (c.f. the order attribute) -->    <aop:advisor        advice-ref="txAdvice"        pointcut-ref="entryPointMethod"        order="2"/> <!-- order value is higher than the profiling aspect -->    <aop:aspect id="profilingAspect" ref="profiler">      <aop:pointcut id="serviceMethodWithReturnValue"              expression="execution(!void x.y..*Service.*(..))"/>      <aop:around method="profile" pointcut-ref="serviceMethodWithReturnValue"/>    </aop:aspect>  </aop:config>  <tx:advice id="txAdvice" transaction-manager="txManager">    <tx:attributes>      <tx:method name="get*" read-only="true"/>      <tx:method name="*"/>    </tx:attributes>  </tx:advice>  <!-- other <bean/> definitions such as a DataSource and a PlatformTransactionManager here --></beans>

注意

在我们继续之前，你可能需要好好读一下前面的第 9.5.6 节 “使用 @Transactional” 和 第 6 章 使用Spring进行面向切面编程（AOP） 两章。

// construct an appropriate transaction manager DataSourceTransactionManager txManager = new DataSourceTransactionManager(getDataSource());// configure the AnnotationTransactionAspect to use it; this must be done before executing any transactional methodsAnnotationTransactionAspect.aspectOf().setTransactionManager(txManager); 

注意

使用此切面（aspect），你必须在 实现 类（和/或类里的方法）、而 不是 类的任何所实现的接口上面进行注解。AspectJ遵循Java的接口上的注解 不被继承 的规则。