mysql 事务

1，Mysql事务基础

1）MySQL默认是autocommit自动提交模式。除非显式地开始一个事务,否则每个查询都被当做一个单独的事务自动执行。
set autocommit=0 禁止自动提交。所有的SQL都将做为一个事务处理，直到commit | rollback。

image.png

2）查看事务的隔离级别：select @@tx_isolation;或show variables like "%tx%";
设置事务的隔离级别：set session/global transaction isolation level ${level}
3）一个事务的流程
开启事务：begin / begin work / start transaction
业务逻辑：select xxx -> insert xxx -> update xxx
提交事务：commit / commit work
4）ACID特性
Atomic： 原子性事务作为一个整体，要么全部执行，要么全不执行
Consistency：一致性A账户减100元，B账户加100元
Isolation：隔离性多个事务并发执行，一个事务的执行不应该影响其他事务的执行。(事务间的锁等待，也不影响另一个事务内的操作)
Durability：持久性commit的事务，更改会永久保存到数据库

2，Spring编程式事务

1）编程式事务，通过编码的方式(类似jdbc编程)实现事务管理。Spring框架提供一致的事务抽象, 对于JDBC还是JTA事务都是采用相同的API进行编程。(jta是多库的事务 jdbc是单库的事务)
2）Spring中采用面向PlatformTransactionManager接口编程来控制事务。

@Bean
public PlatformTransactionManager transactionManager(){
  DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
  transactionManager.setDataSource(dynamicDataSource());
  return transactionManager;
  }

//create table mytable(id bigint(20) NOT NULL auto_increment PRIMARY KEY, name varchar(100));
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = {AppConfig.class, WebConfig.class, ShiroConfig.class})//如果需要启动参数，要在IDE中加上-D参数。
public class SpringTest{

    private static final Logger logger = LoggerFactory.getLogger(SpringTest.class);

    @Autowired
    private PlatformTransactionManager txManager;

    @Autowired
    private DynamicDataSource dynamicDataSource;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    private static final String INSERT_SQL = "insert into mytable(name) values(?)";

    /**
     * 普通编程式管理事务
     */
    @Test
    public void testPlatformTransactionManagerForLowLevel() {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        TransactionStatus status = txManager.getTransaction(def);
        Connection conn = DataSourceUtils.getConnection(dynamicDataSource);
        try {
//          PreparedStatement pstmt = conn.prepareStatement(INSERT_SQL);
//          pstmt.setString(1, "test");
//          pstmt.execute();
            jdbcTemplate.update(INSERT_SQL, "test1");
            jdbcTemplate.update(INSERT_SQL, "test2");// 这里如果出现异常，会进行事务回滚
            txManager.commit(status);
        } catch (Exception e) {
            logger.info(e.getMessage(), e);
            status.setRollbackOnly();
            txManager.rollback(status);
        } finally {
            DataSourceUtils.releaseConnection(conn, dynamicDataSource);
        }
    }

    /**
     * 使用模板，编程式管理事务
     */
    @Test
    public void testTransactionTemplate(){
        TransactionTemplate transactionTemplate = new TransactionTemplate(txManager);
        transactionTemplate.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
        transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                jdbcTemplate.update(INSERT_SQL, "test1");
                jdbcTemplate.update(INSERT_SQL, "test2", "222222");// 这里如果出现异常，会进行事务回滚
            }
        });
    }

}

3，Spring声明式事务

1）基于 AOP,将具体业务逻辑与事务处理(开启，提交，回滚等)解耦。
利用AOP的环绕通知，before开始事务--->业务逻辑-->after提交或者回滚事务。
2）基于@Transactional注解，管理事务。
首先配置相关的bean，然后将@Transactional加到方法或者类上即可。
xml配置

        

或者使用hibernate

        

javaconfig配置

//@EnableTransactionManagement
@Bean
public PlatformTransactionManager transactionManager(){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dynamicDataSource());
        return transactionManager;
}
@Bean
public JdbcTemplate jdbcTemplate(){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dynamicDataSource());

        return jdbcTemplate;
}

4，@Transaction注解

1）相关属性

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
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 TransactionDefinition.TIMEOUT_DEFAULT;//事务的超时时间，默认-1，超时则回滚
    boolean readOnly() default false;//只读事务，不能更新，读取会优化
    Class[] rollbackFor() default {};
    String[] rollbackForClassName() default {};
    Class[] noRollbackFor() default {};
    String[] noRollbackForClassName() default {};
}

2）@Transactional 注解放在类上，该类的公共方法都配置相同的事务属性信息。
方法级别的@Transactional，会覆盖类级别的事务配置。
在 Spring 的 AOP下，只有目标方法由外部调用，才能由Spring 生成的代理对象来管理。

@Service
public class OrderService {
   private void insert() {
     insertOrder();//insert方法没有开启事务，调用insertOrder，发生异常不会回滚。
   }
  @Transactional
  public void insertOrder() {
     //insert log info
     //insertOrder
     //updateAccount
   }
}

