事务

业务逻辑上的一组操作，要么全部成功，要么全部失败，比如下面的伪代码:

public class MyService {//外界调用public void doService(){//A逻辑serviceA();//B逻辑serviceB();//C逻辑serviceC();//其他otherService();}
}

当外界调用doService方法，该方法里面的各个子逻辑单元，要么全部成功，要么全部失败

事务转账场景分析(事务的传播行为)

事务传播行为:同一个类中相互调用

同一个类AClass中，有两个函数aFunction、aInnerFunction。aFunction调用aInnerFunction。而且aFunction函数会被外部调用。

情况1: aFunction添加了@Transactional注解，aInnerFunction函数没有添加。aInnerFunction抛异常。
结果:两个方法都回滚，aInnerFunction依附在aFunction事务，aInnerFunction抛异常也间接等于aFunction抛异常

public class AClass {@Transactional(rollbackFor = Exception.class)public void aFunction() {//todo: 数据库操作A(增，删，该)aInnerFunction(); // 调用内部没有添加@Transactional注解的函数}private void aInnerFunction() {//todo: 操作数据B(做了增，删，改 操作)throw new RuntimeException("函数执行有异常!");}
}

情况2:两个函数都添加了@Transactional注解。aInnerFunction抛异常。
结果:同第一种情况一样，两个函数对数据库操作都会回滚。因为同一个类中函数相互调用的时候，内部函数添加@Transactional注解无效,也会依附于外部调用的方法事务。@Transactional注解只有外部调用才有效。

public class AClass {@Transactional(rollbackFor = Exception.class)public void aFunction() {//todo: 数据库操作A(增，删，该)aInnerFunction(); // 调用内部添加@Transactional注解的函数}@Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)private void aInnerFunction() {//todo: 操作数据B(做了增，删，改 操作)throw new RuntimeException("函数执行有异常!");}
}

情况3: aFunction不添加注解，aInnerFunction添加注解。aInnerFunction抛异常。
结果:两个函数对数据库的操作都不会回滚。因为内部函数@Transactional注解添加和没添加一样(内部函数添加@Transactional注解无效),两个方法都没事务

public class AClass {public void aFunction() {//todo: 数据库操作A(增，删，该)aInnerFunction(); // 调用内部添加@Transactional注解的函数}@Transactional(rollbackFor = Exception.class)protected void aInnerFunction() {//todo: 操作数据B(做了增，删，改 操作)throw new RuntimeException("函数执行有异常!");}
}

情况4:aFunction添加了@Transactional注解，aInnerFunction函数没有添加。aInnerFunction抛异常，不过在aFunction里面把异常抓出来了。aFunction能够正常往下执行，并没有抛出异常
结果:两个函数里面的数据库操作都成功。事务回滚的动作发生在当有@Transactional注解函数有对应异常抛出时才会回滚。
如果此时aFunction显示抛出异常，就会整体回滚

public class AClass {@Transactional(rollbackFor = Exception.class)public void aFunction() {//todo: 数据库操作A(增，删，该)try {aInnerFunction(); // 调用内部没有添加@Transactional注解的函数} catch (Exception e) {e.printStackTrace();}}private void aInnerFunction() {//todo: 操作数据B(做了增，删，改 操作)throw new RuntimeException("函数执行有异常!");}}

事务传播行为:不同类中函数相互调用

两个类AClass、BClass。AClass类有aFunction、BClass类有bFunction。AClass类aFunction调用BClass类bFunction。最终会在外部调用AClass类的aFunction。

情况1：aFunction添加注解，bFunction不添加注解。bFunction抛异常。
结果:两个方法都会回滚，可类比在同类中相互调用的情况1

//类AClass 
@Service("aClass")
public class AClass {@Autowiredprivate AccountMapperImpl accountMapper;@Autowiredprivate BClass bClass;@Transactionalpublic void aFunction(){accountMapper.addMoney();bClass.bFunction();}
}//类BClass
@Service("bClass")
public class BClass {@Autowiredprivate AccountMapperImpl accountMapper ;public void bFunction(){accountMapper.reduceMoney();throw new RuntimeException("bFunction函数方法调用异常");}
}

情况2：aFunction、bFunction两个函数都添加注解，bFunction抛异常。
结果:两个函数对数据库的操作都回滚了。两个函数里面用的还是同一个事务。这种情况下，你可以认为事务rollback了两次。
两个函数都有异常。

//类AClass 
@Service("aClass")
public class AClass {@Autowiredprivate AccountMapperImpl accountMapper;@Autowiredprivate BClass bClass;@Transactionalpublic void aFunction(){accountMapper.addMoney();bClass.bFunction();}
}//类BClass
@Service("bClass")
public class BClass {@Autowiredprivate AccountMapperImpl accountMapper ;@Transactionalpublic void bFunction(){accountMapper.reduceMoney();throw new RuntimeException("bFunction函数方法调用异常");}
}

情况3:aFunctio不添加注解、bFunction添加注解，bFunction抛异常。
结果:aFunctio方法不回滚，bFunction方法回滚，当前只存在bFunction方法的事务

//类AClass 
@Service("aClass")
public class AClass {@Autowiredprivate AccountMapperImpl accountMapper;@Autowiredprivate BClass bClass;public void aFunction(){accountMapper.addMoney();bClass.bFunction();}
}//类BClass
@Service("bClass")
public class BClass {@Autowiredprivate AccountMapperImpl accountMapper ;@Transactionalpublic void bFunction(){accountMapper.reduceMoney();throw new RuntimeException("bFunction函数方法调用异常");}
}

情况4:aFunction、bFunction两个函数都添加注解，bFunction抛异常。aFunction抓出异常。
结果:两个方法执行不成功，还抛出了org.springframework.transaction.UnexpectedRollbackException: 
Transaction rolled back because it has been marked as rollback-only，两个方法处于同一事务，但是bFunction抛出异常，调了事务的rollback函数。
事务被标记了只能rollback了，程序继续执行，aFunction函数里面把异常给抓出来了，
这个时候aFunction函数没有抛出异常，既然你没有异常那事务就需要提交，会调事务的commit函数。
而之前已经标记了事务只能rollback-only(以为是同一个事务)。直接就抛异常了，不让调了。综上，两个方法都会回滚

//类AClass 
@Service("aClass")
public class AClass {@Autowiredprivate AccountMapperImpl accountMapper;@Autowiredprivate BClass bClass;@Transactionalpublic void aFunction(){accountMapper.addMoney();try {bClass.bFunction();} catch (Exception e) {e.printStackTrace();}}
}//类BClass
@Service("bClass")
public class BClass {@Autowiredprivate AccountMapperImpl accountMapper ;@Transactionalpublic void bFunction(){accountMapper.reduceMoney();throw new RuntimeException("bFunction函数方法调用异常");}
}

情况5:aFunction、bFunction两个函数都添加注解，bFunction抛异常。aFunction抓出异常。
这里要注意bFunction函数@Transactional注解我们是有变化的，加了一个参数
propagation = Propagation.REQUIRES_NEW，控制事务的传播行为。表明是一个新的事务。
结果:bFunction函数里面的操作回滚了，aFunction里面的操作成功了。因为两者不是在同一个事务中了

//类AClass 
@Service("aClass")
public class AClass {@Autowiredprivate AccountMapperImpl accountMapper;@Autowiredprivate BClass bClass;@Transactionalpublic void aFunction(){//accountMapper.addMoney();如果当前存在事务写操作，会引起当前事务的挂起try {bClass.bFunction();} catch (Exception e) {e.printStackTrace();}}
}//类BClass
@Service("bClass")
public class BClass {@Autowiredprivate AccountMapperImpl accountMapper ;@Transactional(propagation = Propagation.REQUIRES_NEW,rollbackFor = Exception.class)public void bFunction(){accountMapper.reduceMoney();throw new RuntimeException("bFunction函数方法调用异常");}
}

总结

Spring事务实际业务场景应该就是以上总结，首先要弄清楚事务注解中的各个属性，然后判断是在同一个类中方法相互调用呢还是不同类的方法调用，特别要注意事务失效的各个场景。