事务传播机制

//    @Transactional
    @Override
    public R test() {
        UserDomain userDomain = userService.getOne(new UserQueryDTO(){{setMobile("13203207039");}}.toQueryWrapper());
        if(ObjectUtil.isNull(userDomain)) log.debug("该用户为空！");
        ActiveDomain activeDomain = activeMapper.selectOne(new ActiveQueryDTO(){{setUserId(userDomain.getId());}}.toQueryWrapper());
        if(ObjectUtil.isNull(activeDomain)) log.debug("该用户活跃度资产为空！");

        //新增明细1
        ActiveDetailDomain activeDetailDomain = new ActiveDetailDomain();
        activeDetailDomain.setActiveId(activeDomain.getId());
        activeDetailDomain.setUserId(activeDomain.getUserId());
        activeDetailDomain.setAmount(1);
        activeDetailDomain.setNum(1);
        activeDetailDomain.setType(7);
        activeDetailDomain.setMark(1);
        activeDetailDomain.setStatusDate(LocalDateTime.now());
        activeDetailDomain.setDescription("测试新增明细1111");
        activeDetailDomain.setCreateTime(LocalDateTime.now());
        int insertResult = activeDetailMapper.insert(activeDetailDomain);
        if(insertResult<1) log.debug("新增明细1失败");

        //PROPAGATION_REQUIRED：如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，这是最常见的选择，也是Spring默认的事务传播行为。(required需要，没有新建，有加入)
        //PROPAGATION_REQUIRED
        //外围无事务，内部有事务（此处分是否处于同类），外围管不着内部
        //method A（无标注事务）使用如下调用同类当中的method B（标注事务），method B中如发生异常，method B回滚，method A无法回滚；
//        ((IActiveService) AopContext.currentProxy()).test2(activeDetailDomain);
        //method A（无标注事务）中调用同类当中的method B（标注事务），method B中如发生异常，method A B无法回滚；；
//        test2(activeDetailDomain);
        //method A（无标注事务）调用非同类当中的method B（标注事务），method B中如发生异常，method B回滚，method A无法回滚；
//        activeDetailService.test2(activeDetailDomain);

        //外围方法Propagation.REQUIRED，内部方法Propagation.REQUIRED，修饰的内部方法会加入到外围方法的事务中，内部方法和外围方法均属于同一事务，只要一个方法回滚，整个事务均回滚
        //method A（标注事务）调用非/同类当中的method B（标注事务），method B中如发生异常，method A B回滚；

        //PROPAGATION_SUPPORTS：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就以非事务执行。（supports支持，有则加入，没有就不管了，非事务运行）
        //PROPAGATION_SUPPORTS
        //支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就以非事务执行；外围方法没有开启事务，test2方法直接无事务执行
        //外围加入事务，默认Propagation.REQUIRED，内部使用Propagation.SUPPORTS，内部发现有事务，加入，外部异常，内部回滚
//        ((IActiveService) AopContext.currentProxy()).test2(activeDetailDomain);
//        activeDetailService.test2(activeDetailDomain);
//        test2(activeDetailDomain);

        //PROPAGATION_MANDATORY：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就抛出异常。（mandatory强制性，有则加入，没有异常）
        //支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就抛出异常
        //外围不存在事务
        //内部add方法使用@Transactional(propagation = Propagation.MANDATORY)
        //内部发现当前没事务，直接抛出异常（No existing transaction found for transaction marked with propagation 'mandatory'），此处分是否处于同类，如同类则不会抛出此异常
//        ((IActiveService) AopContext.currentProxy()).test2(activeDetailDomain);
//        activeDetailService.test2(activeDetailDomain);
//        test2(activeDetailDomain);

        //PROPAGATION_REQUIRES_NEW：创建新事务，无论当前存不存在事务，都创建新事务。（requires_new需要新的，不管有没有，直接创建新事务）（此处分是否处于同类）
        //PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。（not supported不支持事务，存在就挂起）
        //PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。（never不支持事务，存在就异常）异常如下：Existing transaction found for transaction marked with propagation 'never'
        //PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则按REQUIRED属性执行。（nested存在就在嵌套的执行，没有就找是否存在外面的事务，有则加入，没有则新建）
        //对事务的要求程度可以从大到小排序：mandatory / supports / required / requires_new / nested / not supported / never
        ((IActiveService) AopContext.currentProxy()).test2(activeDetailDomain);

        int a=1/0;


        test3(activeDetailDomain);

        return R.ok();
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public int test2(ActiveDetailDomain activeDetailDomain) {
        //新增明细2
        activeDetailDomain.setId(IdWorker.getId());
        activeDetailDomain.setDescription("测试新增明细2222");
        int insertResult = activeDetailMapper.insert(activeDetailDomain);
        if(insertResult<1) log.debug("新增明细2失败");

        activeDetailDomain.setId(IdWorker.getId());
        activeDetailDomain.setDescription("测试新增明细222222222222222222222");
        int insertResult2 = activeDetailMapper.insert(activeDetailDomain);
        if(insertResult2<1) log.debug("新增明细222222222失败");
        test4(activeDetailDomain);
//        int a=1/0;

        return 1;
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public int test3(ActiveDetailDomain activeDetailDomain) {
        //新增明细3
        activeDetailDomain.setId(IdWorker.getId());
        activeDetailDomain.setDescription("测试新增明细33333");
        int insertResult2 = activeDetailMapper.insert(activeDetailDomain);
        if(insertResult2<1) log.debug("新增明细3失败");
        return 1;
    }

    public int test4(ActiveDetailDomain activeDetailDomain) {
        //新增明细3
        activeDetailDomain.setId(IdWorker.getId());
        activeDetailDomain.setDescription("测试新增明细44444444");
        int insertResult2 = activeDetailMapper.insert(activeDetailDomain);
        if(insertResult2<1) log.debug("新增明细4失败");
        return 1;
    }