Spring事务传播机制详解和 @Transactional 失效情况原因及解决方法

已于 2023-01-14 17:07:33 修改
阅读量1.3k 收藏 13
点赞数 3
文章标签： spring java 后端
于 2022-12-03 21:30:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lendsomething/article/details/128166806
版权

视频出处：https://www.bilibili.com/video/BV1te4y1J7Qd/?vd_source=44d1426ea434f76dfe83b4aa384fb2fa

1、什么是事务传播机制

事务的传播，是A方法调用B方法并将事务传递给它。事务的转播机制主要针对被调用者而言，控制它是否被传播或者被怎样传播。spring事务的传播机制有七种：

传播行为描述
PROPAGATION_REQUIRED默认的Spring事物传播级别，若当前存在事务，则加入该事务，若不存在事务，则新建一个事务
PROPAGATION_REQUIRE_NEW若当前没有事务，则新建一个事务。若当前存在事务，则新建一个事务，新老事务相互独立。外部事务抛出异常回滚不会影响内部事务的正常提交
PROPAGATION_NESTED如果当前存在事务，则嵌套在当前事务中执行。如果当前没有事务， 则新建一个事务，类似于REQUIRE_NEW
PROPAGATION_SUPPORTS支持当前事务，若当前不存在事务，以非事务的方式执行
PROPAGATION_NOT_SUPPORTED以非事务的方式执行，若当前存在事务，则把当前事务挂起
PROPAGATION_MANDATORY强制事务执行，若当前不存在事务，则抛出异常
PROPAGATION_NEVER以非事务的方式执行，如果当前存在事务，则抛出异常

传播级别一般不需要定义，默认就是PROPAGATION_REQUIRED，除非在嵌套事务的情况。上述描述表格的描述还是比较抽象，下面我们使用一个例子来说明这个传播机制。假定方法A调用方法B：

方法B定义的事务类型A方法有事务时A方法无事务
@Transactional(propagation = Propagation.REQUIRED)B和A事务合并成一个事务B新建一个事务
@Transactional(propagation = Propagation.REQUIRES_NEW)B新建一个事务，和A事务无关，互不影响（A回滚不会影响到B的提交）B新建一个事务
@Transactional(propagation = Propagation.NESTED)B新建一个A的子事务，A回滚会导致B已经提交的事务一起回滚；B回滚不会影响到AB新建一个事务
@Transactional(propagation = Propagation.SUPPORTS)B加入到A事务中B无事务
@Transactional(propagation = Propagation.NOT_SUPPORTED)挂起A事务，B以无事务方式执行B无事务
@Transactional(propagation = Propagation.MANDATORY)B加入到A事务中B抛异常
@Transactional(propagation = Propagation.NEVER)B抛异常B无事务

2、七种事务传播机制

现在在这里，我们假定方法A 是 StudentService类中的方法，方法B是CourseService类中的方法

2.1、@Transactional(propagation = Propagation.REQUIRED)

A中没有事务，B中有事务


@Service
public class StudentService {


    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private CourseService courseService;



    //这里没有开启事务，courseService.insertCourse会自己开启一个事务运行
    //而且两个添加操作都会成功，因为studentMapper.insert(student);是自动提交的
    public void insert0(){

        courseService.insertCourse();

        Student student = new Student();
        student.setId(1);
        student.setName("student_"+ System.currentTimeMillis());
        studentMapper.insert(student);


        int i = 1/0;//这里抛出异常，两个添加操作都不会回滚
    }

}


@Service
public class CourseService {

    @Autowired
    private CourseMapper courseMapper;


    @Transactional(propagation = Propagation.REQUIRED)
    public void insertCourse(){
        Course course = new Course();
        course.setId(1);
        course.setName("course_"+  System.currentTimeMillis());
        courseMapper.insert(course);

    }
}

A和B两个方法都有事务

@Service
public class StudentService {


    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private CourseService courseService;



