基于可靠消息方案的分布式事务（二）：Java中的事务

 1public static void main(String[] args) {
 2        Connection con = null;
 3        try {
 4            con = DBConnection.getConnection();
 5            con.setAutoCommit(false);
 6            insertAccountData(con, 1, "Pankaj");
 7            insertAddressData(con, 1, "Albany Dr", "San Jose", "USA");
 8        }
 9        catch (SQLException | ClassNotFoundException e) {
10            e.printStackTrace();
11            try {
12                con.rollback();
13                System.out.println("JDBC Transaction rolled back successfully");
14            }
15            catch (SQLException e1) {
16                System.out.println("SQLException in rollback" + e.getMessage());
17            }
18        }
19        finally {
20            try {
21                if (con != null)
22                    con.close();
23            }
24            catch (SQLException e) {
25                e.printStackTrace();
26            }
27        }
28    }

1public interface PlatformTransactionManager {
2    TransactionStatus getTransaction(TransactionDefinition var1) throws TransactionException;
3
4    void commit(TransactionStatus var1) throws TransactionException;
5
6    void rollback(TransactionStatus var1) throws TransactionException;
7}

 1@Target({ElementType.METHOD, ElementType.TYPE})
 2@Retention(RetentionPolicy.RUNTIME)
 3@Inherited
 4@Documented
 5public @interface Transactional {
 6    @AliasFor("transactionManager")
 7    String value() default "";
 8
 9    @AliasFor("value")
10    String transactionManager() default "";
11    // 定义事务的传播规则
12    Propagation propagation() default Propagation.REQUIRED;
13    // 指定事务的隔离级别
14    Isolation isolation() default Isolation.DEFAULT;
15    // 对于长时间运行的事务定义超时时间
16    int timeout() default -1;
17    // 指定事务为只读
18    boolean readOnly() default false;
19    // rollback-for指定事务对哪些检查型异常应当回滚而不提交
20    Class<? extends Throwable>[] rollbackFor() default {};
21    // 导致事务回滚的异常类名字数组
22    String[] rollbackForClassName() default {};
23    // no-rollback-for指定事务对哪些异常应当继续执行而不回滚
24    Class<? extends Throwable>[] noRollbackFor() default {};
25    // 不会导致事务回滚的异常类名字数组
26    String[] noRollbackForClassName() default {};
27}

1 <!-- 配置事务管理器 -->  
2    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
3        <property name="dataSource" ref="dataSource" />  
4    </bean>  

 1        @Bean
 2        @ConditionalOnMissingBean(PlatformTransactionManager.class)
 3        public DataSourceTransactionManager transactionManager(
 4                DataSourceProperties properties) {
 5            DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(
 6                    this.dataSource);
 7            if (this.transactionManagerCustomizers != null) {
 8                this.transactionManagerCustomizers.customize(transactionManager);
 9            }
10            return transactionManager;
11        }

1    <!--配置事务管理的模板-->
2    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
3        <property name="transactionManager" ref="transactionManager"></property>
4        <!--定义事务隔离级别,-1表示使用数据库默认级别-->
5        <property name="isolationLevelName" value="ISOLATION_DEFAULT"></property>
6        <property name="propagationBehaviorName" value="PROPAGATION_REQUIRED"></property>
7    </bean>

 1    //BaseSeviceImpl.java
 2    @Override
 3    public void insert(String sql, boolean flag) throws Exception {
 4        dao.insertSql(sql);
 5        // 如果flag 为 true ，抛出异常
 6        if (flag) {
 7            throw new Exception("has exception!!!");
 8        }
 9    }
10    //获取总金额
11    @Override
12    public Integer sum() {
13        return dao.sum();
14    }

 1@RunWith(SpringJUnit4ClassRunner.class)
 2@ContextConfiguration(locations = {"classpath:spring-test.xml"})
 3public class TransactionTest{
 4    @Resource
 5    private TransactionTemplate transactionTemplate;
 6    @Autowired
 7    private BaseSevice baseSevice;
 8
 9    @Test
10    public void transTest() {
11        System.out.println("before transaction");
12        Integer sum1 = baseSevice.sum();
13        System.out.println("before transaction sum: "+sum1);
14        System.out.println("transaction....");
15        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
16            @Override
17            protected void doInTransactionWithoutResult(TransactionStatus status) {
18                try {
19                    baseSevice.insert("INSERT INTO account VALUES (100);",false);
20                    baseSevice.insert("INSERT INTO account VALUES (100);",false);
21                } catch (Exception e) {
22                    status.setRollbackOnly();
23                    e.printStackTrace();
24                }
25           }
26        });
27        System.out.println("after transaction");
28        Integer sum2 = baseSevice.sum();
29        System.out.println("after transaction sum: "+sum2);
30    }
31}

 1<tx:advice id="advice" transaction-manager="transactionManager">
 2        <tx:attributes>
 3            <tx:method name="insert" propagation="REQUIRED" read-only="false"  rollback-for="Exception"/>
 4        </tx:attributes>
 5    </tx:advice>
 6
 7    <aop:config>
 8        <aop:pointcut id="pointCut" expression="execution (* com.blueskykong.service.*.*(..))"/>
 9        <aop:advisor advice-ref="advice" pointcut-ref="pointCut"/>
10    </aop:config>

 1    @Test
 2    public void transTest() {
 3        System.out.println("before transaction");
 4        Integer sum1 = baseSevice.sum();
 5        System.out.println("before transaction sum: "+sum1);
 6        System.out.println("transaction....");
 7        try{
 8            baseSevice.insert("INSERT INTO account VALUES (100);",true);
 9        } catch (Exception e){
10            e.printStackTrace();
11        }
12        System.out.println("after transaction");
13        Integer sum2 = baseSevice.sum();
14        System.out.println("after transaction sum: "+sum2);
15    }

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

1    @Transactional(rollbackFor=Exception.class)
2    public void insert(String sql, boolean flag) throws Exception {
3        dao.insertSql(sql);
4        // 如果flag 为 true ，抛出异常
5        if (flag){
6            throw new Exception("has exception!!!");
7        }
8    }