Spring事务传播机制

已于 2022-11-18 11:17:44 修改
阅读量753 收藏
点赞数
分类专栏： 学习笔记 SpringBoot 疑难问题 文章标签： spring java 事务
于 2022-10-06 22:43:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22610595/article/details/127189076
版权

Spring事务传播行为验证

文章目录

Spring事务传播机制

Spring中的Propagation枚举类中定义了七种事务传播机制，事务的传播机制都是针对被调用方来说的，假如，方法A中调用了B方法，对于方法B有以下七种事务传播机制来处理A的事务：

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

验证需要的示例代码：

@RestController
@RequestMapping("/transactional")
public class TestTransactionalController {

    @Resource
    TestTransactionalAService transactionalAService;

    @RequestMapping("/fund")
    public String fund() throws ParseException {
        transactionalAService.subFund();
        return "OK";
    }
}

@Service
public class TestTransactionalAService {

    @Resource
    TestTransactionalADao transactionalADao;

    @Resource
    TestTransactionalBService transactionalBService;

    @Transactional
    public void subFund() throws ParseException {
        transactionalADao.subFund(1, 200, DateUtils.dateFormat(String.valueOf(System.currentTimeMillis()), false));
        transactionalBService.addFund();
    }
}

@Service
public class TestTransactionalBService {

    @Resource
    TestTransactionalBDao transactionalBDao;

    @Transactional
    public void addFund() throws ParseException {
        transactionalBDao.addFund(2, 200, DateUtils.dateFormat(String.valueOf(System.currentTimeMillis()), false));
    }
}

// 开启这三个类的debug日志即可，否则日志太多，不方便查看
logging.level.com.orkasgb.bigdatatools.dao.TestTransactionalADao=debug
logging.level.com.orkasgb.bigdatatools.dao.TestTransactionalBDao=debug
logging.level.org.springframework.jdbc.datasource.DataSourceTransactionManager=debug

REQUIRED：

事务机制的默认行为，如果调用者存在事务，则被调用者加入当前事务，如果不存在，则被调用者新建事务，即：A方法存在事务的时候，B方法就加入当前事务执行，否则，B方法新建一个事务执行。

验证（开启debug日志，查看控制台日志）：在TestTransactionalAService.subFund上加上@Transactional注解，并在TestTransactionalBService.addFund上增加@Transactional(propagation = Propagation.REQUIRED)

(org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].java:173)-Initializing Spring DispatcherServlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:525)-Initializing Servlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:547)-Completed initialization in 11 ms
// 调用者TestTransactionalAService.subFund上增加了@Transactional注解，执行的时候创建了一个新的事务，所以TestTransactionalAService.subFund是以事务方式运行的
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:370)-Creating new transaction with name [com.orkasgb.bigdatatools.service.TestTransactionalAService.subFund]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:263)-Acquired Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@641c8066]]] for JDBC transaction
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:281)-Switching JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@641c8066]]] to manual commit
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund - ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 14:24:53(String), 1(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-<==    Updates: 1
// 被调用者TestTransactionalBService.addFund上增加了@Transactional(propagation = Propagation.REQUIRED)注解，执行的时候，发现调用者TestTransactionalAService.subFund已经创建了事务，因为事务传播机制为REQUIRED，所以加入了已经调用者创建的事务，以事务方式运行。
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:470)-Participating in existing transaction
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund + ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 14:24:53(String), 2(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-<==    Updates: 1
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:740)-Initiating transaction commit
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:326)-Committing JDBC transaction on Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@641c8066]]]
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:385)-Releasing JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@641c8066]]] after transaction

验证（开启debug日志，查看控制台日志）：取消TestTransactionalAService.subFund上的@Transactional注解，并在TestTransactionalBService.addFund上增加@Transactional(propagation = Propagation.REQUIRED)

