Spring事务的传播行为（Propagation Behavior）

Spring事务的传播行为（Propagation Behavior）描述了在多个事务之间如何进行协调和交互。它定义了在一个事务方法被另一个事务方法调用时，事务应该如何传播。在Spring中，传播行为被定义为一组预定义的值，这些值描述了事务在方法调用链中的行为。

以下是Spring支持的事务传播行为的类型：

• PROPAGATION_REQUIRED（默认）：如果当前存在事务，那么就加入这个事务，并执行该事务。如果当前没有事务，就创建一个新的事务。
• PROPAGATION_SUPPORTS：如果当前存在事务，那么就加入这个事务，并执行该事务。如果当前没有事务，就以非事务的方式继续运行。
• PROPAGATION_MANDATORY：如果当前存在事务，那么就加入这个事务，并执行该事务。如果当前没有事务，就抛出异常。
• PROPAGATION_REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。
• PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
• PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。
• PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，就创建一个新的事务。

这些传播行为可以帮助你更好地控制和管理你的事务。例如，如果你希望在某个特定的方法调用时总是开启新的事务，你可以将该方法的事务传播行为设置为PROPAGATION_REQUIRES_NEW。同样，如果你希望在某些情况下以非事务方式运行代码，你可以将该代码块的事务传播行为设置为PROPAGATION_NOT_SUPPORTED。

以下是几个Spring事务传播行为的例子：

1. PROPAGATION_REQUIRED 例子：
   假设我们有一个ServiceA，它调用另一个ServiceB的方法。如果ServiceB方法需要一个事务，那么我们可以将ServiceA的事务传播行为设置为PROPAGATION_REQUIRED。这样，当ServiceA调用ServiceB方法时，如果存在事务，ServiceB方法就会加入该事务；如果不存在事务，Spring会创建一个新的事务。

@Service  
public class ServiceA {  
    @Autowired  
    private ServiceB serviceB;  
  
    @Transactional(propagation = Propagation.REQUIRED)  
    public void methodA() {  
        serviceB.methodB();  
    }  
}

2. PROPAGATION_SUPPORTS例子：
   假设我们有一个ServiceA，它调用另一个ServiceB的方法。如果ServiceB方法不需要事务，那么我们可以将ServiceB方法的事务传播行为设置为PROPAGATION_SUPPORTS。这样，如果存在事务，ServiceB方法就会加入该事务；如果没有事务，ServiceB方法将以非事务的方式执行。

@Service  
public class ServiceB {  
    @Transactional(propagation = Propagation.SUPPORTS)  
    public void methodB() {  
        // 该方法将以非事务方式执行，如果存在事务，就加入该事务  
    }  
}

3. PROPAGATION_MANDATORY例子：
   假设我们有一个ServiceA，它调用另一个ServiceB的方法。如果ServiceB方法需要一个事务，而且它应该在自己的事务中执行，那么我们可以将ServiceB方法的事务传播行为设置为PROPAGATION_MANDATORY。这样，如果存在事务，ServiceB方法就会加入该事务；如果没有事务，ServiceB方法就会抛出异常。

@Service  
public class ServiceB {  
    @Transactional(propagation = Propagation.MANDATORY)  
    public void methodB() {  
        // 该方法必须在一个事务中执行，如果没有事务，就会抛出异常  
    }  
}

4. PROPAGATION_REQUIRES_NEW例子：
   假设我们有一个ServiceA，它调用另一个ServiceB的方法。如果ServiceB方法需要一个新的事务，而且它不应该影响ServiceA的事务，那么我们可以将ServiceB方法的事务传播行为设置为PROPAGATION_REQUIRES_NEW。这样，当ServiceA调用ServiceB方法时，Spring会创建一个新的事务，并将当前的事务挂起。

@Service  
public class ServiceB {  
    @Transactional(propagation = Propagation.REQUIRES_NEW)  
    public void methodB() {  
        // 该方法将创建一个新的事务，并挂起当前事务  
    }  
}

5. PROPAGATION_NOT_SUPPORTED例子：
   假设我们有一个ServiceA，它调用另一个ServiceB的方法。如果ServiceB方法不需要事务，而且它不应该影响正在执行的事务，那么我们可以将ServiceB方法的事务传播行为设置为PROPAGATION_NOT_SUPPORTED。这样，当ServiceA调用ServiceB方法时，如果存在事务，就把当前事务挂起，然后以非事务方式执行ServiceB方法。

