Spring 5 中文解析数据存储篇 - 事务同步和声明式事物管理

// the service interface that we want to make transactional​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 {​    @Override    public Foo getFoo(String fooName) {        // ...    }​    @Override    public Foo getFoo(String fooName, String barName) {        // ...    }​    @Override    public void insertFoo(Foo foo) {        // ...    }​    @Override    public 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        https://www.springframework.org/schema/beans/spring-beans.xsd        http://www.springframework.org/schema/tx        https://www.springframework.org/schema/tx/spring-tx.xsd        http://www.springframework.org/schema/aop        https://www.springframework.org/schema/aop/spring-aop.xsd">​    <!-- 该bean具有事物 -->    <bean id="fooService" class="x.y.service.DefaultFooService"/>​    <!-- 事物通知 -->    <tx:advice id="txAdvice" transaction-manager="txManager">        <!-- the transactional semantics... -->        <tx:attributes>            <!-- 以‘get’开头的方法具有只读事物设置 -->            <tx:method name="get*" read-only="true"/>            <!-- 其他使用默认事物设置 -->            <tx:method name="*"/>        </tx:attributes>    </tx:advice>​    <!-- 定义事物切面 -->    <aop:config>        <aop:pointcut id="fooServiceOperation" expression="execution(* x.y.service.FooService.*(..))"/>      <!--使用advisor绑定事物通知与切面-->        <aop:advisor advice-ref="txAdvice" pointcut-ref="fooServiceOperation"/>    </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>​    <!-- other <bean/> definitions here -->​</beans>

<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());    }}

<!-- the Spring container is starting up... -->[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 DataSource​Exception 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)

// the reactive service interface that we want to make transactional​package x.y.service;​public interface FooService {​    Flux<Foo> getFoo(String fooName);​    Publisher<Foo> getFoo(String fooName, String barName);​    Mono<Void> insertFoo(Foo foo);​    Mono<Void> updateFoo(Foo foo);​}

package x.y.service;​public class DefaultFooService implements FooService {​    @Override    public Flux<Foo> getFoo(String fooName) {        // ...    }​    @Override    public Publisher<Foo> getFoo(String fooName, String barName) {        // ...    }​    @Override    public Mono<Void> insertFoo(Foo foo) {        // ...    }​    @Override    public Mono<Void> updateFoo(Foo foo) {        // ...    }}

<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        https://www.springframework.org/schema/beans/spring-beans.xsd        http://www.springframework.org/schema/tx        https://www.springframework.org/schema/tx/spring-tx.xsd        http://www.springframework.org/schema/aop        https://www.springframework.org/schema/aop/spring-aop.xsd">​   <!-- 定义切入点和事物通知 -->    <aop:config>​        <aop:pointcut id="serviceOperation"                expression="execution(* x.y.service..*Service.*(..))"/>​        <aop:advisor pointcut-ref="serviceOperation" advice-ref="txAdvice"/>​    </aop:config>​    <!-- 在事物中执行 -->    <bean id="fooService" class="x.y.service.DefaultFooService"/>    <bean id="barService" class="x.y.service.extras.SimpleBarService"/>​    <!-- ... 不在事物中执行 -->    <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 TransactionManager 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        https://www.springframework.org/schema/beans/spring-beans.xsd        http://www.springframework.org/schema/tx        https://www.springframework.org/schema/tx/spring-tx.xsd        http://www.springframework.org/schema/aop        https://www.springframework.org/schema/aop/spring-aop.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 TransactionManager omitted... -->​</beans>

// 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        https://www.springframework.org/schema/beans/spring-beans.xsd        http://www.springframework.org/schema/tx        https://www.springframework.org/schema/tx/spring-tx.xsd        http://www.springframework.org/schema/aop        https://www.springframework.org/schema/aop/spring-aop.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 TransactionManager is still required --> //1​    <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>

// the reactive service class that we want to make transactional@Transactionalpublic class DefaultFooService implements FooService {​    Publisher<Foo> getFoo(String fooName) {        // ...    }​    Mono<Foo> getFoo(String fooName, String barName) {        // ...    }​    Mono<Void> insertFoo(Foo foo) {        // ...    }​    Mono<Void> updateFoo(Foo foo) {        // ...    }}

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

public class TransactionalService {​    @Transactional("order")    public void setSomething(String name) { ... }​    @Transactional("account")    public void doSomething() { ... }​    @Transactional("reactive-account")    public Mono<Void> doSomethingReactive() { ... }}

<tx:annotation-driven/>​    <bean id="transactionManager1" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">        ...        <qualifier value="order"/>    </bean>​    <bean id="transactionManager2" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">        ...        <qualifier value="account"/>    </bean>​    <bean id="transactionManager3" class="org.springframework.data.r2dbc.connectionfactory.R2dbcTransactionManager">        ...        <qualifier value="reactive-account"/>    </bean></tx:annotation-driven>