(org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].java:173)-Initializing Spring DispatcherServlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:525)-Initializing Servlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:547)-Completed initialization in 11 ms
// 调用者TestTransactionalAService.subFund上没有增加@Transactional注解，所以调用者TestTransactionalAService.subFund是以非事务方式运行的
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund - ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 14:35:44(String), 1(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-<==    Updates: 1
// 被调用者TestTransactionalBService.addFund上增加了@Transactional(propagation = Propagation.REQUIRED)注解，执行的时候，发现调用者TestTransactionalAService.subFund没有创建事务，因为事务传播机制为REQUIRED，所以自己执行时候创建了事务，以事务方式运行。
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:370)-Creating new transaction with name [com.orkasgb.bigdatatools.service.TestTransactionalBService.addFund]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:263)-Acquired Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@10cb9808]]] for JDBC transaction
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:281)-Switching JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@10cb9808]]] to manual commit
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund + ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 14:35:44(String), 2(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-<==    Updates: 1
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:740)-Initiating transaction commit
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:326)-Committing JDBC transaction on Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@10cb9808]]]
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:385)-Releasing JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@10cb9808]]] after transaction

SUPPORTS：

如果调用者存在事务，则被调用者加入当前事务，如果不存在，则被调用者也不会新建事务，而是以非事务方式执行。即：A方法存在事务的时候，B方法就加入当前事务执行，否则，B方法不会新建一个事务，而是以非事务执行。

验证（开启debug日志，查看控制台日志）：在TestTransactionalAService.subFund上加上@Transactional注解，并在TestTransactionalBService.addFund上增加@Transactional(propagation = Propagation.SUPPORTS)

(org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].java:173)-Initializing Spring DispatcherServlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:525)-Initializing Servlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:547)-Completed initialization in 16 ms
// 调用者TestTransactionalAService.subFund上增加了@Transactional注解，执行的时候创建了一个新的事务，所以TestTransactionalAService.subFund是以事务方式运行的
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:370)-Creating new transaction with name [com.orkasgb.bigdatatools.service.TestTransactionalAService.subFund]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:263)-Acquired Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@104ea18b]]] for JDBC transaction
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:281)-Switching JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@104ea18b]]] to manual commit
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund - ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 14:47:47(String), 1(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-<==    Updates: 1
// 被调用者TestTransactionalBService.addFund上增加了@Transactional(propagation = Propagation.SUPPORTS)注解，执行的时候，发现调用者TestTransactionalAService.subFund已经创建了事务，因为事务传播机制为SUPPORTS，所以加入了调用者创建的事务，以事务方式运行。
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:470)-Participating in existing transaction
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund + ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 14:47:47(String), 2(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-<==    Updates: 1
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:740)-Initiating transaction commit
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:326)-Committing JDBC transaction on Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@104ea18b]]]
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:385)-Releasing JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@104ea18b]]] after transaction

验证（开启debug日志，查看控制台日志）：取消TestTransactionalAService.subFund上加上@Transactional注解，并在TestTransactionalBService.addFund上增加@Transactional(propagation = Propagation.SUPPORTS)

(org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].java:173)-Initializing Spring DispatcherServlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:525)-Initializing Servlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:547)-Completed initialization in 12 ms
// 调用者TestTransactionalAService.subFund上没有增加@Transactional注解，所以调用者TestTransactionalAService.subFund是以非事务方式运行的
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund - ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 14:44:26(String), 1(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-<==    Updates: 1
// 被调用者TestTransactionalBService.addFund上增加了@Transactional(propagation = Propagation.SUPPORTS)注解，执行的时候，发现调用者TestTransactionalAService.subFund没有创建事务，因为事务传播机制为SUPPORTS，所以自己也没有创建事务，也以非事务方式运行。
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund + ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 14:44:27(String), 2(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-<==    Updates: 1

MANDATORY：

被调用者必须在事务中运行，如果调用者没有事务，被调用者将会抛出异常。即：A方法存在事务的时候，B方法就加入当前事务执行，否则，B方法直接抛出异常。

验证（开启debug日志，查看控制台日志）：在TestTransactionalAService.subFund上加上@Transactional注解，并在TestTransactionalBService.addFund上增加@Transactional(propagation = Propagation.MANDATORY)

(org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].java:173)-Initializing Spring DispatcherServlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:525)-Initializing Servlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:547)-Completed initialization in 14 ms
// 调用者TestTransactionalAService.subFund上增加了@Transactional注解，执行的时候创建了一个新的事务，所以TestTransactionalAService.subFund是以事务方式运行的
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:370)-Creating new transaction with name [com.orkasgb.bigdatatools.service.TestTransactionalAService.subFund]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:263)-Acquired Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@360fb7d5]]] for JDBC transaction
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:281)-Switching JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@360fb7d5]]] to manual commit
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund - ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 14:52:32(String), 1(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-<==    Updates: 1
// 被调用者TestTransactionalBService.addFund上增加了@Transactional(propagation = Propagation.MANDATORY)注解，执行的时候，发现调用者TestTransactionalAService.subFund已经创建了事务，因为事务传播机制为MANDATORY，所以自己执行时候加入了调用者创建的事务中，以事务方式运行。
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:470)-Participating in existing transaction
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund + ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 14:52:32(String), 2(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-<==    Updates: 1
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:740)-Initiating transaction commit
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:326)-Committing JDBC transaction on Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@360fb7d5]]]
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:385)-Releasing JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@360fb7d5]]] after transaction

