拿下 Spring 事务

public void accountMoney(){
    int money = 100;
    //小明 少 100
    userDao.reduceMoney(money);
    // 其他业务 发生异常
    int i = 1/0;
    //小红 多 100
    userDao.addMoney(money);
}

public interface PlatformTransactionManager {
// 根据传入的 TransactionDefinition 对象获取一个事务状态对象
   TransactionStatus getTransaction(@Nullable TransactionDefinition var1) throws TransactionException;

// 提交事务
   void commit(TransactionStatus var1) throws TransactionException;
// 回滚事务
   void rollback(TransactionStatus var1) throws TransactionException;
}

public interface TransactionDefinition {

    int PROPAGATION_REQUIRED = 0;
    int PROPAGATION_SUPPORTS = 1;
    int PROPAGATION_MANDATORY = 2;
    int PROPAGATION_REQUIRES_NEW = 3;
    int PROPAGATION_NOT_SUPPORTED = 4;
    int PROPAGATION_NEVER = 5;
    int PROPAGATION_NESTED = 6;

    int ISOLATION_DEFAULT = -1;
    int ISOLATION_READ_UNCOMMITTED = 1;
    int ISOLATION_READ_COMMITTED = 2;
    int ISOLATION_REPEATABLE_READ = 4;
    int ISOLATION_SERIALIZABLE = 8;

    int TIMEOUT_DEFAULT = -1;

    default int getPropagationBehavior(){
        return 0;
    }

    default int getIsolationLevel(){
        return -1;
    }

    default int getTimeout(){
        return -1;
    }

    default boolean isReadOnly(){
        return false;
    }

    @Nullable
    default String getName(){
        return null;
    }

    static TransactionDefinition withDefaults(){
        return StaticTransactionDefinition.INSTANCE;
    }
}

public interface TransactionStatus extends TransactionExecution, SavepointManager, Flushable {

    boolean hasSavepoint();

    @Override
    void flush();

}

public interface TransactionExecution {

   boolean isNewTransaction();

   void setRollbackOnly();

   boolean isRollbackOnly();

   boolean isCompleted();

}

public interface SavepointManager {

    Object createSavepoint() throws TransactionException;

    void rollbackToSavepoint(Object savepoint) throws TransactionException;

    void releaseSavepoint(Object savepoint) throws TransactionException;

}

public class DefaultTransactionStatus extends AbstractTransactionStatus {

    // 具体事务对象
    @Nullable
    private final Object transaction;

    //是否是新开启的事务（=true时才会提交事务）
    private final boolean newTransaction;

// 是否是新建的同步器（=true时才会执行回调事件）
    private final boolean newSynchronization;

// 是否只读
    private final boolean readOnly;
// 是否已调试
    private final boolean debug;

// 挂起的资源信息（事务传播行为要求挂起当前事务时，挂起的事务暂存信息，执行完后用于恢复）
    @Nullable
    private final Object suspendedResources;

    //省略。。。。
}

public enum Propagation {
    REQUIRED(0),
    SUPPORTS(1),
    MANDATORY(2),
    REQUIRES_NEW(3),
    NOT_SUPPORTED(4),
    NEVER(5),
    NESTED(6);
}

    org.springframework
    spring-context
    5.0.8.RELEASE



    org.springframework
    spring-tx
    5.0.8.RELEASE



    org.aspectj
    aspectjrt
    1.9.6



    org.aspectj
    aspectjweaver
    1.9.6

CREATE TABLE `tx_test` (
  `id` int(11) NOT NULL,
  `name` varchar(64) DEFAULT NULL,
  `money` decimal(10,0) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

INSERT INTO `test`.`tx_test`(`id`, `name`, `money`) VALUES (1, '张三', 1000);
INSERT INTO `test`.`tx_test`(`id`, `name`, `money`) VALUES (2, '李四', 1000);

@Repository
public class TXDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 给张三增加金额
     */
    public void add(){
        String sql = "update `tx_test`  set money = money + 100 where id = 1;";
        jdbcTemplate.update(sql);
    }

    /**
     * 给李四减金额
     */
    public void reduce(){
        String sql = "update `tx_test`  set money = money - 100 where id = 2;";
        jdbcTemplate.update(sql);
    }
}

public class TxTest {

    private Integer id;

    private String name;

    private BigDecimal money;

    public Integer getId(){
        return id;
    }

    public void setId(Integer id){
        this.id = id;
    }

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name = name;
    }

    public BigDecimal getMoney(){
        return money;
    }

    public void setMoney(BigDecimal money){
        this.money = money;
    }
}

@Service
public class TXServiceImpl {

    @Autowired
    private TXDao tx;

    public void transfer(){
        tx.add();
        int i = 1/0;
        tx.reduce();
    }
}

public static void main(String[] args){
    ApplicationContext context = new ClassPathXmlApplicationContext("tx.xml");
    TXServiceImpl bean = context.getBean(TXServiceImpl.class);
    bean.transfer();
}

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at cn.cxyxj.txannon.service.TestServiceImpl.transfer(TestServiceImpl.java:20)
    at cn.cxyxj.txannon.AppMain.main(AppMain.java:20)

       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" 
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd 
       http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context.xsd">

    
    

    
    
        
        
        
        
        
        
        
        
    

    
    
        
        
    

    
              class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        
    

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://192.168.50.172/tx_test?useSSL=false
jdbc.username=Yj19980402
jdbc.password=root

@ComponentScan(basePackages = "com.cxyxj.txannon")
@EnableTransactionManagement //开启事务
public class AppMain {

}

@Configuration
@PropertySource("jdbc.properties")
public class TxConfig {

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;

    @Value("${jdbc.driver}")
    private String driverClassName;

    //创建数据库连接池
    @Bean
    public DriverManagerDataSource getDruidDataSource(){
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }

    //创建 JdbcTemplate 对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        //到 ioc 容器中根据类型找到 dataSource
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入 dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    //创建事务管理器
    @Bean
    public DataSourceTransactionManager
    getDataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new
                DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }

}

@Service
public class TXServiceImpl {

    @Autowired
    private TXDao tx;

    @Transactional
    public void transfer(){
        tx.add();
        int i = 1/0;
        tx.reduce();
    }
}

public @interface Transactional {

    @AliasFor("transactionManager")
    String value() default "";

    @AliasFor("value")
    String transactionManager() default "";

    Propagation propagation() default Propagation.REQUIRED;

    Isolation isolation() default Isolation.DEFAULT;

    int timeout() default -1;

    boolean readOnly() default false;

    Class[] rollbackFor() default {};

    String[] rollbackForClassName() default {};

    Class[] noRollbackFor() default {};

    String[] noRollbackForClassName() default {};
}

 transfer 方法进行的操作会回滚，reduce 方法的操作不会回滚。

 两个方法的操作都会回滚。这是由于 reduce 方法的异常会向 transfer 方法传递。

No existing transaction found for transaction marked with propagation 'mandatory'

Existing transaction found for transaction marked with propagation 'never'