    //两个方法都使用了@Transactional(propagation = Propagation.REQUIRED)
    //courseService.insertCourse()会加入到insert0方法开启的事务中，所以两个方法在同一事务中
    @Transactional(propagation = Propagation.REQUIRED)
    public void insert0(){

        courseService.insertCourse();

        Student student = new Student();
        student.setId(1);
        student.setName("student_"+ System.currentTimeMillis());
        studentMapper.insert(student);


        int i = 1/0;//这里抛出异常，两个添加操作都被回滚
    }
    
}


@Service
public class CourseService {

    @Autowired
    private CourseMapper courseMapper;


    @Transactional(propagation = Propagation.REQUIRED)
    public void insertCourse(){
        Course course = new Course();
        course.setId(1);
        course.setName("course_"+  System.currentTimeMillis());
        courseMapper.insert(course);

    }
}

2.2、@Transactional(propagation = Propagation.REQUIRES_NEW)

在A方法的事务中抛出异常，B方法正确执行，正常提交

@Service
public class StudentService {


    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private CourseService courseService;



    //courseService.insertCourse()方法用了@Transactional(propagation = Propagation.REQUIRES_NEW)
    //开启了一个独立的新的事务，在独立的事务中运行，
    // 并且insert0()开启的事务被挂起
    //等courseService.insertCourse()运行完毕，再恢复insert0()的事务
    //两个事务的提交和回滚都在各自事务中完成
    @Transactional(propagation = Propagation.REQUIRED)
    public void insert0(){

        courseService.insertCourse();

        Student student = new Student();
        student.setId(1);
        student.setName("student_"+ System.currentTimeMillis());
        studentMapper.insert(student);


        //这里抛出异常，courseService.insertCourse()不会回滚
        //但是studentMapper.insert会被回滚
        int i = 1/0;
    }

}

@Service
public class CourseService {

    @Autowired
    private CourseMapper courseMapper;


    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void insertCourse(){
        Course course = new Course();
        course.setId(1);
        course.setName("course_"+  System.currentTimeMillis());
        courseMapper.insert(course);

    }
}

在B方法中抛出异常，A和B都被回滚


@Service
public class StudentService {


    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private CourseService courseService;



    //courseService.insertCourse()方法用了@Transactional(propagation = Propagation.REQUIRES_NEW)
    //courseService.insertCourse()会抛出异常给insert0()方法，导致两个方法都被回滚
    @Transactional(propagation = Propagation.REQUIRED)
    public void insert0(){

        Student student = new Student();
        student.setId(1);
        student.setName("student_"+ System.currentTimeMillis());
        studentMapper.insert(student);
        //这里调用的insertCourse会抛出异常
        courseService.insertCourse();


    }

}


@Service
public class CourseService {

    @Autowired
    private CourseMapper courseMapper;


    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void insertCourse(){
        Course course = new Course();
        course.setId(1);
        course.setName("course_"+  System.currentTimeMillis());
        courseMapper.insert(course);
        //这里抛出异常，异常会被抛给调用这个方法的调用者
        int i = 1/0;
    }
}

2.3、@Transactional(propagation = Propagation.SUPPORTS)

A方法有事务，B加入到事务中

@Service
public class StudentService {


    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private CourseService courseService;



    //由于courseService.insertCourse使用@Transactional(propagation = Propagation.SUPPORTS)
    //所以会加入到insert0()开启的事务中，被一起回滚
    @Transactional(propagation = Propagation.REQUIRED)
    public void insert0(){

        courseService.insertCourse();

        Student student = new Student();
        student.setId(1);
        student.setName("student_"+ System.currentTimeMillis());
        studentMapper.insert(student);

        //这里抛出异常，courseService.insertCourse()也会被回滚
        int i=1/0;


    }

}



@Service
public class CourseService {

    @Autowired
    private CourseMapper courseMapper;


    @Transactional(propagation = Propagation.SUPPORTS)
    public void insertCourse(){
        Course course = new Course();
        course.setId(1);
        course.setName("course_"+  System.currentTimeMillis());
        courseMapper.insert(course);

    }
}

A没有事务，B以无事务方式运行

@Service
public class StudentService {


    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private CourseService courseService;



