页面加载中...

Spring事务使用总结

| Spring Boot | 2 条评论 | 900浏览

Spring对事务的支持

首先，程序是否支持事务，取决于数据库，比如Mysql的Innodb引擎，那么就支持事务；如果是Myisam引擎，那么就根本不支持事务。

Spring支持两种方式的事务管理，一种是编程式，另一种是注解式。编程式对代码入侵太大，一般使用情况较少；基本上都是通过注解方式来进行事务管理。

事务传播行为

事务传播行为是为了解决业务层方法之间互相调用的事务问题。

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。

Propagation.REQUIRED

使用的最多的一个事务传播行为，我们平时经常使用的@Transactional注解默认使用就是这个事务传播行为。如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。也就是说：

  1. 如果外部方法没有开启事务的话，Propagation.REQUIRED修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。
  2. 如果外部方法开启事务并且被Propagation.REQUIRED的话，所有Propagation.REQUIRED修饰的内部方法和外部方法均属于同一事务 ，只要一个方法回滚，整个事务均回滚。

举个例子：

@Component
@EnableTransactionManagement //相当于配置文件的spring-tx配置，springboot自动包括该注解
public class A {
    @Autowired
    JdbcTemplate jdbcTemplate;
    @Autowired
    B b;
    @Transactional(propagation=Propagation.REQUIRED)
    public void requiredA(){
        b.requiredB(); //1
        jdbcTemplate.update("insert into user(id,name) value (1,'zhangsan')");
        //除于0 ，制造一个程序异常
        int s = 3/0; //2
    }

}
@Component
@EnableTransactionManagement
public class B {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional(propagation=Propagation.REQUIRED)
    public void requiredB(){
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");

    }
}

在方法A里面，制造一个异常//2处，此时方法A会回滚，那么方法B也就会回滚。

或者将异常放在方法B中，就算方法A对异常进行了try catch处理，方法B回滚了，那么方法A也一样会回滚。

@Component
@EnableTransactionManagement 
public class A {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Autowired
    B b;

    @Transactional(propagation=Propagation.REQUIRED)
    public void requiredA(){
       jdbcTemplate.update("insert into user(id,name) value (1,'zhangsan')");
        try{
          //将异常放在B中，就算异常捕获了，A还是会回滚
            b.requiredB();
        }catch (Throwable e){
            System.out.println(e.getMessage());
        }
    }

}
@Component
@EnableTransactionManagement
public class B {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional(propagation=Propagation.REQUIRED)
    public void requiredB(){
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");
        //除于0 ，制造一个程序异常
        int s = 3/0; //2
    }
}

Propagation.REQUIRES_NEW

创建一个新的事务，如果当前存在事务，则把当前事务挂起。也就是说不管外部方法是否开启事务，Propagation.REQUIRES_NEW修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。

比如上面，我们将方法B的注解改为：@Transactional(propagation=Propagation.REQUIRES_NEW)

@Component
@EnableTransactionManagement //相当于配置文件的spring-tx配置，springboot自动包括该注解
public class A {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Autowired
    B b;

    @Transactional(propagation=Propagation.REQUIRED)
    public void requiredNewA(){
        b.requiredNewB(); //1
        jdbcTemplate.update("insert into user(id,name) value (1,'zhangsan')");
        //除于0 ，制造一个程序异常
        int s = 3/0; //2
    }

}
@Component
@EnableTransactionManagement
public class B {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional(propagation=Propagation.REQUIRES_NEW)
    public void requiredNewB(){
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");
    }
}

此时，方法A抛出了异常，方法A会回滚，但是方法B不会回滚，因为方法B是独立的事务。 同理，如果方法B回滚，同样也不会对方法A造成影响，比如：

@Component
@EnableTransactionManagement //相当于配置文件的spring-tx配置，springboot自动包括该注解
public class A {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Autowired
    B b;

    @Transactional(propagation=Propagation.REQUIRED)
    public void nestedA(){
        b.nestedB();
        jdbcTemplate.update("insert into user(id,name) value (1,'zhangsan')");
        //除于0 ，制造一个程序异常
        int s = 3/0;
    }

}
@Component
@EnableTransactionManagement
public class B {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional(propagation=Propagation.NESTED)
    public void nestedB(){
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");
    }
}