@Service  
public class ServiceB {  
    @Transactional(propagation = Propagation.NOT_SUPPORTED)  
    public void methodB() {  
        // 该方法以非事务方式执行，如果存在事务，就把当前事务挂起  
    }  
}

6. PROPAGATION_NEVER例子：
   假设我们有一个ServiceA，它调用另一个ServiceB的方法。如果ServiceB方法不应该在任何事务中执行，那么我们可以将ServiceB方法的事务传播行为设置为PROPAGATION_NEVER。这样，当ServiceA调用ServiceB方法时，如果存在事务，就抛出异常；如果没有事务，就以非事务方式执行。

@Service  
public class ServiceB {  
    @Transactional(propagation = Propagation.NEVER)  
    public void methodB() {  
        // 该方法以非事务方式执行，如果存在事务，就抛出异常  
    }  
}

7. PROPAGATION_NESTED例子：
   假设我们有一个ServiceA，它已经在一个事务中。然后，它调用另一个ServiceB的方法。如果ServiceB方法需要一个嵌套事务，而且它应该与ServiceA的事务共享数据，那么我们可以将ServiceB方法的事务传播行为设置为PROPAGATION_NESTED。这样，当ServiceA调用ServiceB方法时，Spring会在嵌套事务内执行。

@Service  
public class ServiceA {  
    @Autowired  
    private ServiceB serviceB;  
  
    @Transactional(propagation = Propagation.NESTED)  
    public void methodA() {  
        serviceB.methodB();  
    }  
}

在Spring中，serviceA是否有事务主要取决于两点：

• @Transactional注解：如果在serviceA类上添加了@Transactional注解，那么该类中的所有方法都将具有事务。
• 方法上的@Transactional注解：如果在serviceA类中的某个方法上添加了@Transactional注解，那么只有这个方法具有事务。

如果没有上述的任何一种情况，那么默认情况下，serviceA将不会有事务。

需要注意的是，事务传播是在方法调用时发生的，因此在一个事务中的方法调用另一个没有事务的方法时，将会根据@Transactional注解的设置来决定是否创建新的事务。如果被调用的方法有@Transactional注解，并且其传播属性设置为PROPAGATION_REQUIRED或更高，那么调用该方法的方法将在一个新的事务中执行。如果被调用的方法没有事务，那么调用该方法的方法将在其自身的事务中执行。

假设我们有一个ServiceA，它有两个方法：methodA()和methodB()

1. 在ServiceA类上添加@Transactional注解：

@Service  
@Transactional  
public class ServiceA {  
    // methodA() and methodB()  
}

这意味着ServiceA类中的所有方法都将具有事务。因此，当调用methodA()或methodB()时，它们将在事务中执行。

2. 在ServiceA类中的某个方法上添加@Transactional注解：

@Service  
public class ServiceA {  
      
    @Transactional  
    public void methodA() {  
        // 该方法将在事务中执行  
    }  
      
    public void methodB() {  
        // 该方法默认情况下不在事务中执行  
    }  
}

在这种情况下，只有methodA()具有事务。因此，当调用methodA()时，它将在事务中执行。但是，调用methodB()时，它默认情况下不在事务中执行。

需要注意的是，事务传播是在方法调用时发生的。在一个事务中的方法调用另一个没有事务的方法时，将会根据@Transactional注解的设置来决定是否创建新的事务。例如，如果methodA()在一个事务中调用methodB()，而methodB()没有事务，那么根据@Transactional注解的设置，methodB()将在自己的事务中执行，或者与methodA()的事务共享数据（如果@Transactional注解的传播属性设置为PROPAGATION_NESTED）。

methodA()调用methodB()时，如何让methodB()以非事务执行

要让methodB()以非事务执行，可以通过设置@Transactional注解的propagation属性为Propagation.NON_TRANSACTIONAL来实现。这样，当methodA()调用methodB()时，methodB()将以非事务方式执行。

@Service  
public class ServiceA {  
  
    @Transactional  
    public void methodA() {  
        methodB();  
    }  
  
    @Transactional(propagation = Propagation.NON_TRANSACTIONAL)  
    public void methodB() {  
        // 该方法将以非事务方式执行  
    }  
}

在上面的代码中，methodA()是一个有事务的方法，而methodB()的@Transactional注解将传播属性设置为Propagation.NON_TRANSACTIONAL，表示它将以非事务方式执行。因此，当methodA()调用methodB()时，methodB()将以非事务方式执行。