    //由于courseService.insertCourse使用@Transactional(propagation = Propagation.SUPPORTS)
    //由于insert0没有开启事务，所以两个方法都以无事务方式运行，都会自动提交
    public void insert0(){

        courseService.insertCourse();

        Student student = new Student();
        student.setId(1);
        student.setName("student_"+ System.currentTimeMillis());
        studentMapper.insert(student);

        //这里抛出异常，courseService.insertCourse()不会被回滚
        //studentMapper.insert(student);也不会被回滚
        int i=1/0;


    }

}



@Service
public class CourseService {

    @Autowired
    private CourseMapper courseMapper;


    @Transactional(propagation = Propagation.SUPPORTS)
    public void insertCourse(){
        Course course = new Course();
        course.setId(1);
        course.setName("course_"+  System.currentTimeMillis());
        courseMapper.insert(course);

    }
}

2.4、@Transactional(propagation = Propagation.NOT_SUPPORTED)

A有事务，B以无事务方式运行（自动提交）

@Service
public class StudentService {


    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private CourseService courseService;



    //由于courseService.insertCourse使用@Transactional(propagation = Propagation.NOT_SUPPORTED)
    //所以courseService.insertCourse会以无事务方式运行，自动提交
    @Transactional(propagation = Propagation.REQUIRED)
    public void insert0(){

        courseService.insertCourse();

        Student student = new Student();
        student.setId(1);
        student.setName("student_"+ System.currentTimeMillis());
        studentMapper.insert(student);

        //这里抛出异常，courseService.insertCourse()不会被回滚
        //studentMapper.insert(student);会被回滚
        int i=1/0;


    }

}

@Service
public class CourseService {

    @Autowired
    private CourseMapper courseMapper;


    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void insertCourse(){
        Course course = new Course();
        course.setId(1);
        course.setName("course_"+  System.currentTimeMillis());
        courseMapper.insert(course);

    }
}

2.5、@Transactional(propagation = Propagation.MANDATORY)

A有事务，B加入事务中

@Service
public class StudentService {


    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private CourseService courseService;



    //由于courseService.insertCourse使用@Transactional(propagation = Propagation.MANDATORY)
    //所以courseService.insertCourse会加入到insert0()的事务中，一起回滚
    @Transactional(propagation = Propagation.REQUIRED)
    public void insert0(){

        courseService.insertCourse();

        Student student = new Student();
        student.setId(1);
        student.setName("student_"+ System.currentTimeMillis());
        studentMapper.insert(student);

        //这里抛出异常，courseService.insertCourse()会被回滚
        //studentMapper.insert(student);会被回滚
        int i=1/0;

    }
    
   
}


@Service
public class CourseService {


    @Autowired
    private CourseMapper courseMapper;

    @Transactional(propagation = Propagation.MANDATORY)
    public void insertCourse(){
        Course course = new Course();
        course.setId(1);
        course.setName("course_"+  System.currentTimeMillis());
        courseMapper.insert(course);

    }
}

A没有事务，B会抛出异常


@Service
public class StudentService {


    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private CourseService courseService;



    //由于courseService.insertCourse使用@Transactional(propagation = Propagation.MANDATORY)
    //courseService.insertCourse();会抛出异常
    public void insert0(){

        courseService.insertCourse();

        Student student = new Student();
        student.setId(1);
        student.setName("student_"+ System.currentTimeMillis());
        studentMapper.insert(student);

    }

}



@Service
public class CourseService {

    @Autowired
    private CourseMapper courseMapper;


    @Transactional(propagation = Propagation.MANDATORY)
    public void insertCourse(){
        Course course = new Course();
        course.setId(1);
        course.setName("course_"+  System.currentTimeMillis());
        courseMapper.insert(course);

    }
}

2.6、@Transactional(propagation = Propagation.NEVER)

A方法无事务，A和B都以无事务方式运行

@Service
public class StudentService {


    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private CourseService courseService;