3）正确的设置@Transactional 的 propagation 传播行为
Propagation.REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED)默认值，当前有事务则加入；无事务，则创建新的事务。
Propagation.REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW)创建新的事务，当前存在事务则挂起
Propagation.SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS)当前有事务则加入；无事务则不启动
Propagation.NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED)非事务方式执行，当前有事务则挂起
Propagation.NEVER(TransactionDefinition.PROPAGATION_NEVER)非事务方式执行，当前有事务抛异常

5，注解示例。

1）只读标志与 REQUIRED 传播模式结合使用 — JDBC

@Transactional(readOnly = true, propagation=Propagation.REQUIRED)
public long insertTrade(TradeData trade) throws Exception {
   //JDBC code...只读模式下，jdbc会抛出一个只读连接异常。
}

2）只读标志与 REQUIRED 传播模式结合使用 — JPA

@Transactional(readOnly = true, propagation=Propagation.REQUIRED)
public long insertTrade(TradeData trade) throws Exception {
   em.persist(trade);//基于 ORM 的框架，readOnly也会正确插入数据。
   return trade.getTradeId();
}

3）propagation默认是required的传播行为。(事务会在不必要的情况下启动，启动和停止事务将消耗不必要的处理时间和资源)

@Transactional(readOnly = true)
public TradeData getTrade(long tradeId) throws Exception {
   return em.find(TradeData.class, tradeId);//会启动一个事务，并提交。
}

4）正确使用readOnly，将传播行为设置成SUPPORTS，就不会启动事务。(在执行读取操作时，避免使用 @Transactional 注释)

@Transactional(readOnly = true, propagation=Propagation.SUPPORTS)
public TradeData getTrade(long tradeId) throws Exception {
   return em.find(TradeData.class, tradeId);
}

5）REQUIRES_NEW 事务属性总是会在启动方法时启动一个新的事务。

@Transactional(propagation=Propagation.REQUIRES_NEW)
public long insertTrade(TradeData trade) throws Exception {
   em.persist(trade);
   updateAcct(trade);//新开一个事务，当前事务挂起。
   //exception occurs here! Trade rolled back but account update is not!
  //抛出异常，updateAcct执行的操作已提交。
   ...
}

6，事务回滚。

1）默认情况下，如果在事务中抛出了未检查异常（继承自 RuntimeException 的异常）或者 Error，则 Spring 将回滚事务。
2）如果在事务中抛出其他类型的异常，并期望 Spring 能够回滚事务，可以指定 rollbackFor。
3）运行时异常（即非受控异常）自动强制执行整个逻辑工作单元的回滚，但受控异常(checked Exception，需要被try..catch才可以编译通过)不会回滚。
@Transactional(propagation= Propagation.REQUIRED,rollbackFor= MyException.class)
4）当一个service抛出异常的时候(从自己向外层抛出)，才会回滚；另一个service调用它，并且try.. catch之后，自己没有向上层抛出，外层事务是不会回滚的。(当内层使用REQUIRED，内层不会回滚，因为和外层属于同一个事务，外层try catch了； 当内层使用NEW，内层是一个单独的事务，service向调用者抛出异常，内层自身会回滚)
5）maxscale代理可以配置开事务的走主库。 这时候，如果使用读写分离的策略，查询的时候，主从不同步，可能会查询不到记录的情况。

@Transactional(propagation=Propagation.REQUIRED)
public TradeData placeTrade(TradeData trade) throws Exception {
   try {
      insertTrade(trade);//(Propagation.REQUIRED)
      updateAcct(trade);//(REQUIRES_NEW)在执行 updateAcct() 方法期间抛出受控异常，就会保存交易订单，但不会更新帐户。
      return trade;
   } catch (Exception up) {
      //log the error
      throw up;
   }
}

4）添加事务一致性回滚。rollbackFor进行异常强制回滚

@Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class)
public TradeData placeTrade(TradeData trade) throws Exception {
   try {
      insertTrade(trade);
      updateAcct(trade);
      return trade;
   } catch (Exception up) {
      //log the error
      throw up;
   }
}

7，事务的隔离级别

SELECT @@tx_isolation; 或 show variables like "%tx%";
1）读未提交 READ-UNCOMMITTED(别的事务可以读取当前事务未commit的数据，造成脏读)

image.png

image.png

2）读已提交READ-COMMITTED(事务B可以读取事务A已提交的数据)可以解决脏读，会造成不可重复读(一个事务中两次读取会不一样)。

image.png

image.png

3）可重复读。REPEATABLE-READ 默认事务隔离级别。（事务A在两次读取中数据会保持一致，即使事务B更新并且提交。会造成幻读，这个时候插入一条id为4的数据(明明没有4这条数据，可以插入？)，插入失败，主键重复的。）
具体例子如：select 某记录是否存在，不存在，准备插入此记录，但执行 insert 时发现此记录已存在，无法插入，此时就发生了幻读。

image.png

image.png

4）串行化。SERIALIZABLE 事务串执行(先begin的时候，排前面)，事务A会挂起，等待事务B的commit，即使B没有写的操作。

image.png

image.png

image.png

image.png