验证（开启debug日志，查看控制台日志）：取消TestTransactionalAService.subFund上加上@Transactional注解，并在TestTransactionalBService.addFund上增加@Transactional(propagation = Propagation.MANDATORY)

(org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].java:173)-Initializing Spring DispatcherServlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:525)-Initializing Servlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:547)-Completed initialization in 13 ms
// 调用者TestTransactionalAService.subFund上没有增加@Transactional注解，所以调用者TestTransactionalAService.subFund是以非事务方式运行的
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund - ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 14:53:54(String), 1(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-<==    Updates: 1
// 被调用者TestTransactionalBService.addFund上增加了@Transactional(propagation = Propagation.MANDATORY)注解，执行的时候，发现调用者TestTransactionalAService.subFund没有创建事务，因为事务传播机制为MANDATORY，所以直接抛出异常，并且明确提示出 “ No existing transaction found ”
(org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].[dispatcherServlet].java:175)-Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory'] with root cause
org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory'
	at org.springframework.transaction.support.AbstractPlatformTransactionManager.getTransaction(AbstractPlatformTransactionManager.java:362)

REQUIRES_NEW：

被调用者必须在自己创建的事务中运行，如果调用者有事务，则被调用者将会将当前事务挂起，自己新建事务运行。即：A方法存在事务的时候，B方法就暂停当前事务并自己新建事务运行，否则，B方法直接创建事务运行。

验证（开启debug日志，查看控制台日志）：在TestTransactionalAService.subFund上加上@Transactional注解，并在TestTransactionalBService.addFund上增加@Transactional(propagation = Propagation.REQUIRES_NEW)

(org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].java:173)-Initializing Spring DispatcherServlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:525)-Initializing Servlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:547)-Completed initialization in 10 ms
// 调用者TestTransactionalAService.subFund上增加了@Transactional注解，执行的时候创建了一个新的事务，所以TestTransactionalAService.subFund是以事务方式运行的
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:370)-Creating new transaction with name [com.orkasgb.bigdatatools.service.TestTransactionalAService.subFund]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:263)-Acquired Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@6b3810aa]]] for JDBC transaction
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:281)-Switching JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@6b3810aa]]] to manual commit
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund - ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 15:12:17(String), 1(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-<==    Updates: 1
// 被调用者TestTransactionalBService.addFund上增加了@Transactional(propagation = Propagation.REQUIRES_NEW)注解，执行的时候，发现调用者TestTransactionalAService.subFund已经创建了事务，因为事务传播机制为REQUIRES_NEW，所以挂起了调用者创建的事务，并自己创建了新事务，以新的事务方式运行。
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:429)-Suspending current transaction, creating new transaction with name [com.orkasgb.bigdatatools.service.TestTransactionalBService.addFund]
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:263)-Acquired Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@3c067a4f]]] for JDBC transaction
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:281)-Switching JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@3c067a4f]]] to manual commit
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund + ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 15:12:17(String), 2(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-<==    Updates: 1
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:740)-Initiating transaction commit
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:326)-Committing JDBC transaction on Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@3c067a4f]]]
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:385)-Releasing JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@3c067a4f]]] after transaction
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:1008)-Resuming suspended transaction after completion of inner transaction
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:740)-Initiating transaction commit
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:326)-Committing JDBC transaction on Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@6b3810aa]]]
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:385)-Releasing JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@6b3810aa]]] after transaction

验证（开启debug日志，查看控制台日志）：取消TestTransactionalAService.subFund上加上@Transactional注解，并在TestTransactionalBService.addFund上增加@Transactional(propagation = Propagation.REQUIRES_NEW)