    //由于courseService.insertCourse使用@Transactional(propagation = Propagation.NEVER)
    //courseService.insertCourse();以无事务方式运行，两个添加都不会被回滚
    public void insert0(){

        courseService.insertCourse();

        Student student = new Student();
        student.setId(1);
        student.setName("student_"+ System.currentTimeMillis());
        studentMapper.insert(student);

        //这里抛出异常，但是两个添加操作都是自动提交的，都不会被回滚
        int i = 1/0;

    }

}

@Service
public class CourseService {


    @Autowired
    private CourseMapper courseMapper;

    @Transactional(propagation = Propagation.NEVER)
    public void insertCourse(){
        Course course = new Course();
        course.setId(1);
        course.setName("course_"+  System.currentTimeMillis());
        courseMapper.insert(course);

    }
}

A方法有事务，B抛出异常

@Service
public class StudentService {


    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private CourseService courseService;



    //由于courseService.insertCourse使用@Transactional(propagation = Propagation.NEVER)
    //由于insert0()开启了一个事务，所以courseService.insertCourse();会抛出异常
    @Transactional(propagation = Propagation.REQUIRED)
    public void insert0(){



        Student student = new Student();
        student.setId(1);
        student.setName("student_"+ System.currentTimeMillis());
        studentMapper.insert(student);

        //这里会抛出异常，因为courseService.insertCourse不支持事务
        courseService.insertCourse();

    }

}



@Service
public class CourseService {

    @Autowired
    private CourseMapper courseMapper;


    @Transactional(propagation = Propagation.NEVER)
    public void insertCourse(){
        Course course = new Course();
        course.setId(1);
        course.setName("course_"+  System.currentTimeMillis());
        courseMapper.insert(course);

    }
}

2.7、@Transactional(propagation = Propagation.NESTED)

A方法抛出异常，B方法成功的提交也被回滚

@Service
public class StudentService {


    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private CourseService courseService;



    //由于courseService.insertCourse使用@Transactional(propagation = Propagation.NESTED)
    //由于insert0()开启了一个事务，所以courseService.insertCourse();在嵌套事务内层运行
    //当courseService.insertCourse()成功提交后，insert0()最后抛出异常，会导致courseService.insertCourse()也会被回滚
    @Transactional(propagation = Propagation.REQUIRED)
    public void insert0(){

        try {
            courseService.insertCourse();
        } catch (Exception e) {
            e.printStackTrace();
        }

        Student student = new Student();
        student.setId(1);
        student.setName("student_"+ System.currentTimeMillis());
        studentMapper.insert(student);

        //这里抛出异常会导致courseService.insertCourse()成功的提交也被回滚
        //studentMapper.insert(student)提交的也会被回滚
        int i = 1/0;
    }

}




@Service
public class CourseService {

    @Autowired
    private CourseMapper courseMapper;


    @Transactional(propagation = Propagation.NESTED)
    public void insertCourse(){
        Course course = new Course();
        course.setId(1);
        course.setName("course_"+  System.currentTimeMillis());
        courseMapper.insert(course);


    }
}

A方法执行成功，B方法抛出异常，只有B的提交被回滚，A的提交成功执行



@Service
public class StudentService {


    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private CourseService courseService;



    //由于courseService.insertCourse使用@Transactional(propagation = Propagation.NESTED)
    //由于insert0()开启了一个事务，所以courseService.insertCourse();在嵌套事务内层运行
    //当courseService.insertCourse()抛出异常会被catch，insert0会成功执行
    //最后，insert0成功提交，courseService.insertCourse()被回滚了
    @Transactional(propagation = Propagation.REQUIRED)
    public void insert0(){

        try {
            courseService.insertCourse();
        } catch (Exception e) {
            e.printStackTrace();
        }

        Student student = new Student();
        student.setId(1);
        student.setName("student_"+ System.currentTimeMillis());
        studentMapper.insert(student);


    }

}



@Service
public class CourseService {

    @Autowired
    private CourseMapper courseMapper;


    @Transactional(propagation = Propagation.NESTED)
    public void insertCourse(){
        Course course = new Course();
        course.setId(1);
        course.setName("course_"+  System.currentTimeMillis());
        courseMapper.insert(course);
        //这个方法抛出异常，只会回滚当前这个方法
        int i = 1/0;
    }
}

