投稿
  1. 极客之音首页
  2. 其他分类
  3. 微信精选

Spring事务传播

小半 • • 微信精选 • 阅读 74

Spring事务传播

什么事务传播机制

首先这个传播机制跟数据库是没有关系的，不会因为你是MySQL或者oracle而有所区别。它是Spring框架中提供的一种事务增强机制，合理的利用能很好的解决一些方法之间的嵌套问题，如果不清楚很可能导致各种奇怪的问题。

事务传播机制的类型

在Spring中一共提供了七种事务传播机制，在TransactionDefinition中可以找到如下表的定义：

事务传播类型 说明
PROPAGATION_REQUIRED 如果当前没有事务，则创建一个新的事务。如果存在事务，则加入到该事务。这是我们用的最多的一种，同时也是Spring框架默认的。
PROPAGATION_SUPPORTS 支持事务运行，如果当前有事务则加入，没有则以非事务的方式运行。
PROPAGATION_MANDATORY 使用当前事务运行，如果当前没有事务，则抛出异常。
PROPAGATION_REQUIRES_NEW 新建事务，如果当前以及存在事务，则把当前事务挂起。
PROPAGATION_NOT_SUPPORTED 已非事务的方式运行，如果当前存在事务，则挂起当前事务。
PROPAGATION_NEVER 不支持事务，已非事务的方式运行。如果当前存在事务，则抛出异常。
PROPAGATION_NESTED 如果当前存在事务，则嵌套在该事务内执行。如果不存在事务，则与PROPAGATION_REQUIRED一样执行。

上面介绍了Spring框架默认提供的七种事务传播机制，下面我们通过代码来演示不同事务机制下的运行结果。

下面的代码中我们在AuthorServiceImpl调用BookServiceImpl中的方法，然后通过Spring的事务日志中查看事务相关信息。

logging.level.org.springframework.jdbc=debug

通过在properties配置文件中设置日志打印级别，我们可以看到Spring完整的事务信息。AuthorServiceImpl.Java

@Service
@Slf4j
public class AuthorServiceImpl implements AuthorService {
    @Autowired
    private AuthorMapper authorMapper;
    @Autowired
    private BookService bookService;
    @Override
    public void addAuthor1() {
        Author author = new Author("addAuthor1");
        log.info("插入addAuthor1");
        authorMapper.insertAuthor(author);
        log.info("插入addAuthor1完成");
        bookService.insertBook1();
    }
    @Override
    public void addAuthor2() {
        Author author = new Author("addAuthor2");
        log.info("插入addAuthor2");
        authorMapper.insertAuthor(author);
        log.info("插入addAuthor2完成");
        bookService.insertBook2();
    }
    @Override
    public void addAuthor3() {
        Author author = new Author("addAuthor3");
        log.info("插入addAuthor3");
        authorMapper.insertAuthor(author);
        log.info("插入addAuthor3完成");
        bookService.insertBook3();
    }
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void addAuthor4() {
        Author author = new Author("addAuthor4");
        log.info("插入addAuthor4");
        authorMapper.insertAuthor(author);
        log.info("插入addAuthor4完成");
        bookService.insertBook4();
    }
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void addAuthor5() {
        Author author = new Author("addAuthor5");
        log.info("插入addAuthor5");
        authorMapper.insertAuthor(author);
        log.info("插入addAuthor5完成");
        bookService.insertBook5();
    }
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void addAuthor6() {
        Author author = new Author("addAuthor6");
        log.info("插入addAuthor6");
        authorMapper.insertAuthor(author);
        log.info("插入addAuthor6完成");
        bookService.insertBook6();
    }
    @Override
    public void addAuthor7() {
        Author author = new Author("addAuthor7");
        log.info("插入addAuthor7");
        authorMapper.insertAuthor(author);
        log.info("插入addAuthor7完成");
        bookService.insertBook7();
    }
}

BookServiceImpl.java