此时，方法A回滚，那么方法B也就会回滚。

如果将异常放在方法B里面：

@Component
@EnableTransactionManagement //相当于配置文件的spring-tx配置，springboot自动包括该注解
public class A {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Autowired
    B b;

    @Transactional(propagation=Propagation.REQUIRED)
    public void nestedA(){
        b.nestedB();
        jdbcTemplate.update("insert into user(id,name) value (1,'zhangsan')");
        
    }

}
@Component
@EnableTransactionManagement
public class B {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional(propagation=Propagation.NESTED)
    public void nestedB(){
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");
        //除于0 ，制造一个程序异常
        int s = 3/0;
    }
}

Propagation.NESTED

如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。也就是说：

它大部分情况都等价于Propagation.REQUIRS_NEW，但是： 如果主事务回滚了，那么NESTED也会回滚。比如：

@Component
@EnableTransactionManagement //相当于配置文件的spring-tx配置，springboot自动包括该注解
public class A {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Autowired
    B b;

    @Transactional(propagation=Propagation.REQUIRED)
    public void nestedA(){
        b.nestedB(); //1
        jdbcTemplate.update("insert into user(id,name) value (1,'zhangsan')");
        //除于0 ，制造一个程序异常
        int s = 3/0; //2
    }

}
@Component
@EnableTransactionManagement
public class B {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional(propagation=Propagation.NESTED)
    public void nestedB(){
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");
    }
}

此时方法A产生了异常，出现了回滚，那么方法B也会回滚。

Propagation.MANDATORY

如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。（mandatory：强制性） 这个一般用得的比较少。 比如方法A有事务：

@Component
@EnableTransactionManagement //相当于配置文件的spring-tx配置，springboot自动包括该注解
public class A {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Autowired
    B b;

   @Transactional(propagation=Propagation.REQUIRED) //1
    public void mandatoryA(){
        b.mandatoryB();
        jdbcTemplate.update("insert into user(id,name) value (1,'zhangsan')");

    }

}
@Component
@EnableTransactionManagement
public class B {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional(propagation=Propagation.MANDATORY)
    public void mandatoryB(){
        jdbcTemplate.update("insert into user(id,name) value (3,'wangwu')");
    }
}

此时程序正常，未见异常。 如果将//1处，方法A的@Transactional注解去掉，再次运行执行方法A，就会出现如下异常：

org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory'

Propagation.NOT_SUPPORTED

表示不支持事务，方法不会以事务的方式进行。如果有事务存在，将它挂起，以无事务状态运行 。 无事务,就是指底层的Connection对象的autoCommit、isolation等属性与数据库有关,与dataSource设置的属性有关，不会被Spring改变。

Transactional注解

Transactional注解中常用的配置参数

属性名说明
propagation事务的传播行为，默认值为 REQUIRED，上面已说过
isolation事务的隔离级别，默认值采用 DEFAULT , 下面会说到
timeout事务的超时时间，单位秒，默认值为-1（不会超时）。
readOnly指定事务是否为只读事务，默认值为 false。
rollbackFor用于指定能够触发事务回滚的异常类型，并且可以指定多个异常类型。

事务回滚规则

默认情况下，事务在遇到运行时异常（RuntimeException）及Error错误就会回滚。 在遇到检查型（checked）异常不会回滚，比如这样：

    @Transactional
    public void rollbackForA() throws IOException {
        jdbcTemplate.update("insert into user(id,name) value (2,'abc')");
        throw new IOException("123");
    }

那么该事务不会回滚。

这时可以指定事务回滚规则，在@Transcational注解中添加rollbackFor属性：

    @Transactional(rollbackFor = IOException.class)
    public void rollbackForA() throws IOException {
        jdbcTemplate.update("insert into user(id,name) value (2,'abc')");
        throw new IOException("123");
    }

此时该事务就会回滚。

事务超时时间

timeou，单位秒，默认值为-1（不会超时）。如果超过该时间限制但事务还没有完成，则自动回滚事务。