A方法提交成功，B方法也提交成功


@Service
public class StudentService {


    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private CourseService courseService;



    //由于courseService.insertCourse使用@Transactional(propagation = Propagation.NESTED)
    //由于insert0()开启了一个事务，所以courseService.insertCourse();在嵌套事务内层运行
    //当courseService.insertCourse()抛出异常会被catch，insert0会成功执行
    //最后，insert0成功提交，courseService.insertCourse()被回滚了
    @Transactional(propagation = Propagation.REQUIRED)
    public void insert0(){

        try {
            courseService.insertCourse();
        } catch (Exception e) {
            e.printStackTrace();
        }

        Student student = new Student();
        student.setId(1);
        student.setName("student_"+ System.currentTimeMillis());
        studentMapper.insert(student);


    }

}



@Service
public class CourseService {

    @Autowired
    private CourseMapper courseMapper;


    @Transactional(propagation = Propagation.NESTED)
    public void insertCourse(){
        Course course = new Course();
        course.setId(1);
        course.setName("course_"+  System.currentTimeMillis());
        courseMapper.insert(course);

    }
}

B方法都用@Transactional(propagation = Propagation.REQUIRES_NEW)来修饰，是否也能达到这个效果呢？


@Service
public class StudentService {


    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private CourseService courseService;




    @Transactional(propagation = Propagation.REQUIRED)
    public void insert0(){

        try {
            //由于这个方法使用了@Transactional(propagation = Propagation.REQUIRES_NEW)
            //尽管内部抛出异常，但是，insert0()方法的事务不会被影响
            courseService.insertCourse();
        } catch (Exception e) {
            e.printStackTrace();
        }

        Student student = new Student();
        student.setId(1);
        student.setName("student_"+ System.currentTimeMillis());
        studentMapper.insert(student);


    }

}



@Service
public class CourseService {

    @Autowired
    private CourseMapper courseMapper;


    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void insertCourse(){
        Course course = new Course();
        course.setId(1);
        course.setName("course_"+  System.currentTimeMillis());
        courseMapper.insert(course);

        int i = 1/0;
    }
}

2.8、无事务运行


@Service
public class StudentService {


    @Autowired
    private StudentMapper studentMapper;



    //没有使用@Transactional注解，以无事务方式运行
    //studentMapper.insert(student);自动提交，不会被回滚
    public void insert0(){

        Student student = new Student();
        student.setId(1);
        student.setName("student_"+ System.currentTimeMillis());
        studentMapper.insert(student);

        int i = 1/0;//这里抛出异常，但是studentMapper.insert会自动提交，不会被回滚


    }

}

3、事务失效情况

3.1、使用了@Transactional的方法，被同一个类里面的无@Transactional方法调用，@Transactional的方法无效。

下面的这种情况，student表 和 source表 都能成功添加数据，回滚失败。注意：这是在同一个类中的方法相互调用，上述的是不同类的方法调用，上下文不违背！

@Service
public class StudentImpl implements IStudent {

    @Autowired
    public StudentMapper studentMapper;

    @Autowired
    public SourceMapper sourceMapper;

    @Autowired
    public ISource source;

	@Override
    public void insert0() {
        Student student = new Student();
        student.setId(1);
        student.setName("student:123-sad");
        studentMapper.insert(student);
        
        insertProxy();
    }

    @Transactional
    public void insertProxy(){
        Source source = new Source();
        source.setId(210);
        source.setName("source:210=qqwe");
        sourceMapper.insert(source);
        
        int i = 1/0;
    }

但是下面这种情况B方法是可以回滚成功的，但A方法不能回滚，与第二章说明的情况一致

@Service
public class StudentImpl implements IStudent {

    @Autowired
    public StudentMapper studentMapper;

    @Autowired
    public SourceMapper sourceMapper;

    @Autowired
    public ISource source;

	@Override
    public void insert0() {
        Student student = new Student();
        student.setId(1);
        student.setName("student:123-sad");
        studentMapper.insert(student);
        
        insertProxy();
    }