@Service
@Slf4j
public class BookServiceImpl implements BookService {
    @Autowired
    private BookMapper bookMapper;
    /**
     * 如果已经存在事务则加入该事务，如果不存在，则新建一个新的事务
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void insertBook1() {
        log.info("插入insertBook1");
        Book book = new Book("insertBook1");
        bookMapper.insertBook(book);
        log.info("插入insertBook1完成");
    }
    /**
     * 如果存在事务则加入，不存在则已非事务的方式运行
     */
    @Override
    @Transactional(propagation = Propagation.SUPPORTS)
    public void insertBook2() {
        log.info("插入insertBook2");
        Book book = new Book("insertBook2");
        bookMapper.insertBook(book);
        log.info("插入insertBook2完成");
    }
    /**
     * 如果存在事务则加入，不存在直接抛出异常
     */
    @Override
    @Transactional(propagation = Propagation.MANDATORY)
    public void insertBook3() {
        log.info("插入insertBook3");
        Book book = new Book("insertBook3");
        bookMapper.insertBook(book);
        log.info("插入insertBook3完成");
    }
    /**
     * 如果存在事务，则挂起当前事务，然后新建事务
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void insertBook4() {
        log.info("插入insertBook4");
        Book book = new Book("insertBook4");
        bookMapper.insertBook(book);
        log.info("插入insertBook4完成");
    }
    /**
     * 如果存在事务，则挂起当前事务，以非事务形式运行
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void insertBook5() {
        log.info("插入insertBook5");
        Book book = new Book("insertBook5");
        bookMapper.insertBook(book);
        log.info("插入insertBook5完成");
    }
    /**
     * 如果不存在事务，则已非事务形式运行。如果存在事务，则抛出异常
     */
    @Override
    @Transactional(propagation = Propagation.NEVER)
    public void insertBook6() {
        log.info("插入insertBook6");
        Book book = new Book("insertBook6");
        bookMapper.insertBook(book);
        log.info("插入insertBook6完成");
    }
    /**
     *
     */
    @Override
    @Transactional(propagation = Propagation.NESTED)
    public void insertBook7() {
        log.info("插入insertBook7");
        Book book = new Book("insertBook7");
        bookMapper.insertBook(book);
        log.info("插入insertBook7完成");
    }
}

PROPAGATION_REQUIRED

首先我们调用addAuthor1方法，addAuthor1上并没有开启事务，而insertBook1开启事务传播方式设置为REQUIRED，日志信息如下：

插入addAuthor1
Fetching JDBC Connection from DataSource
插入addAuthor1完成
Creating new transaction with name [com.buydeem.share.springtxpropagation.service.impl.BookServiceImpl.insertBook1]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
Acquired Connection [HikariProxyConnection@2123502254 wrapping com.mysql.cj.jdbc.ConnectionImpl@73a3abfa] for JDBC transaction
Switching JDBC Connection [HikariProxyConnection@2123502254 wrapping com.mysql.cj.jdbc.ConnectionImpl@73a3abfa] to manual commit
插入insertBook1
插入insertBook1完成
Initiating transaction commit
Committing JDBC transaction on Connection [HikariProxyConnection@2123502254 wrapping com.mysql.cj.jdbc.ConnectionImpl@73a3abfa]
Releasing JDBC Connection [HikariProxyConnection@2123502254 wrapping com.mysql.cj.jdbc.ConnectionImpl@73a3abfa] after transaction

从日志1-3行可以看出，addAuthor1并没有开启事务，而日志的4-11行分别经历了开启事务，执行插入SQL，然后提交事务这么一个过程。

PROPAGATION_SUPPORTS

首先我们调用addAuthor2方法，addAuthor2上并没有开启事务，而insertBook2开启事务，传播类型设置为SUPPORTS,日志信息如下：

插入addAuthor2
Fetching JDBC Connection from DataSource
插入addAuthor2完成
插入insertBook2
Fetching JDBC Connection from DataSource
插入insertBook2完成