(org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].java:173)-Initializing Spring DispatcherServlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:525)-Initializing Servlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:547)-Completed initialization in 10 ms
// 调用者TestTransactionalAService.subFund上没有增加@Transactional注解，所以调用者TestTransactionalAService.subFund是以非事务方式运行的
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund - ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 14:59:25(String), 1(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-<==    Updates: 1
// 被调用者TestTransactionalBService.addFund上增加了@Transactional(propagation = Propagation.REQUIRES_NEW)注解，执行的时候，发现调用者TestTransactionalAService.subFund没有创建事务，，因为事务传播机制为REQUIRES_NEW，所以自己执行时候创建了新事务，以事务方式运行。    
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:370)-Creating new transaction with name [com.orkasgb.bigdatatools.service.TestTransactionalBService.addFund]: PROPAGATION_REQUIRES_NEW,ISOLATION_DEFAULT
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:263)-Acquired Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@793d0dd7]]] for JDBC transaction
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:281)-Switching JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@793d0dd7]]] to manual commit
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund + ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 14:59:26(String), 2(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-<==    Updates: 1
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:740)-Initiating transaction commit
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:326)-Committing JDBC transaction on Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@793d0dd7]]]
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:385)-Releasing JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@793d0dd7]]] after transaction

NOT_SUPPORTED：

被调用者必须以非事务方式运行，如果调用者有事务，则被调用者将当前事务挂起，并以非事务方式运行，否则，就直接以普通方式运行。即：A方法存在事务的时候，B方法就暂停当前事务并以普通方式运行，否则，B方法直接以普通方式运行。

验证（开启debug日志，查看控制台日志）：在TestTransactionalAService.subFund上加上@Transactional注解，并在TestTransactionalBService.addFund上增加@Transactional(propagation = Propagation.NOT_SUPPORTED)

(org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].java:173)-Initializing Spring DispatcherServlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:525)-Initializing Servlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:547)-Completed initialization in 13 ms
// 调用者TestTransactionalAService.subFund上增加了@Transactional注解，执行的时候创建了一个新的事务，所以TestTransactionalAService.subFund是以事务方式运行的
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:370)-Creating new transaction with name [com.orkasgb.bigdatatools.service.TestTransactionalAService.subFund]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:263)-Acquired Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@1f421fc0]]] for JDBC transaction
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:281)-Switching JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@1f421fc0]]] to manual commit
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund - ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 15:17:29(String), 1(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-<==    Updates: 1
// 被调用者TestTransactionalBService.addFund上增加了@Transactional(propagation = Propagation.NOT_SUPPORTED)注解，执行的时候，发现调用者TestTransactionalAService.subFund已经创建了事务，因为事务传播机制为NOT_SUPPORTED，所以挂起了调用者创建的事务，并以非事务方式运行。 
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:419)-Suspending current transaction
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund + ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 15:17:29(String), 2(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-<==    Updates: 1
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:1008)-Resuming suspended transaction after completion of inner transaction
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:740)-Initiating transaction commit
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:326)-Committing JDBC transaction on Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@1f421fc0]]]
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:385)-Releasing JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@1f421fc0]]] after transaction

验证（开启debug日志，查看控制台日志）：取消TestTransactionalAService.subFund上加上@Transactional注解，并在TestTransactionalBService.addFund上增加@Transactional(propagation = Propagation.NOT_SUPPORTED)

