1.required属性

TransactionDefinition.PROPAGATION_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认值。

public void addParent() {
    User user = new User();
    user.setName("parent");
    user.setAge(1);
    userDao.save(user);
}

public void addChildren1() {
    User user = new User();
    user.setName("children1");
    user.setAge(1);
    userDao.save(user);
}

public void addChildren2() {
    User user = new User();
    user.setName("children2");
    user.setAge(1);
    userDao.save(user);
}
@Transactional ---》a
public void addChildren() {
    addChildren1();
    int a = 2 / 0;
    addChildren2();
}

 //这个方法一定不能和addChildren在同一个类中，否则会失效
@Transactional ---》b
public void save() {
    addParent();
    addChildren();
}
b生效，a不生效时，执行save方法后，因为事务的传播，所以addParent和addChildren都会回滚，所以数据库中无数据
a生效，b不生效时，执行save方法后，因为事务的传播，只有addChildren会回滚，所以数据库中只有parent的数据
a生效，b生效时，执行save方法后，因为事务的传播，所以addParent和addChildren都会回滚，所以数据库中无数据

2. supports属性

TransactionDefinition.PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。

public void addParent() {
    User user = new User();
    user.setName("parent");
    user.setAge(1);
    userDao.save(user);
}

public void addChildren1() {
    User user = new User();
    user.setName("children1");
    user.setAge(1);
    userDao.save(user);
}

public void addChildren2() {
    User user = new User();
    user.setName("children2");
    user.setAge(1);
    userDao.save(user);
}

@Transactional(propagation = Propagation.SUPPORTS )===》a
public void addChildren() {
    addChildren1();
    int a = 2 / 0;
    addChildren2();
}

//这个方法一定不能和addChildren在同一个类中，否则会失效
@Transactional======>b
public void save() {
    addParent();
    addChildren();
}
若a单独存在，则没有事务，数据库存在两个值，如a和b同时存在，而且b的事务为默认，则数据库中无数据

3.MANDATORY

TransactionDefinition.PROPAGATION_MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。

4.REQUIRES_NEW

TransactionDefinition.PROPAGATION_REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。

 public void addParent() {
    User user = new User();
    user.setName("parent");
    user.setAge(1);
    userDao.save(user);
  }

public void addChildren1() {
    User user = new User();
    user.setName("children1");
    user.setAge(1);
    userDao.save(user);
}

public void addChildren2() {
    User user = new User();
    user.setName("children2");
    user.setAge(1);
    userDao.save(user);
}

@Transactional(propagation = Propagation.REQUIRES_NEW )===》a
public void addChildren() {
    addChildren1();
    int a = 2 / 0;
    addChildren2();
}

 //这个方法一定不能和addChildren在同一个类中，否则会失效
@Transactional======>b
public void save() {
    addParent();
    addChildren();
}
a和b同时存在，效果和required类似

public void addParent() {
    User user = new User();
    user.setName("parent");
    user.setAge(1);
    userDao.save(user);
  }

public void addChildren1() {
    User user = new User();
    user.setName("children1");
    user.setAge(1);
    userDao.save(user);
}

public void addChildren2() {
    User user = new User();
    user.setName("children2");
    user.setAge(1);
    userDao.save(user);
}

@Transactional(propagation = Propagation.REQUIRES_NEW )===》a
public void addChildren() {
    addChildren1();
    addChildren2();
}

//这个方法一定不能和addChildren在同一个类中，否则会失效
@Transactional======>b
public void save() {
    addParent();
    addChildren();
    int a=2/0;
}
a和b同时存在，数据库中会有两条children的值，parent中没有值

TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。 TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。 TransactionDefinition.PROPAGATION_NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。

 *      REQUIRED: 使用当前的事务，如果当前没有事务，则自己新建一个事务，子方法是必须运行在一个事务中的；
 *                如果当前存在事务，则加入这个事务，成为一个整体。
 *                举例：领导没饭吃，我有钱，我会自己买了自己吃；领导有的吃，会分给你一起吃。
 *      SUPPORTS: 如果当前有事务，则使用事务；如果当前没有事务，则不使用事务。
 *                举例：领导没饭吃，我也没饭吃；领导有饭吃，我也有饭吃。
 *      MANDATORY: 该传播属性强制必须存在一个事务，如果不存在，则抛出异常
 *                 举例：领导必须管饭，不管饭没饭吃，我就不乐意了，就不干了（抛出异常）
 *      REQUIRES_NEW: 如果当前有事务，则挂起该事务，并且自己创建一个新的事务给自己使用；
 *                    如果当前没有事务，则同 REQUIRED
 *                    举例：领导有饭吃，我偏不要，我自己买了自己吃
 *      NOT_SUPPORTED: 如果当前有事务，则把事务挂起，自己不适用事务去运行数据库操作
 *                     举例：领导有饭吃，分一点给你，我太忙了，放一边，我不吃
 *      NEVER: 如果当前有事务存在，则抛出异常
 *             举例：领导有饭给你吃，我不想吃，我热爱工作，我抛出异常
 *      NESTED: 如果当前有事务，则开启子事务（嵌套事务），嵌套事务是独立提交或者回滚；
 *              如果当前没有事务，则同 REQUIRED。
 *              但是如果主事务提交，则会携带子事务一起提交。
 *              如果主事务回滚，则子事务会一起回滚。相反，子事务异常，则父事务可以回滚或不回滚。
 *              举例：领导决策不对，老板怪罪，领导带着小弟一同受罪。小弟出了差错，领导可以推卸责任。