	//无论这里有没有@Transactional注解，source.insert0()一样能回滚成功
    @Transactional	
    public void insertProxy(){
		source.insert0();
    }
    

    
@Service
public class SourceImpl implements ISource {

    @Autowired
    public SourceMapper sourceMapper;

    @Override
    @Transactional
    public void insert0() {
        Source source = new Source();
        source.setId(210);
        source.setName("source:210=qqwe");
        sourceMapper.insert(source);

        int i = 1/0;

    }
}

原因：Spring的事务管理是基于动态代理对象的代理逻辑实现的，那么如果在类内部的非事务方法调用类内部的事务方法，这个调用事务方法的过程并不是通过代理对象来调用的，而是直接通过this对象来调用方法，绕过的代理对象，肯定就是没有代理逻辑了。可以理解为使用了Spring注入的bean才会生成动态代理对象，更详细解释请看这里 https://blog.csdn.net/qq_45228323/article/details/125168679

解决方法：使用在类中注入自己的bean，加上@Lazy是为了防止bean的循环依赖注入。但是在实际开发中很少这样写，但这样确实能解决@Transactional失效的问题

@Service
public class StudentImpl implements IStudent {

    @Autowired
    public StudentMapper studentMapper;

    @Autowired
    public SourceMapper sourceMapper;

    @Autowired
    public ISource source;

    @Autowired
    @Lazy
    public StudentImpl studentImpl;

    @Override
    public void insert0() {

        Student student = new Student();
        student.setId(1);
        student.setName("student:123-sad");
        studentMapper.insert(student);

        studentImpl.insertProxy();
    }

	//insertProxy()方法能成功回滚，Source表没有数据，但insert0()还是会添加成功，Student表有数据
    @Transactional
    public void insertProxy(){
        Source source1 = new Source();
        source1.setId(999);
        source1.setName("source:999=qqwe");
        sourceMapper.insert(source1);

        int i = 1/0;
    }
}

区分：下面这种情况是 绝对能回滚 的，insertProxy()方法只是对代码的抽取而已，请不要搞混。

@Service
public class StudentImpl implements IStudent {

    @Autowired
    public StudentMapper studentMapper;

    @Autowired
    public SourceMapper sourceMapper;

    @Autowired
    public ISource source;

	@Override
	@Transactional
    public void insert0() {
        Student student = new Student();
        student.setId(1);
        student.setName("student:123-sad");
        studentMapper.insert(student);
        
        insertProxy();
    }
    
    private void insertProxy(){
        Source source = new Source();
        source.setId(210);
        source.setName("source:210=qqwe");
        sourceMapper.insert(source);
        
        int i = 1/0;
    }

4. 奇特的回滚方式

我们都知道，在Service层打上@Transactional后，若在该层操作出错了，不捕获异常，交由Controller层去捕获，则会回滚；但是如果异常在Service层就被捕获了，则不会回滚。
但有以下方式，即使在Service层捕获了异常，仍然可以回滚成功。

@RestController
public class InsertController {

    @Autowired
    public IStudent studentService;