(org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].java:173)-Initializing Spring DispatcherServlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:525)-Initializing Servlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:547)-Completed initialization in 10 ms
// 调用者TestTransactionalAService.subFund上没有增加@Transactional注解，所以调用者TestTransactionalAService.subFund是以非事务方式运行的
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund - ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 15:20:11(String), 1(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-<==    Updates: 1
// 被调用者TestTransactionalBService.addFund上增加了@Transactional(propagation = Propagation.NOT_SUPPORTED)注解，执行的时候，发现调用者TestTransactionalAService.subFund没有创建事务，因为事务传播机制为NOT_SUPPORTED，所以自己以非事务方式运行。 
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund + ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 15:20:12(String), 2(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-<==    Updates: 1

NEVER：

被调用者必须以非事务方式运行，如果调用者有事务，则被调用者直接报错，否则以普通方式运行。即：A方法存在事务的时候，B方法直接报错，否则，B方法直接以普通方式运行。

验证（开启debug日志，查看控制台日志）：在TestTransactionalAService.subFund上加上@Transactional注解，并在TestTransactionalBService.addFund上增加@Transactional(propagation = Propagation.NEVER)

(org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].java:173)-Initializing Spring DispatcherServlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:525)-Initializing Servlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:547)-Completed initialization in 10 ms
// 调用者TestTransactionalAService.subFund上增加了@Transactional注解，执行的时候创建了一个新的事务，所以TestTransactionalAService.subFund是以事务方式运行的
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:370)-Creating new transaction with name [com.orkasgb.bigdatatools.service.TestTransactionalAService.subFund]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:263)-Acquired Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@5b918ce]]] for JDBC transaction
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:281)-Switching JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@5b918ce]]] to manual commit
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund - ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 15:25:09(String), 1(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-<==    Updates: 1
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:833)-Initiating transaction rollback
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:341)-Rolling back JDBC transaction on Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@5b918ce]]]
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:385)-Releasing JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@5b918ce]]] after transaction
// 被调用者TestTransactionalBService.addFund上增加了@Transactional(propagation = Propagation.NEVER)注解，执行的时候，发现调用者TestTransactionalAService.subFund已经创建了事务，因为事务传播机制为NEVER，所以直接抛出异常，并且明确提示出 “ Existing transaction found ”    
(org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].[dispatcherServlet].java:175)-Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation 'never'] with root cause
org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation 'never'
	at org.springframework.transaction.support.AbstractPlatformTransactionManager.handleExistingTransaction(AbstractPlatformTransactionManager.java:413)

验证（开启debug日志，查看控制台日志）：取消TestTransactionalAService.subFund上加上@Transactional注解，并在TestTransactionalBService.addFund上增加@Transactional(propagation = Propagation.NEVER)

(org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].java:173)-Initializing Spring DispatcherServlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:525)-Initializing Servlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:547)-Completed initialization in 11 ms
// 调用者TestTransactionalAService.subFund上没有增加@Transactional注解，所以调用者TestTransactionalAService.subFund是以非事务方式运行的
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund - ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 15:23:11(String), 1(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-<==    Updates: 1
// 被调用者TestTransactionalBService.addFund上增加了@Transactional(propagation = Propagation.NEVER)注解，执行的时候，发现调用者TestTransactionalAService.subFund没有创建事务，因为事务传播机制为NEVER，所以自己以非事务方式运行。 
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund + ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 15:23:11(String), 2(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-<==    Updates: 1

NESTED：

如果调用者有事务，则被调用者创建一个子事务嵌套在当前事务中运行，并跟随当前事务一起提交或者回滚，如果调用者没有事务，则被调用者创建一个新事务运行，此时和REQUIRED方式一致。即：A方法存在事务的时候，B方法创建一个子事务嵌套在当前事务中运行，并跟随当前事务一起提交或者回滚，否则，B方法直接创建一个新事务运行。

验证（开启debug日志，查看控制台日志）：在TestTransactionalAService.subFund上加上@Transactional注解，并在TestTransactionalBService.addFund上增加@Transactional(propagation = Propagation.NESTED)

(org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].java:173)-Initializing Spring DispatcherServlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:525)-Initializing Servlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:547)-Completed initialization in 10 ms
// 调用者TestTransactionalAService.subFund上增加了@Transactional注解，执行的时候创建了一个新的事务，所以TestTransactionalAService.subFund是以事务方式运行的   
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:370)-Creating new transaction with name [com.orkasgb.bigdatatools.service.TestTransactionalAService.subFund]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:263)-Acquired Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@1367561]]] for JDBC transaction
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:281)-Switching JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@1367561]]] to manual commit
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund - ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 15:30:32(String), 1(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-<==    Updates: 1
// 被调用者TestTransactionalBService.addFund上增加了@Transactional(propagation = Propagation.NESTED)注解，执行的时候，发现调用者TestTransactionalAService.subFund已经创建了事务，因为事务传播机制为NESTED，所以自己创建了子事务，并以子事务方式运行。    
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:449)-Creating nested transaction with name [com.orkasgb.bigdatatools.service.TestTransactionalBService.addFund]
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund + ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 15:30:32(String), 2(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-<==    Updates: 1
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:733)-Releasing transaction savepoint
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:740)-Initiating transaction commit
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:326)-Committing JDBC transaction on Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@1367561]]]
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:385)-Releasing JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@1367561]]] after transaction