比如，指定事务时间为2秒，下面这个sql执行需要3秒，那么事务就会回滚。

    @Transactional(timeout = 2)
    public void timeoutA(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        jdbcTemplate.update("insert into user(id,name) value (2,'123')");
    }

此时事务超时，回滚并会抛出一个异常：

org.springframework.transaction.TransactionTimedOutException: Transaction timed out: deadline was Wed Jul 15 10:32:14 CST 2020

事务只读属性

readOnly，对于只有读取数据查询的事务，可以指定事务类型为 readonly，即只读事务。只读事务不涉及数据的修改，数据库会提供一些优化手段，适合用在有多条数据库查询操作的方法中。

如果指定了readOnly=true，但还是update语句，那么就会抛出异常并回滚。比如：

    @Transactional(readOnly=true)
    public void readOnlyA(){
        jdbcTemplate.update("insert into user(id,name) value (2,'123')");
    }

此时就会抛出异常：

org.springframework.dao.TransientDataAccessResourceException: StatementCallback; SQL [insert into user(id,name) value (2,'123')]; Connection is read-only. Queries leading to data modification are not allowed.; nested exception is java.sql.SQLException: Connection is read-only. Queries leading to data modification are not allowed.
  • 只读为什么也要有事务？

如果不用事务，即不加@Tranactional，那么每条sql会单独开启一个事务。考虑这么个情况，执行n个表的查询语句，其中一些表此时正被其他事务修改，那么你读到的数据就会出现不一致的情况。

如果给方法加上了Transactional注解的话，这个方法执行的所有sql会被放在一个事务中。如果声明了只读事务的话，数据库就会去优化它的执行，并不会带来其他的什么收益。

事务隔离级别

Spring有一个枚举类Isolation，专门定义事务隔离级别。

public enum Isolation {
    DEFAULT(TransactionDefinition.ISOLATION_DEFAULT),
    READ_UNCOMMITTED(TransactionDefinition.ISOLATION_READ_UNCOMMITTED),
    READ_COMMITTED(TransactionDefinition.ISOLATION_READ_COMMITTED),
    REPEATABLE_READ(TransactionDefinition.ISOLATION_REPEATABLE_READ),
    SERIALIZABLE(TransactionDefinition.ISOLATION_SERIALIZABLE);

    private final int value;
    Isolation(int value) {
        this.value = value;
    }
    public int value() {
        return this.value;
    }

}
  • DEFAULT:使用后端数据库默认的隔离级别，MySQL 默认采用的 REPEATABLE_READ 隔离级别 Oracle 默认采用的 READ_COMMITTED 隔离级别;
  • READ_UNCOMMITTED:最低的隔离级别，使用这个隔离级别很少，因为它允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读;
  • READ_COMMITTED : 允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生;
  • REPEATABLE_READ : 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生;
  • SERIALIZABLE : 最高的隔离级别，完全服从 ACID 的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别;

Spring 事务失效的几种情况

@Transactional只有在public方法才起作用

@Transactional注解作用的方法，private方法直接就编译出错，protected方法注解不会生效。比如：

    @Transactional
    protected void pA(){
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");
        int s =3/0;
    }

该方法的事务不会生效

自调用

在一个非事务方法里调用一个事务方法，此时事务方法的事务就会失效。比如：

@Component
@EnableTransactionManagement
public class TxInvalidMaster {

    @Autowired
    JdbcTemplate jdbcTemplate;

    public void a(){
        jdbcTemplate.update("insert into user(id,name) value (1,'zhangsan')");
        b();
    }

    @Transactional
    public void b(){
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");
        int s =3/0;
    }
}

执行方法a，会发现方法b的事务并没有生效。

属性rollbackFor指定异常不正确

比如，下面方法抛出的是IoException，但是rollbackFor却是SQLException，那么此时事务也不会回滚

    @Transactional(rollbackFor = SQLException.class)
    public void rollbackForA() throws IOException {
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");
        throw new IOException("123");
    }

参考文章

发表评论

最新评论

  1. 热心网友

    1024 up up up 节日快乐！

  2. 热心网友

    cool

Spring事务使用总结

发表评论

最新评论