从上面的日志可以看出，整个过程都没有开启事务，因为在addAuthor2方法上并没有开启事务，所以insertBook2则已非事务的方式运行。

PROPAGATION_MANDATORY

首先我们调用addAuthor3方法，addAuthor3上并没有开启事务，而insertBook3开启事务，传播类型设置为MANDATORY,日志信息如下：

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

该次方法调用没有完成，而是抛出了异常。问题就在于addAuthor3没有开启日志，insertBook3必须是在有事务的情况下才可以正常运行。

PROPAGATION_REQUIRES_NEW

首先我们调用addAuthor4方法，addAuthor4上开启事务，insertBook4也开启事务，传播类型设置为REQUIRES_NEW,日志信息如下：

Creating new transaction with name [com.buydeem.share.springtxpropagation.service.impl.AuthorServiceImpl.addAuthor4]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
Acquired Connection [HikariProxyConnection@711616768 wrapping com.mysql.cj.jdbc.ConnectionImpl@73a3abfa] for JDBC transaction
Switching JDBC Connection [HikariProxyConnection@711616768 wrapping com.mysql.cj.jdbc.ConnectionImpl@73a3abfa] to manual commit
插入addAuthor4
插入addAuthor4完成
Suspending current transaction, creating new transaction with name [com.buydeem.share.springtxpropagation.service.impl.BookServiceImpl.insertBook4]
Acquired Connection [HikariProxyConnection@1421806083 wrapping com.mysql.cj.jdbc.ConnectionImpl@648e1366] for JDBC transaction
Switching JDBC Connection [HikariProxyConnection@1421806083 wrapping com.mysql.cj.jdbc.ConnectionImpl@648e1366] to manual commit
插入insertBook4
插入insertBook4完成
Initiating transaction commit
Committing JDBC transaction on Connection [HikariProxyConnection@1421806083 wrapping com.mysql.cj.jdbc.ConnectionImpl@648e1366]
Releasing JDBC Connection [HikariProxyConnection@1421806083 wrapping com.mysql.cj.jdbc.ConnectionImpl@648e1366] after transaction
Resuming suspended transaction after completion of inner transaction
Initiating transaction commit
Committing JDBC transaction on Connection [HikariProxyConnection@711616768 wrapping com.mysql.cj.jdbc.ConnectionImpl@73a3abfa]
Releasing JDBC Connection [HikariProxyConnection@711616768 wrapping com.mysql.cj.jdbc.ConnectionImpl@73a3abfa] after transaction

从日志1-5行可以看出，在执行addAuthor4方法时开启了事务。6-13行可以看出在执行insertBook4方法时开启了事务，在Sql执行完成之后提交了事务。14-17行可以看出它恢复了addAuthor4开启的事务并提交了事务，所以在该次方法调用中实际上是开启了两个事务。

PROPAGATION_NOT_SUPPORTED

首先我们调用addAuthor5方法，addAuthor5上开启事务，insertBook5也开启事务，传播类型设置为NOT_SUPPORTED,日志信息如下：

Creating new transaction with name [com.buydeem.share.springtxpropagation.service.impl.AuthorServiceImpl.addAuthor5]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
Acquired Connection [HikariProxyConnection@1147713578 wrapping com.mysql.cj.jdbc.ConnectionImpl@73a3abfa] for JDBC transaction
Switching JDBC Connection [HikariProxyConnection@1147713578 wrapping com.mysql.cj.jdbc.ConnectionImpl@73a3abfa] to manual commit
插入addAuthor5
插入addAuthor5完成
Suspending current transaction
插入insertBook5
Fetching JDBC Connection from DataSource
插入insertBook5完成
Resuming suspended transaction after completion of inner transaction
Initiating transaction commit
Committing JDBC transaction on Connection [HikariProxyConnection@1147713578 wrapping com.mysql.cj.jdbc.ConnectionImpl@73a3abfa]
Releasing JDBC Connection [HikariProxyConnection@1147713578 wrapping com.mysql.cj.jdbc.ConnectionImpl@73a3abfa] after transaction