    @GetMapping("/insert")
    public String insert(){
        String result = "error";
        try {
            result = studentService.insert0();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
}

@Service
public class StudentImpl implements IStudent {
    @Autowired
    public ISource sourceService;

    @Override
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public String insert0() throws Exception {
        String result = sourceService.insert0();
        if ("fail".equals(result)) {
            throw new Exception();
        }
        return "OK";
    }
}


@Service
public class SourceImpl implements ISource {

    @Autowired
    public SourceMapper sourceMapper;

    @Override
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public String insert0() throws Exception{
        String result = "success";
        try {
            Source source = new Source();
            source.setName("source:210=qqwe");
            sourceMapper.insert(source);

            int i = 1/0;
        }catch (Exception e){
            result = "fail";
        }
        return result;
    }
}

这是因为A方法调用了B方法，A方法和B方法组成了一个事务，虽然B方法异常确实是被捕获到了，但是抛出异常的是A方法，由于A方法和B方法已经组成了一个事务了，所以这两个方法会一起回滚！

lendsomething
关注
事务的传播机制
blackball1998的博客
06-25 2969
事务的传播机制 事务的传播行为就是在两个都启用了事务的方法进行嵌套调用时，外层事务和内层事务的执行动作，Spring支持七种传播方式，他们的效果如下： REQUIRED：如果有外层事务，则加入这个事务，否则开启一个新的事务 SUPPORTS：如果有外层事务，则加入这个事务，否则就以非事务方式执行 MANDATORY：如果有外层事务，则加入这个事务，否则抛出异常 REQUIRES_NEW：开启一个独立的新事务执行 NOT_SUPPORTED：方法不应该以事务方法执行，如果有外层事务，就以非事务方式执行 NE
Spring事务：@Transactional注解详解
资料免费分享，点击名片
08-05 2245
背景前两天在工作中忙的焦头烂额，涉及到 @Transactional 对于事务的控制，便仔细研究了一下，颇有所获，花费好了几天测试整理，今天才发表出来，希望老铁们能有所获吧。Spring 事务的传播行为话不多说直奔正题。先简单介绍一下 Spring 事务的传播行为。所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。在 TransactionDefinition 定义中包括了如下几个表示传播行为的常量：TransactionDefiniti
事务注解 @Transactional 失效的3种场景及解决办法
Java知音
03-30 1172
作者：向北blog.csdn.net/qq_20597727/article/details/84900994Transactional失效场景介绍第一种 Transactional注解标...
Spring中事务传播机制
最新发布
qq_44286009的博客
08-25 832
Spring事务传播机制是指在一个事务方法调用另一个事务方法时，Spring如何管理这些方法之间的事务边界。Spring在接口中定义了七种事务传播行为，以满足不同的业务需求。
事务传播机制
qq_36851469的博客
03-18 344
mandatory：强制性的。suspend：暂停、终止。
@Transactional传播
weixin_50993955的博客
11-18 2815
测试两个事物方法调用时事物的传播
spring事务失效以及事务传播机制
qq_41560749的博客
05-19 355
Spring事务失效的原因和解决方案。
Spring @Async 注解多线程导致Spring的注解@Transactional失效问题
ssmaaa的博客
02-20 3745
本文Spring @Async 注解多线程导致Spring的注解@Transactional失效与多数据源切换问题！ 问题：多线程为什么会导致事务注解@Transactional失效 实现AOP的方法有动态代理、编译期，类加载期织入等等，Spring实现AOP的方法则就是利用了动态代理机制，正因如此，才会导致某些情况下@Async和@Transactional不生效。 @Async注解使用如下 @EnableAsync //添加此注解开启异步调用（可用在配置类上，也可在启动类上标注） public
@Transactional 事务注解详解
Tyson0314的博客
03-22 549
所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。在。
Spring事务@Transactional底层原理
05-25 5490
最近同事发现一个业务状态部分更新的bug，这个bug会导致两张表的数据一致性问题。花了些时间去查问题的原因，现在总结下里面遇到的知识点原理。 问题一：事务没生效 我们先看一段实例代码，来说明下问题： @Service public class PaymentServiceImpl implements PaymentService { public void fetchLatestStatus(String trxId) { //1. do RPC request and g
事务注解@transactional和异步调用注解@Async失效了——AOP原理解析
a624193873的博客
01-16 1264
背景介绍 在使用@Async注解时，发现在本类中调用的方法异步注解失效了，实际上还是同步调用，后定位是Spring的AOP实现方式，导致注解没有生效。 动态代理两种方式 Spring实现动态代理有两种方式，JDK代理和CGLIB代理。 使用JDK还是CGLIB 1）当Bean实现接口时，Spring就会用JDK的动态代理。 2）当Bean没有实现接口时，Spring使用CGlib是实现。 3）可以强制使用CGlib（在spring配置中加入<aop:aspectj-autoproxy proxy-ta
@transactional的作用范围
08-23
@transactional注解的作用范围是作用于public方法上，只有在public方法上使用该注解时，事务才会生效。不推荐在接口上使用该注解。同时，需要注意避免在同一个类中调用带有该注解的方法，这样会导致事务失效。另外，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值