JAVA事务二

场景四：

主调用方 没有事务，副调用方 REQUIRES_NEW

  //@Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void testPropagationTrans() {
        stuService.saveParent();

        stuService.saveChildren();

副调用方：

    public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }

只有parent插入了数据库。

主调用方加上 

@Transactional(propagation = Propagation.REQUIRED)

两个都没有插入数据库。

结论：

REQUIRES_NEW: 如果当前有事务，则挂起该事务，并且自己创建一个新的事务给自己使用；
     *                    如果当前没有事务，则同 REQUIRED
     *                    举例：领导有饭吃，我偏不要，我自己买了自己吃

场景五：

  @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void testPropagationTrans() {
        stuService.saveParent();

        stuService.saveChildren();

    public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }

child-1 插入了数据库，parent没有插入数据库。

结论：主要也是用于查询语句场景。

     *      NOT_SUPPORTED: 如果当前有事务，则把事务挂起，自己不适用事务去运行数据库操作
     *                     举例：领导有饭吃，分一点给你，我太忙了，放一边，我不吃

如果主调用方去掉

@Transactional(propagation = Propagation.REQUIRED)

两个都插入了数据库。

场景六：

主调用方有事务

  @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void testPropagationTrans() {
        stuService.saveParent();

        stuService.saveChildren();

被调用方：

   public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
    @Transactional(propagation = Propagation.NEVER)
    public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }

报错了。
Existing transaction found for transaction marked with propagation 'never'

主导用法去掉

 @Transactional(propagation = Propagation.REQUIRED)

两个都插入了数据库。parent和children1 。类似not support

结论：

   *      NEVER: 如果当前有事务存在，则抛出异常
     *             举例：领导有饭给你吃，我不想吃，我热爱工作，我抛出异常

场景七：

    NESTED: 如果当前有事务，则开启子事务（嵌套事务），嵌套事务是独立提交或者回滚；
*              如果当前没有事务，则同 REQUIRED。

下面以有事务来讲解。

但是如果主事务提交，则会携带子事务一起提交。
*              如果主事务回滚，则子事务会一起回滚。相反，子事务异常，则父事务可以回滚或不回滚。
*              举例：领导决策不对，老板怪罪，领导带着小弟一同受罪。小弟出了差错，领导可以推卸责任。

  @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void testPropagationTrans() {
        stuService.saveParent();

        stuService.saveChildren();
      int a = 1 / 0;

    public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
    @Transactional(propagation = Propagation.NESTED)
    public void saveChildren() {
        saveChild1();
       // int a = 1 / 0;
        saveChild2();
    }

不会有数据。主事务发生异常，子事务跟着一起回滚。

注意：上面的 1/0 在主方法里面了，不是副方法里面。

如果把副调用方里面修改为 

@Transactional(propagation = Propagation.REQUIRES_NEW)

    public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void saveChildren() {
        saveChild1();
       // int a = 1 / 0;
        saveChild2();
    }

1267    child-1    11
1268    child-2    22

都插入了数据库。

------------------------------------------

另外场景：子事务异常，则父事务可以回滚或不回滚。用try cath

     *              如果主事务回滚，则子事务会一起回滚。相反，子事务异常，则父事务可以回滚或不回滚。
     *              举例：领导决策不对，老板怪罪，领导带着小弟一同受罪。小弟出了差错，领导可以推卸责任。

开放1/0

    public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
    @Transactional(propagation = Propagation.NESTED)
    public void saveChildren() {
        saveChild1();
       int a = 1 / 0;
        saveChild2();
    }

主调用方：

  @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void testPropagationTrans() {
        stuService.saveParent();

        stuService.saveChildren();
      int a = 1 / 0;

结果，两个都没有插入数据库。

如果主调用方用try cath

  @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void testPropagationTrans() {
        stuService.saveParent();

 /*       stuService.saveChildren();
      int a = 1 / 0;*/


        try {
            // save point
            stuService.saveChildren();
        } catch (Exception e) {
            e.printStackTrace();
        }

只有1271    parent    19插入了数据库。