从日志的1-5行可以看出，方法addAuthor5开启了事务并执行了SQL，在6-9行可以看出，insertBook5并没有开启新的事务，而是暂停了之前的事务以非事务的方式运行。在日志的10-13行可以看出，它恢复了之前暂停的事务然后提交了事务。

PROPAGATION_NEVER

首先我们调用addAuthor6方法，addAuthor6上开启事务，insertBook6也开启事务，传播类型设置为NEVER,日志信息如下：

org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation 'never'

该方法并没有完整的执行完成，而是在抛出了异常。这是因为在addAuthor6中开启了事务，而insertBook6设置的传播类型为PROPAGATION_NEVER，从异常信息也能看出。

PROPAGATION_NESTED

该方式比较特殊，意思是在已存在的事务中再次开启事务，即事务的嵌套。在其他数据库中暂时未做测试，在Mysql中并不是在事务中再开启一个子事务，而是提供一个savepoint，类似于一个暂存档。如果在事务中再次使用start transaction/begin，这将会导致前一个事务并隐式提交。该传播模式对应到Mysql如下所示：

mysql> begin;
Query OK, 0 rows affected
mysql> insert into t_book (book_name) value ('test1');
Query OK, 1 row affected
mysql> savepoint s1;
Query OK, 0 rows affected
mysql> insert into t_book (book_name) value ('test2');
Query OK, 1 row affected
mysql> commit;
Query OK, 0 rows affected
mysql> select * from t_book;
+----+-------------+
| id | book_name   |
+----+-------------+
| 19 | test1       |
+----+-------------+
1 rows in set

首先我们调用addAuthor7方法，addAuthor7上开启事务，insertBook7也开启事务，传播类型设置为NESTED,日志信息如下：

Creating new transaction with name [com.buydeem.share.springtxpropagation.service.impl.AuthorServiceImpl.addAuthor7]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
Acquired Connection [HikariProxyConnection@1072851271 wrapping com.mysql.cj.jdbc.ConnectionImpl@25e98b3f] for JDBC transaction
Switching JDBC Connection [HikariProxyConnection@1072851271 wrapping com.mysql.cj.jdbc.ConnectionImpl@25e98b3f] to manual commit
插入addAuthor7
插入addAuthor7完成
Creating nested transaction with name [com.buydeem.share.springtxpropagation.service.impl.BookServiceImpl.insertBook7]
插入insertBook7
插入insertBook7完成
Releasing transaction savepoint
Initiating transaction commit
Committing JDBC transaction on Connection [HikariProxyConnection@1072851271 wrapping com.mysql.cj.jdbc.ConnectionImpl@25e98b3f]
Releasing JDBC Connection [HikariProxyConnection@1072851271 wrapping com.mysql.cj.jdbc.ConnectionImpl@25e98b3f] after transaction

从日志的1-5行可以看出，addAuthor7开启了一个事务。从6-9可以看出，insertBook7创建了一个嵌套事务，并且嵌套事务的名字为：com.buydeem.share.springtxpropagation.service.impl.BookServiceImpl.insertBook7，然后在insertBook7中的sql执行完成之后release了savepoint。在10-12行中可以看出，整个事务被提交了。

事务传播失效

有时候在开发的时候我们很容易会犯一个低级错误，例如下面的代码：

@Override
public void addAuthor8() {
    Author author = new Author("addAuthor8");
    log.info("插入addAuthor8");
    authorMapper.insertAuthor(author);
    log.info("插入addAuthor8完成");
    addAuthor9();
}
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void addAuthor9() {
    Author author = new Author("addAuthor9");
    log.info("插入addAuthor9");
    authorMapper.insertAuthor(author);
    log.info("插入addAuthor9完成");
}

