@Transactional传播行为

最新推荐文章于 2024-11-04 00:29:04 发布

linshouwei.chn

最新推荐文章于 2024-11-04 00:29:04 发布

阅读量323

点赞数

文章标签： java spring spring boot

本文链接：https://blog.csdn.net/weixin_42844489/article/details/131139997

版权

在事务的应用中，传播行为（Propagation Behavior）是指一个事务方法被另一个事务方法调用时，当前事务方法如何与外部事务进行交互的规则。在Spring框架中，@Transactional注解可以指定传播行为。常用的传播行为有以下几种：

REQUIRED：如果当前存在事务，则加入该事务；否则创建一个新的事务。这是默认的传播行为。举个例子：

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
    // do something
    methodB();
    // do something else
}

@Transactional(propagation = Propagation.REQUIRED)
public void methodB() {
    // do something
}

在这种情况下，当methodA被调用时，它将启动一个新的事务，并将其传播到methodB中。由于methodB也指定了Propagation.REQUIRED传播行为，它将加入methodA的事务，而不是启动一个新的事务。

REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则挂起当前事务。举个例子：

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
    // do something
    methodB();
    // do something else
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void methodB() {
    // do something
}

在这种情况下，当methodA被调用时，它将启动一个新的事务，并将其传播到methodB中。由于methodB指定了Propagation.REQUIRES_NEW传播行为，它将启动一个新的事务，而不是使用methodA的事务。这意味着当methodB完成时，它将提交其事务，而不是回滚methodA的事务。

SUPPORTS：如果当前存在事务，则加入该事务；否则以非事务方式执行。举个例子：

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
    // do something
    methodB();
    // do something else
}

@Transactional(propagation = Propagation.SUPPORTS)
public void methodB() {
    // do something
}

在这种情况下，当methodA被调用时，它将启动一个新的事务，并将其传播到methodB中。由于methodB指定了Propagation.SUPPORTS传播行为，它将加入methodA的事务。如果methodA没有事务，则methodB将以非事务方式执行。

NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，则挂起当前事务。举个例子：

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
    // do something
    methodB();
    // do something else
}

@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void methodB() {
    // do something
}

在这种情况下，当methodA被调用时，它将启动一个新的事务，并将其传播到methodB中。由于methodB指定了Propagation.NOT_SUPPORTED传播行为，它将以非事务方式执行。如果methodA有事务，则methodB将挂起该事务。

MANDATORY：如果当前存在事务，则加入该事务；否则抛出异常。举个例子：

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
    // do something
    methodB();
    // do something else
}

@Transactional(propagation = Propagation.MANDATORY)
public void methodB() {
    // do something
}

在这种情况下，当methodA被调用时，它将启动一个新的事务，并将其传播到methodB中。由于methodB指定了Propagation.MANDATORY传播行为，它将加入methodA的事务。如果methodA没有事务，则methodB将抛出异常。

NEVER：以非事务方式执行操作，如果当前存在事务，则抛出异常。举个例子：

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
    // do something
    methodB();
    // do something else
}

@Transactional(propagation = Propagation.NEVER)
public void methodB() {
    // do something
}

在这种情况下，当methodA被调用时，它将启动一个新的事务，并将其传播到methodB中。由于methodB指定了Propagation.NEVER传播行为，它将以非事务方式执行。如果methodA有事务，则methodB将抛出异常。

NESTED：如果当前存在事务，则在嵌套事务中执行；否则创建一个新的事务。举个例子：

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
    // do something
    methodB();
    // do something else
}

@Transactional(propagation = Propagation.NESTED)
public void methodB() {
    // do something
}

在这种情况下，当methodA被调用时，它将启动一个新的事务，并将其传播到methodB中。由于methodB指定了Propagation.NESTED传播行为，它将在methodA的事务中运行，但它将作为methodA事务的嵌套事务运行。如果methodB抛出异常，则会回滚methodB的事务，但不会回滚methodA的事务。如果methodA抛出异常，则会回滚methodA和methodB的事务。