事务传播机制：
事务的传播行为是针对嵌套事务而言。 示例：
@Transactional(propagation = Propagation.REQUIRED)
1.REQUIRED
spring默认的事务传播行为就是它。
支持事务。如果业务方法执行时已经在一个事务中，则加入当前事务，否则重新开启一个事务。
外层事务提交了，内层才会提交。
内/外只要有报错，他俩会一起回滚。
只要内层方法报错抛出异常，即使外层有try-catch，该事务也会回滚！
因为内外层方法在同一个事务中，内层只要抛出了异常，这个事务就会被设置成rollback-only，即使外层try-catch内层的异常，该事务也会回滚。
例子：
外层方法在调用内层方法的时候包裹住try-catch，内层方法报错抛出异常。
外层方法：
@Service
public class UserServiceImp implements UserService {
@Resource
private UserMapper userMapper;
@Autowired
StudentService studentService;
@Override
@Transactional
public int addUser(User user) {
int i = userMapper.insertSelective(user);
Student student = new Student();
student.setCourse("cs");
student.setName("sid");
try {
studentService.addStudent(student);
}catch (Exception e){
//不抛出
}
return i;
}
}
内层方法：
@Service
public class StudentServiceImp implements StudentService {
@Resource
private StudentMapper studentMapper;
@Override
@Transactional//(propagation = Propagation.NESTED)
public int addStudent(Student student) {
int i = studentMapper.insertSelective(student);
int j = 10/ 0; // 内层报错抛出异常
return i;
}
}
结果：
事务回滚，user表和student表都没有插入数据。
因为内外层方法在同一个事务中，内层只要抛出了异常，这个事务就会被设置成rollback-only，即使外层try-catch内层的异常，该事务也会回滚。
报错
org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only
2.REQUIRES_NEW
支持事务。每次都是创建一个新事物，如果当前已经在事务中了，会挂起当前事务。
内层事务结束，内层就提交了，不用等着外层一起提交。
外层报错回滚，不影响内层。
内层报错回滚，外层try-catch内层的异常，外层不会回滚。
内层报错回滚，然后又会抛出异常，外层如果没有捕获处理内层抛出来的这个异常，外层还是会回滚的。这是重点！！！网上有些文章的例子给错了！！！
例子：
1.调用addStudent的外层方法有事务，外层报错回滚，内层无错
外层方法：
@Service
public class UserServiceImp implements UserService {
@Resource
private UserMapper userMapper;
@Autowired
StudentService studentService;
@Override
@Transactional
public int addUser(User user) {
int i = userMapper.insertSelective(user);
Student student = new Student();
student.setCourse("cs");
student.setName("sid");
studentService.addStudent(student);
int j = 10/ 0; // 外层报错
return i;
}
}
内层方法：
@Service
public class StudentServiceImp implements StudentService {
@Resource
private StudentMapper studentMapper;
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public int addStudent(Student student) {
int i = studentMapper.insertSelective(student);
return i;
}
}
结果：
内层的addStudent方法执行结束后，这个内层的事务就提交了，student表中就已经插入了数据了。
外层addUser方法报错，只是回滚了外层的这个事务，user表中没有插入数据。
2.调用addStudent的外层方法有事务，外层无错，内层报错回滚
外层方法：
@Service
public class UserServiceImp implements UserService {
@Resource
private UserMapper userMapper;
@Autowired
StudentService studentService;
@Override
@Transactional
public int addUser(User user) {
int i = userMapper.insertSelective(user);
Student student = new Student();
student.setCourse("cs");
student.setName("sid");
studentService.addStudent(student);
return i;
}
}
内层方法：
@Service
public class StudentServiceImp implements StudentService {
@Resource
private StudentMapper studentMapper;
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public int addStudent(Student student) {
int i = studentMapper.insertSelective(student);
int j = 10/ 0;
return i;
}
}
结果：
内层的addStudent方法执行报错 ，内层事务回滚，然后再向外抛出这个异常。student表中没有插入数据。
外层addUser，如果没有捕获处理内层抛出来的异常，外层一会回滚。user表中没有插入数据。
3.NESTED
该传播行为解释：支持事务。如果当前已经在一个事务中了，则嵌套在已有的事务中作为一个子事务。如果当前没在事务中则开启一个事务。
内层事务结束，要等着外层一起提交。
外层回滚，内层也回滚。
如果只是内层回滚，不影响外层。
这个内层回滚不影响外层的特性是有前提的，否则内外都回滚。
使用前提：
1.JDK版本要在1.4以上，有java.sql.Savepoint。因为nested就是用savepoint来实现的。
2.事务管理器的nestedTransactionAllowed属性为true。
3.外层try-catch内层的异常。
例子：
1.调用addStudent的外层方法有事务，外层报错回滚，内层无错
外层调用方法：
@Service
public class UserServiceImp implements UserService {
@Resource
private UserMapper userMapper;
@Autowired
StudentService studentService;
@Override
@Transactional
public int addUser(User user) {
int i = userMapper.insertSelective(user);
Student student = new Student();
student.setCourse("cs");
student.setName("sid");
studentService.addStudent(student);
int i1 = 10/ 0; // 外层报错回滚
return i;
}
}
内层调用方法：
@Service
public class StudentServiceImp implements StudentService {
@Resource
private StudentMapper studentMapper;
@Override
@Transactional(propagation = Propagation.NESTED)
public int addStudent(Student student) {
int i = studentMapper.insertSelective(student);
return i;
}
}
结果：
studentMapper.insertSelective(student);方法执行后，数据库student表中并没有插入数据，要等到外层addUser方法的事务结束后，才一起提交。而此时，外层报错了，回滚，student表和user表都无数据插入。
2.调用addStudent的外层方法有事务，外层无错，内层报错回滚
外层调用方法：
@Service
public class UserServiceImp implements UserService {
@Resource
private UserMapper userMapper;
@Autowired
StudentService studentService;
@Override
@Transactional
public int addUser(User user) {
int i = userMapper.insertSelective(user);
Student student = new Student();
student.setCourse("cs");
student.setName("sid");
// 强调一下，内层是nested模式下，外层要try-catch内层的异常，外层才不会回滚
// 而内层是REQUIRED模式的话，即是外层try-catch内层异常，外层同样会回滚的
try {
studentService.addStudent(student);
}catch (Exception e){
//不抛出
}
return i;
}
}
内层调用方法：
@Service
public class StudentServiceImp implements StudentService {
@Resource
private StudentMapper studentMapper;
@Override
@Transactional(propagation = Propagation.NESTED)
public int addStudent(Student student) {
int i = studentMapper.insertSelective(student);
int j = 10/ 0; // 内层报错
return i;
}
}
结果：
studentMapper.insertSelective(student);方法执行后，数据库student表中并没有插入数据，要等到外层addUser方法的事务结束后，才一起提交。而此时，自己内层报错了回滚，并不影响外层addUser方法的事务。 student表无数据插入。User表数据插入成功。
强调一下：
内层是nested模式下，外层要try-catch内层的异常，外层才不会回滚 而内层是REQUIRED模式的话，即是外层try-catch内层异常，外层同样会回滚的
4.SUPPORTS
该传播行为解释：支持事务。当前有事务就支持。当前没有事务就算了，不会开启一个事物。
例子：
1.直接从外面调这个addStudent方法，外面没有事务，这个addStudent方法的事务传播行为是SUPPORTS。
@Service
public class StudentServiceImp implements StudentService {
@Resource
private StudentMapper studentMapper;
@Override
@Transactional(propagation = Propagation.SUPPORTS)// 这个addStudent方法的事务传播行为是SUPPORTS。
public int addStudent(Student student) {
int i = studentMapper.insertSelective(student);
return i;
}
}
结果：
此时相当于addStudent方法没有事务。执行了insertSelective后，数据就已经插入到Mysql对应的student表中了。
等于说@Transactional(propagation = Propagation.SUPPORTS)修饰的方法本身是没有事务性的。
2.调用addStudent的外层方法有事务
外层调用方法：
@Service
public class UserServiceImp implements UserService {
@Resource
private UserMapper userMapper;
@Autowired
StudentService studentService;
@Override
@Transactional //有事务
public int addUser(User user) {
int i = userMapper.insertSelective(user);
Student student = new Student();
student.setCourse("cs");
student.setName("sid");
studentService.addStudent(student);// 调用addStudent方法，addStudent方法的事务传播机制是SUPPORTS
return i;
}
}
内层传播机制为SUPPORTS的方法：强调，外层方法和内层方法不在同一个类中
@Service
public class StudentServiceImp implements StudentService {
@Resource
private StudentMapper studentMapper;
@Override
@Transactional(propagation = Propagation.SUPPORTS) // 这个addStudent方法的事务传播行为是SUPPORTS
public int addStudent(Student student) {
int i = studentMapper.insertSelective(student);
return i;
}
}
结果：
studentMapper.insertSelective(student);方法执行后，数据库student表中并没有插入数据，要等到外层addUser方法的事务结束后，才一起提交。
5.MANDATORY
该传播行为解释：支持事务，如果业务方法执行时已经在一个事务中，则加入当前事务。否则抛出异常。
例子：
1.直接从外面调这个addStudent方法，外面没有事务
@Service
public class StudentServiceImp implements StudentService {
@Resource
private StudentMapper studentMapper;
@Override
@Transactional(propagation = Propagation.MANDATORY)
public int addStudent(Student student) {
int i = studentMapper.insertSelective(student);
return i;
}
}
结果：抛出异常
org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory' 2.调用addStudent的外层方法有事务
外层调用方法：
@Service
public class UserServiceImp implements UserService {
@Resource
private UserMapper userMapper;
@Autowired
StudentService studentService;
@Override
@Transactional //有事务
public int addUser(User user) {
int i = userMapper.insertSelective(user);
Student student = new Student();
student.setCourse("cs");
student.setName("sid");
studentService.addStudent(student);// 调用addStudent方法
return i;
}
}
内层方法：
@Service
public class StudentServiceImp implements StudentService {
@Resource
private StudentMapper studentMapper;
@Override
@Transactional(propagation = Propagation.MANDATORY)
public int addStudent(Student student) {
int i = studentMapper.insertSelective(student);
return i;
}
}
结果：
studentMapper.insertSelective(student);方法执行后，数据库student表中并没有插入数据，要等到外层addUser方法的事务结束后，才一起提交。
6.NOT_SUPPORTED
不支持事务，如果业务方法执行时已经在一个事务中，则挂起当前事务，等方法执行完毕后，事务恢复进行。
例子：
1.调用addStudent的外层方法有事务
外层调用方法：
@Service
public class UserServiceImp implements UserService {
@Resource
private UserMapper userMapper;
@Autowired
StudentService studentService;
@Override
@Transactional
public int addUser(User user) {
int i = userMapper.insertSelective(user);
Student student = new Student();
student.setCourse("cs");
student.setName("sid");
studentService.addStudent(student);
return i;
}
}
内层调用方法：
@Service
public class StudentServiceImp implements StudentService {
@Resource
private StudentMapper studentMapper;
@Override
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public int addStudent(Student student) {
int i = studentMapper.insertSelective(student);
return i;
}
}
结果：
studentMapper.insertSelective(student);方法执行后，数据库student表中已经插入了数据，不用等到自己的addStudent方法的事务结束后才提交。
7.NEVER
不支持事务。如果当前已经在一个事务中了，抛出异常。
例子：
1.调用addStudent的外层方法有事务
外层调用方法：
@Service
public class UserServiceImp implements UserService {
@Resource
private UserMapper userMapper;
@Autowired
StudentService studentService;
@Override
@Transactional
public int addUser(User user) {
int i = userMapper.insertSelective(user);
Student student = new Student();
student.setCourse("cs");
student.setName("sid");
studentService.addStudent(student);
return i;
}
}
内层调用方法：
@Service
public class StudentServiceImp implements StudentService {
@Resource
private StudentMapper studentMapper;
@Override
@Transactional(propagation = Propagation.NEVER)
public int addStudent(Student student) {
int i = studentMapper.insertSelective(student);
return i;
}
}
结果：
外层addUser方法在调内层方法addStudent的时候，因为内层方法不支持事务，而外层方法开启了事务，则报错
org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation 'never'
tail -f xxx.log 查看最后几行数据，并且将命令行阻塞
tail -n 500 xxx.log 查看最后500行数据
cat xxx.log 查看所有的数据
|grep 关键字 搜索相关关键字数据