当我们调用addAuthor8时，按照我们前面所讲的事务传播类型来说，addAuthor9应该是会开启事务的。但是实际上从打印的日志中可以看出并非如此：

插入addAuthor8
Fetching JDBC Connection from DataSource
插入addAuthor8完成
插入addAuthor9
Fetching JDBC Connection from DataSource
插入addAuthor9完成

从打印的日志可以看出，整个过程都没有打印出开启事务和事务提交相关信息。造成这个问题的原因就是动态代理造成的。在Spring中像@Transcation，@Cacheable等注解都是通过AOP的方式来实现的，在AOP的实现过程中就用到了动态代理。当默认情况下，例如在UserServiceImpl类中方法A调用方法B，方法B上的注解将不会生效。要想自调用注解生效有如下几种解决方案：

Autowired注入自身

@Autowired
private AuthorService authorService;
@Override
public void addAuthor10() {
    Author author = new Author("addAuthor10");
    log.info("插入addAuthor10");
    authorMapper.insertAuthor(author);
    log.info("插入addAuthor10完成");
    authorService.addAuthor9();
}

最后打印的日志如下：

插入addAuthor10
Fetching JDBC Connection from DataSource
插入addAuthor10完成
Creating new transaction with name [com.buydeem.share.springtxpropagation.service.impl.AuthorServiceImpl.addAuthor9]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
Acquired Connection [HikariProxyConnection@146798052 wrapping com.mysql.cj.jdbc.ConnectionImpl@22010483] for JDBC transaction
Switching JDBC Connection [HikariProxyConnection@146798052 wrapping com.mysql.cj.jdbc.ConnectionImpl@22010483] to manual commit
插入addAuthor9
插入addAuthor9完成
Initiating transaction commit
Committing JDBC transaction on Connection [HikariProxyConnection@146798052 wrapping com.mysql.cj.jdbc.ConnectionImpl@22010483]
Releasing JDBC Connection [HikariProxyConnection@146798052 wrapping com.mysql.cj.jdbc.ConnectionImpl@22010483] after transaction

从结果可以看出，事务的传播类型生效了。我们通过将自身注入的本类中，而注入的AuthorService是动态代理生成的代理类，而不是没有经过加强的被代理类，所以上面的@Transcation注解才会生效。不过这种方式看上去比较奇怪，不过他确实是能工作，因为Spring已经解决了这种循环依赖。

AopContext代替this

@SpringBootApplication
@MapperScan(basePackages = {"com.buydeem.share.springtxpropagation.dao"})
@EnableAspectJAutoProxy(exposeProxy = true)
public class SpringTxPropagationApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringTxPropagationApplication.class, args);
    }
}
@Override
public void addAuthor11() {
    Author author = new Author("addAuthor11");
    log.info("插入addAuthor11");
    authorMapper.insertAuthor(author);
    log.info("插入addAuthor11完成");
    AuthorService temp = (AuthorService) AopContext.currentProxy();
    temp.addAuthor9();
}

通过AopContext获取当前类的代理对象，该方式需要注意的一点就是添加下面的配置：

@EnableAspectJAutoProxy(exposeProxy = true)

同时在pom.xml文件中添加如下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

从ApplicationContext中获取实例

@Autowired
private ApplicationContext applicationContext;
@Override
public void addAuthor12() {
    Author author = new Author("addAuthor12");
    log.info("插入addAuthor12");
    authorMapper.insertAuthor(author);
    log.info("插入addAuthor12完成");
    AuthorService temp = applicationContext.getBean(AuthorService.class);
    temp.addAuthor9();
}

上面的方式就是通过ApplicationContext容器中获取AuthorService的代理类，通过该方式同样能解决自调用的AOP不生效的错误。

引用

  • Java动态代理
  • 示例代码地址：https://gitee.com/zengchao_workspace/spring-tx-propagation.git


原文始发于微信公众号（一只菜鸟程序员）：Spring事务传播

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/73165.html

赞 (0)
小半的头像小半
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！