验证（开启debug日志，查看控制台日志）：取消TestTransactionalAService.subFund上加上@Transactional注解，并在TestTransactionalBService.addFund上增加@Transactional(propagation = Propagation.NESTED)

(org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/].java:173)-Initializing Spring DispatcherServlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:525)-Initializing Servlet 'dispatcherServlet'
(org.springframework.web.servlet.DispatcherServlet.java:547)-Completed initialization in 11 ms
// 调用者TestTransactionalAService.subFund上没有增加@Transactional注解，所以调用者TestTransactionalAService.subFund是以非事务方式运行的
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund - ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 15:33:54(String), 1(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalADao.subFund.java:143)-<==    Updates: 1
// 被调用者TestTransactionalBService.addFund上增加了@Transactional(propagation = Propagation.NESTED)注解，执行的时候，发现调用者TestTransactionalAService.subFund没有创建事务，因为事务传播机制为NESTED，所以自己创建了新的事务，并以事务方式运行。 
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:370)-Creating new transaction with name [com.orkasgb.bigdatatools.service.TestTransactionalBService.addFund]: PROPAGATION_NESTED,ISOLATION_DEFAULT
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:263)-Acquired Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@181e4cfe]]] for JDBC transaction
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:281)-Switching JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@181e4cfe]]] to manual commit
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==>  Preparing: UPDATE orkasgb.t_oaksgb_account SET fund=fund + ?, `time`=? WHERE id=? 
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-==> Parameters: 200.0(Double), 2022-09-30 15:33:55(String), 2(Integer)
(com.orkasgb.bigdatatools.dao.TestTransactionalBDao.addFund.java:143)-<==    Updates: 1
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:740)-Initiating transaction commit
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:326)-Committing JDBC transaction on Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@181e4cfe]]]
(org.springframework.jdbc.datasource.DataSourceTransactionManager.java:385)-Releasing JDBC Connection [ProxyConnection[PooledConnection[com.mysql.cj.jdbc.ConnectionImpl@181e4cfe]]] after transaction
夜间沐水人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring Boot：服务端实时消息推送
Java技术攻略的博客
03-21 1223
今天介绍了通过轮询方式向服务端“实时”推送消息的实现方式。这实际上是一种伪实时方式。如果要实现真正的实时通讯，需要用到其他的技术，例如 WebSocket、更高版本的 HTTP 协议等。
Spring框架 编程式事务 事务的传播行为（一）
moyuxi_的博客
11-03 523
spring编程式事务的传播行为，仅为个人理解，如有错误，请大佬指正。万分感谢
SSM面试题2：Spring支持的常用数据库事务传播属性和事务隔离级别
|张超|的博客
11-20 175
1.请简单介绍Spring支持的常用数据库事务传播属性和事务隔离级别？ 事务的属性： * 1.★propagation：用来设置事务的传播行为 * 事务的传播行为：一个方法运行在了一个开启了事务的方法中时，当前方法是使用原来的事务还是开启一个新的事务 * -Propagation.REQUIRED：默认值，使用原来的事务 * -Propagation.REQUIRES_NEW：将原来的事务挂起，开启一个新的事务...
Spring 事务和事务传播机制
最新发布
qq_63983125的博客
06-18 2918
Spring 事务和事务传播机制
Spring事务传播机制.docx
01-13
Spring 事务传播机制 Spring 事务传播机制是指在 Spring 框架中，事务的传播和嵌套机制。当我们在使用 Spring 所提供的事务功能时，如果是仅仅处理单个的事务，是比较容易把握事务的提交与回滚，不过一旦引入嵌套...
spring 事务传播 demo
06-05
本示例“spring 事务传播 demo”将聚焦于Spring的事务传播行为，这是在多个方法调用中控制事务边界的关键概念。下面我们将详细讨论相关知识点。 首先，事务传播行为是指当一个被@Transactional注解的方法被另一个@...
浅谈Spring事务传播行为实战
08-25
二、Spring事务传播机制： 1. REQUIRED：如果当前事务存在，则加入当前事务，如果当前事务不存在，则创建一个新的事务。 2. REQUIRES_NEW：总是创建一个新的事务，如果当前事务存在，则挂起当前事务。 3. SUPPORTS...
Spring事务传播属性和隔离级别详细介绍
08-29
Spring事务传播属性和隔離级别详细介绍 Spring事务传播属性（Propagation）是指在事务中如何...Spring事务传播属性和隔离级别是对事务进行管理和控制的重要机制，可以帮助开发者更好地管理事务，避免各种并发问题。
spring事务传播级别
BruceBupt的博客
08-14 199
spring有7种事务传播级别（传播行为），分别是 public enum Propagation { REQUIRED(0), SUPPORTS(1), MANDATORY(2), REQUIRES_NEW(3), NOT_SUPPORTED(4), NEVER(5), NESTED(6); } 下面3篇文章讲解了7种传播级别的含义，并通过代码演示了在外部方法有无事务时，调用不同传播级别修饰的方法，遇到异常时事务的回滚情况。还部分讲述了不同传播
idea+springboot启动报错 ERROR org.apache.catalina.core.ContainerBase
追求卓越583的博客
08-18 4341
idea+springboot启动报错 ERROR org.apache.catalina.core.ContainerBase
深入理解 Spring 事务原理【转】
weixin_30679823的博客
07-01 748
本文转自码农网– 吴极心原创 连接地址：http://www.codeceo.com/article/spring-transactions.html 一、事务的基本原理 Spring事务的本质其实就是数据库对事务的支持，没有数据库的事务支持，spring是无法提供事务功能的。对于纯JDBC操作数据库，想要用到事务，可以按照以下步骤进行： 获取连接 Connection con ...
spring的propogation(传播机制)
ForestCat的专栏
08-24 1256
pring的propagation，表示打算对这些方法怎么使用事务，是用还是不用. propagation有七种配置.  REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。  SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。  MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。  REQUIRES_NEW：新建事务，如果
事务管理中的四大特性（ACID）以及隔离级别和传播行为
吃茫茫的博客
05-29 533
文章内容来自于： http://blog.didispace.com/springboottransactional/，作者：程序员DD https://www.cnblogs.com/fjdingsd/p/5273008.html，作者：fjdingsd 文章主要用于自己学习SpringBoot，方便以后的查询 （1）原子性（Atomicity） 原子性是...
Spring Boot数据——事务
Alex_LiuC的博客
02-17 366
一、SpringBoot 事务原理 事务其实是建立在AOP的基础之上，其核心类就是 TransactionInterceptor，该类invokeWithinTransaction 方法是事务处理的核心方法，其中封装了我们创建的 DataSourceTransactionManager 对象，该对象就是执行回滚或者提交的执行单位 其实TransactionInterceptor 和我们平时标注@...
spring 的事务传播性，多操作，多尝试
技术二哥
10-26 179
一、事务的传播性 只要和数据库交互，一定会使用到事务，那么事务的传播性有哪几类。 事务种类（源码） public enum Propagation { REQUIRED(0), SUPPORTS(1), MANDATORY(2), REQUIRES_NEW(3), NOT_SUPPORTED(4), NEVER(5), NESTED(6); private final int value; private Propagation(i
事务的传播特性之@Transactional使用详解
积跬步，至千里。
06-30 3032
对@Transactional事务注解的7种事务传播机制展开详细的代码演示说明，以及对事务传播机制与事务失效场景的总结。
Spring的事务传播效果示例
绅士jiejie的博客
11-22 350
在业务中，为了保证数据的一致性，我们需要事务，不管是单体事务还是分布式事务。而在正常的开发流程中，我们控制单体的事务一般都会使用到@Transactional注解，不过很多朋友都是觉得直接加上这个注解，就能控制好事务了。但是其实Spring的事务控制也是分级别的，@Transactional这个注解里就有提供这么一个属性propagation来配合控制事务传播级别。 所以先看看属性propagation到底能够有哪几种值？ public enum Propagation { REQUIRED(0
【Spring学习34】Spring事务(4)：事务属性之7种传播行为
热门推荐
程序老兵的博客
04-20 1万+
事务传播行为什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个
spring事务传播机制
06-09
Spring事务传播机制是指在一个方法调用中，如果该方法中嵌套了其他事务方法，那么这些事务方法应该如何处理事务。Spring提供了7种不同的事务传播行为，它们分别是： 1. REQUIRED：如果当前存在事务，则加入该事务；...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

夜间沐水人

文章编写不易，一分钱也是爱。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值