@Transactional 学习和使用

已于 2023-08-15 17:02:47 修改
阅读量895 收藏 4
点赞数 1
分类专栏： java 文章标签： Transactional 不生效
于 2023-08-06 10:49:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35461948/article/details/132124222
版权

知识点：

@Transactional是一种基于注解管理事务的方式，spring通过动态代理的方式为目标方法实现事务管理的增强。 

@Transactional 实质是使用了 JDBC 的事务来进行事务控制的

@Transactional 基于 Spring 的动态代理的机制

@Transactional 实现原理：

    1) 事务开始时，通过AOP机制，生成一个代理connection对象，

并将其放入 DataSource 实例的某个与 DataSourceTransactionManager 相关的某处容器中。 在接下来的整个事务中，客户代码都应该使用该 connection 连接数据库，执行所有数据库命令。

[不使用该 connection 连接数据库执行的数据库命令，在本事务回滚的时候得不到回滚]

（物理连接 connection 逻辑上新建一个会话session；

DataSource 与 TransactionManager 配置相同的数据源）

   2) 事务结束时，回滚在第1步骤中得到的代理 connection 对象上执行的数据库命令，然后关闭该代理 connection 对象。（事务结束后，回滚操作不会对已执行完毕的SQL操作命令起作用）

使用注意

1）接口实现类或接口实现方法上，而不是接口类中。

2）访问权限：public 的方法才起作用。@Transactional 注解应该只被应用到 public 方法上，这是由 Spring AOP 的本质决定的。

系统设计：将标签放置在需要进行事务管理的方法上，而不是放在所有接口实现类上：

3）@Transactional注解在外部调用的函数上才有效果，内部调用的函数添加无效，要切记。这是由AOP的特性决定的。

函数之间调用

业务：创建法律模板，添加关联法律模板关系

单个类之间函数调用：外部加

情形1： create添加了@Transactional注解，insertLawInnerMappingBatch函数没有添加。insertLawInnerMappingBatch抛异常

    @Transactional
    public Long create(LawTemplate lawTemplate) {
        lawTemplateMapper.insertSelective(lawTemplate);
        List<Long> relLawIds = lawTemplate.getRelLawIds();
        if(CollectionUtils.isNotEmpty(relLawIds)){
            this.insertLawInnerMappingBatch(lawTemplate);
        }
        return lawTemplate.getLawId();
    }

    // 插入关联关系
    public void insertLawInnerMappingBatch(LawTemplate lawTemplate){
        throw new RuntimeException("模拟函数执行有异常!");
//        lawTemplateMapper.insertLawInnerMappingBatch(lawTemplate);
    }

单元测试：

    @Autowired
    private LawTemplateService lawTemplateService;

    @Test
    public void createRelLaw() {
        LawTemplate law = new LawTemplate();
        law.setLawName("成年人");
        law.setLawContent("成年人为完全民事行为能力人，可以独立实施民事法律行为");
        law.setLawCase("成年人行为xxx");
        law.setCreateStaffId(1L);
        law.setCreateTime(new Date());
        List<Long> lawIds = new ArrayList<>();
        lawIds.add(1L);
        law.setRelLawIds(lawIds);
        lawTemplateService.create(law);
    }

执行报错，两个数据的操作都会回滚

单个类之间函数调用：都加

情形2： create和insertLawInnerMappingBatch都添加了@Transactional注解。insertLawInnerMappingBatch抛异常

    @Transactional
    public Long create(LawTemplate lawTemplate) {
        lawTemplateMapper.insertSelective(lawTemplate);
        List<Long> relLawIds = lawTemplate.getRelLawIds();
        if(CollectionUtils.isNotEmpty(relLawIds)){
            this.insertLawInnerMappingBatch(lawTemplate);
        }
        return lawTemplate.getLawId();
    }

    // 插入关联关系
    @Transactional
    public void insertLawInnerMappingBatch(LawTemplate lawTemplate){
        throw new RuntimeException("模拟函数执行有异常!");
//        lawTemplateMapper.insertLawInnerMappingBatch(lawTemplate);
    }

  结果：同第一种情况一样，两个函数对数据库操作都会回滚。因为同一个类中函数相互调用的时候，内部函数添加@Transactional注解无效。@Transactional注解只有外部调用才有效。

单个类之间函数调用：内部加  

  情形3： create不加了@Transactional注解，insertLawInnerMappingBatch函数加@Transactional注解。insertLawInnerMappingBatch抛异常

 
    public Long create(LawTemplate lawTemplate) {
        lawTemplateMapper.insertSelective(lawTemplate);
        List<Long> relLawIds = lawTemplate.getRelLawIds();
        if(CollectionUtils.isNotEmpty(relLawIds)){
            this.insertLawInnerMappingBatch(lawTemplate);
        }
        return lawTemplate.getLawId();
    }

    // 插入关联关系
    @Transactional
    public void insertLawInnerMappingBatch(LawTemplate lawTemplate){
        throw new RuntimeException("模拟函数执行有异常!");
//        lawTemplateMapper.insertLawInnerMappingBatch(lawTemplate);
    }

 结果：两个函数对数据库的操作都不会回滚。因为内部函数@Transactional注解添加和没添加一样。

单个类之间函数调用：外部加，内部捕获异常

   情形4： create加了@Transactional注解，insertLawInnerMappingBatch加@Transactional注解。create 内部添加插入关系的捕获， insertLawInnerMappingBatch抛异常

    @Transactional
    public Long create(LawTemplate lawTemplate) {
        lawTemplateMapper.insertSelective(lawTemplate);
        List<Long> relLawIds = lawTemplate.getRelLawIds();
        if(CollectionUtils.isNotEmpty(relLawIds)){
            try {
                this.insertLawInnerMappingBatch(lawTemplate);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        return lawTemplate.getLawId();
    }

    // 插入关联关系
    @Transactional
    public void insertLawInnerMappingBatch(LawTemplate lawTemplate){
        throw new RuntimeException("模拟函数执行有异常!");
//        lawTemplateMapper.insertLawInnerMappingBatch(lawTemplate);
    }

 结果：不管insertLawInnerMappingBatch操作是否成功，insertSelective没有发生异常就会成功。事务回滚的动作发生在当有@Transactional注解函数有对应异常抛出时才会回滚。

不同类之间函数调用

不同类之间函数调用：外部加

情形1： create添加了@Transactional注解，insertLawInnerMappingBatch函数没有添加。insertLawInnerMappingBatch抛异常

@Slf4j
@Service
public class LawTemplateService {


    @Resource
    private LawTemplateMapper lawTemplateMapper;

    @Resource
    private ReplyTemplateService replyTemplateService;

    @Transactional
    public Long create(LawTemplate lawTemplate) {
        lawTemplateMapper.insertSelective(lawTemplate);
        List<Long> relLawIds = lawTemplate.getRelLawIds();
        if(CollectionUtils.isNotEmpty(relLawIds)){
            replyTemplateService.insertLawInnerMappingBatch(lawTemplate);
        }
        return lawTemplate.getLawId();
    }
}


@Slf4j
@Service
public class ReplyTemplateService {


    // 插入关联关系
    public void insertLawInnerMappingBatch(LawTemplate lawTemplate) {
        throw new RuntimeException("模拟函数执行有异常!");
    }

}

单元测试：

    @Autowired
    private LawTemplateService lawTemplateService;

    @Test
    public void createRelLaw() {
        LawTemplate law = new LawTemplate();
        law.setLawName("成年人");
        law.setLawContent("成年人为完全民事行为能力人，可以独立实施民事法律行为");
        law.setLawCase("成年人行为xxx");
        law.setCreateStaffId(1L);
        law.setCreateTime(new Date());
        List<Long> lawIds = new ArrayList<>();
        lawIds.add(1L);
        law.setRelLawIds(lawIds);
        lawTemplateService.create(law);
    }

执行报错，两个数据的操作都会回滚

不同类之间函数调用：都加

情形2： create和insertLawInnerMappingBatch都添加了@Transactional注解。insertLawInnerMappingBatch抛异常

@Slf4j
@Service
public class LawTemplateService {


    @Resource
    private LawTemplateMapper lawTemplateMapper;

    @Resource
    private ReplyTemplateService replyTemplateService;

    @Transactional
    public Long create(LawTemplate lawTemplate) {
        lawTemplateMapper.insertSelective(lawTemplate);
        List<Long> relLawIds = lawTemplate.getRelLawIds();
        if(CollectionUtils.isNotEmpty(relLawIds)){
            replyTemplateService.insertLawInnerMappingBatch(lawTemplate);
        }
        return lawTemplate.getLawId();
    }
}


@Slf4j
@Service
public class ReplyTemplateService {


    // 插入关联关系
    @Transactional
    public void insertLawInnerMappingBatch(LawTemplate lawTemplate) {
        throw new RuntimeException("模拟函数执行有异常!");
    }

}

  结果：两个函数对数据库的操作都回滚了。两个函数里面用的还是同一个事务。

不同类之间函数调用：引用加  

  情形3： create不加了@Transactional注解，insertLawInnerMappingBatch函数加@Transactional注解。insertLawInnerMappingBatch抛异常

@Slf4j
@Service
public class LawTemplateService {


    @Resource
    private LawTemplateMapper lawTemplateMapper;

    @Resource
    private ReplyTemplateService replyTemplateService;

  
    public Long create(LawTemplate lawTemplate) {
        lawTemplateMapper.insertSelective(lawTemplate);
        List<Long> relLawIds = lawTemplate.getRelLawIds();
        if(CollectionUtils.isNotEmpty(relLawIds)){
            replyTemplateService.insertLawInnerMappingBatch(lawTemplate);
        }
        return lawTemplate.getLawId();
    }
}


@Slf4j
@Service
public class ReplyTemplateService {


    // 插入关联关系
    @Transactional
    public void insertLawInnerMappingBatch(LawTemplate lawTemplate) {
        throw new RuntimeException("模拟函数执行有异常!");
    }

}

 结果：create里面insertSelective正常不报错，会插入。不管 LawTemplateService 里面 insertLawInnerMappingBatch 是否报错。因为两个是不同事物的

不同类之间函数调用：外部加，内部捕获异常

   情形4： create加了@Transactional注解，insertLawInnerMappingBatch加@Transactional注解。create 内部添加插入关系的捕获， insertLawInnerMappingBatch抛异常

@Slf4j
@Service
public class LawTemplateService {


    @Resource
    private LawTemplateMapper lawTemplateMapper;

    @Resource
    private ReplyTemplateService replyTemplateService;

  
    @Transactional
    public Long create(LawTemplate lawTemplate) {
        lawTemplateMapper.insertSelective(lawTemplate);
        List<Long> relLawIds = lawTemplate.getRelLawIds();
        if(CollectionUtils.isNotEmpty(relLawIds)){
            try {
                replyTemplateService.insertLawInnerMappingBatch(lawTemplate);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        return lawTemplate.getLawId();
    }

}


@Slf4j
@Service
public class ReplyTemplateService {


    // 插入关联关系
    @Transactional
    public void insertLawInnerMappingBatch(LawTemplate lawTemplate) {
        throw new RuntimeException("模拟函数执行有异常!");
    }

}

 部分异常：

Transaction rolled back because it has been marked as rollback-only
org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only
	at org.springframework.transaction.support.AbstractPlatformTransactionManager.processRollback(AbstractPlatformTransactionManager.java:870)
	at org.springframework.transaction.support.AbstractPlatformTransactionManager.commit(AbstractPlatformTransactionManager.java:707)
	at org.springframework.transaction.interceptor.TransactionAspectSupport.commitTransactionAfterReturning(TransactionAspectSupport.java:654)
	at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:407)
	at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:119)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:763)
	at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:708)

结果：create操作失败，而且还添加了抛出异常：org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only。两个函数用的是同一个事务。insertLawInnerMappingBatch函数抛了异常，调了事务的rollback函数。事务被标记了只能rollback了。程序继续执行，create函数里面把异常给抓出来了，这个时候create函数没有抛出异常，既然你没有异常那事务就需要提交，会调事务的commit函数。而之前已经标记了事务只能rollback-only(以为是同一个事务)。直接就抛异常了，不让继续调用了。

        有@Transactional的函数里面调用有@Transactional的函数的时候，进入第二个函数的时候是新的事务，如果还是沿用之前的事务。如果报错就会抛UnexpectedRollbackException异常。

不同类之间函数调用：引用添加 Propagation.REQUIRES_NEW

   情形5： create加了@Transactional注解，insertLawInnerMappingBatch加@Transactional注解。create 内部添加插入关系的捕获， insertLawInnerMappingBatch抛异常，添加 Propagation.REQUIRES_NEW

@Slf4j
@Service
public class LawTemplateService {


    @Resource
    private LawTemplateMapper lawTemplateMapper;

    @Resource
    private ReplyTemplateService replyTemplateService;

  
    @Transactional
    public Long create(LawTemplate lawTemplate) {
        lawTemplateMapper.insertSelective(lawTemplate);
        List<Long> relLawIds = lawTemplate.getRelLawIds();
        if(CollectionUtils.isNotEmpty(relLawIds)){
            try {
                replyTemplateService.insertLawInnerMappingBatch(lawTemplate);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        return lawTemplate.getLawId();
    }

}


@Slf4j
@Service
public class ReplyTemplateService {


    // 插入关联关系
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void insertLawInnerMappingBatch(LawTemplate lawTemplate) {
        throw new RuntimeException("模拟函数执行有异常!");
    }

}

  结果： 不管insertLawInnerMappingBatch操作是否成功，insertSelective没有发生异常就会成功。因为两个函数不是同一个事务了。

常见出错的地方

        总结以上需要注意@Transactional失效的场景：

1、异常被捕获后没有抛出

    @Transactional
    public Long create(LawTemplate lawTemplate) {
        try {
            lawTemplateMapper.insertSelective(lawTemplate);
            return lawTemplate.getLawId();
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
这个很好理解，事务回滚的动作发生在当有@Transactional注解函数有对应异常抛出时才会回滚。

2、抛出非运行时异常 得是RuntimeException 或者指定异常

这个也是容易出错的，要注意！！！

异步虽然抛出了，但是抛出的是非RuntimeException类型的异常（抛出的异常要继承RuntimeException才有效），依旧不会生效。

    @Transactional
    public Long create(LawTemplate lawTemplate) throws MyException {
        lawTemplateMapper.insertSelective(lawTemplate);
        List<Long> relLawIds = lawTemplate.getRelLawIds();
        if(CollectionUtils.isNotEmpty(relLawIds)){
            try {
                replyTemplateService.insertLawInnerMappingBatch(lawTemplate);
            }catch (Exception e){
                throw new MyException ();
            }
        }
        return lawTemplate.getLawId();
    }

如果指定了回滚异常类型为Exception，那么就可以回滚非RuntimeException类型异常了。

@Transactional(rollbackFor = Exception.class)

3、方法内部直接调用 -- 这个容易忽略，需要去注意！

如果先调用createOne()，那么create()执行成功是不会回滚的，其原因就是@Transactional根本没生成代理，如果直接调用create() ，如果报错会回滚。

@Slf4j
@Service
public class LawTemplateService {


    @Resource
    private LawTemplateMapper lawTemplateMapper;

    @Autowired
    private LawTemplateService lawTemplateService;


    public void createOne(LawTemplate lawTemplate) {
        this.create(lawTemplate);
    }

    @Transactional
    public Long create(LawTemplate lawTemplate) {
        lawTemplateMapper.insertSelective(lawTemplate);
        List<Long> relLawIds = lawTemplate.getRelLawIds();
        if(CollectionUtils.isNotEmpty(relLawIds)){
            this.insertLawInnerMappingBatch(lawTemplate);
        }
        return lawTemplate.getLawId();
    }

    // 插入关联关系
    public void insertLawInnerMappingBatch(LawTemplate lawTemplate){
        throw new RuntimeException("模拟函数执行插入关系失败后抛出异常!");
    }
}

insertSelective 插入成功， insertLawInnerMappingBatch报错，并没有回滚。为啥呢？ 因为createOne里面调用create没有生成代理。

修改方式，把当前类自己注入一下调用 

@Slf4j
@Service
public class LawTemplateService {

    @Resource
    private LawTemplateMapper lawTemplateMapper;

    public void createOne(LawTemplate lawTemplate) {
        SpringUtils.getBean(LawTemplateService.class).create(lawTemplate);
    }

    @Transactional
    public Long create(LawTemplate lawTemplate) {
        lawTemplateMapper.insertSelective(lawTemplate);
        List<Long> relLawIds = lawTemplate.getRelLawIds();
        if(CollectionUtils.isNotEmpty(relLawIds)){
            this.insertLawInnerMappingBatch(lawTemplate);
        }
        return lawTemplate.getLawId();
    }

    // 插入关联关系
    public void insertLawInnerMappingBatch(LawTemplate lawTemplate){
        throw new RuntimeException("模拟函数执行插入关系失败后抛出异常!");
    }
}

insertSelective 插入成功， insertLawInnerMappingBatch报错，会回滚。

4、注解到private方法上

idea直接会给出提示Methods annotated with ‘@Transactional’ must be overridable ，原理很简单，private修饰的方式，spring无法生成动态代理。直接报错了

总结：

      @Transactional 使用：1， 要注意抛出异常是否是运行时异常；2，注解在外部调用的函数上才有效果；3，内部调用的，要注意是否生成代理。

天狼1222
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spring @Transactional 无效的解决方案
08-26
主要介绍了spring @Transactional 无效的解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
深入学习Spring Boot排查 @Transactional 引起的 NullPointerException问题
08-28
深入学习Spring Boot排查 @Transactional 引起的 NullPointerException问题 在 Spring Boot 应用程序中，@Transactional 注解是非常常用的，它能够帮助我们管理事务，使得数据库操作更加可靠和安全。然而，在某些...
@Transactional详解（作用、失效场景与解决方法）
我认不到你的博客
08-03 1万+
@Transactional非常的好用，只需要一个注解就可以不用管事务操作了，只需要注重自己的业务代码就可以了 @Transactional也有缺点，比如你要注意上诉的几种失效情况，他有个局限性，他的最小粒度要作用在方法上，也就是说，如果想要给一部分代码块增加事务的话，那就需要把这个部分代码块单独独立出来作为一个方法。而且AOP要生成一个动态代理类，所以会慢一点 但是谁会管这些啊，好用就行了，也不是不能忍的问题，这跟他的好处根本不成正比，当然如果要使用编程式事务也可以，看个人爱好，反之小编一直在用
@Transactional注解详解
最新发布
m0_52825447的博客
05-26 699
事务（Transaction）是数据库管理系统执行过程中的一个逻辑单位，由一个有限的数据库操作序列构成。这些操作要么全部执行，要么全部不执行，是一个不可分割的工作单位。事务的主要目的是简化失败恢复并保持数据的完整性。原子性（Atomicity）：事务作为一个整体被执行，包含在其中的对数据库的操作要么全部被执行，要么全部不执行。一致性（Consistency）：事务必须使数据库从一个一致性状态变换到另一个一致性状态。也就是说，一个事务执行之前和执行之后都必须处于一致性状态。
@Transactional详解与使用示例
qq_45752401的博客
10-16 6073
@Transactional@Transactional@Transactional 实现原理事务的隔离级别：事务传播行为：spring事务回滚规则：演示示例 @Transactional package org.springframework.transaction.annotation; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation
@Transational 事务详解
weixin_44100022的博客
06-12 3436
1、@Transactional注解 可以作用于接口、接口方法、类以及类方法上。当作用于类上时，该类的所有方法将都具有该类型的事务属性，同时，我们也可以在方法级别使用该标注来覆盖类级别的定义。2、虽然@Transactional 注解可以作用于接口、接口方法、类以及类方法上，但是 Spring 建议不要在接口或者接口方法上使用该注解，因为这只有在使用基于接口的代理时它才会生效。另外， @Transactional注解应该只被应用到 public 方法上，这是由Spring AOP的本质决定的。
@Transactional注解的使用
米诺有糖吃
04-26 4339
Transactional注解的底层实现是基于AOP和TransactionInterceptor拦截器来实现的，它使用了TransactionManager来管理事务，确保了在一个事务内执行的所有操作都是原子性、一致性、隔离性和持久性的。@Transactional 注解可以确保一个方法或类中的操作要么全部成功提交，要么全部回滚，从而保证数据的完整性和一致性。它适用于许多场景，包括数据库事务、业务逻辑、缓存更新、消息队列等。
Spring——事务注解@Transactional【建议收藏】
热门推荐
娜娜米的博客
07-18 3万+
在某些业务场景下，如果一个请求中，需要同时写入多张表的数据或者执行多条sql，为了保证操作的原子性（要么同时成功，要么同时失败），避免数据不一致的情况，我们一般都会用到事务；Spring框架下，我们经常会使用@Transactional注解来管理事务； 本篇介绍Spring的事务注解@Transactional相关的知识，包括事务简介、事务隔离级别、Spring声明式事务实现原理、事务的传播行为、@Transactional的用法及注意事项等，属于Spring的常用注解之一，需要掌握相关知识点；...
@Transactional详解
天元白手的博客
06-24 1979
@Transactional的概述 是Spring框架中声明式事务管理 编程中使用的注解 添加的位置 使用在接口的实现类上或接口的实现方法上，不是接口类中 @Transactional注解只能引用到public方法上，这是由Spring AOP的本质决定的，如果你在protected、private或者默认可见性的方法上使用@Transactional注解，那是无效的 系统设计：将@Transactional标签放在需要进行事务管理的方法上，而不是不假思索的放置在接口实现类上，（接口中所有方
spring 自定义事务管理器，编程式事务，声明式事务@Transactional使用
07-13
通过`transactional_learn`目录下的文件，你将能够逐步学习和实践以上所有内容，从配置Spring的事务管理到编写示例代码，最后运行并观察事务管理的效果。这将加深你对Spring事务管理的理解，帮助你在实际项目中更加...
Spring源码学习十二：@Transactional是如何工作的1
08-04
@Transactional 注解的工作原理是通过代理模式和 AOP 机制来实现事务管理的。首先，通过 <tx:annotation-driven/> 配置，Spring 容器注册了一个 InfrastructureAdvisorAutoProxyCreator 类，用于创建代理对象。然后...
Spring中@Transactional用法详细介绍
08-31
主要介绍了Spring中@Transactional用法详细介绍的相关资料,需要的朋友可以参考下
Mybatis学习总结之mybatis使用建议
09-02
根据业务需求，合理使用`@Transactional`注解或其他方式来开启和提交事务，确保数据的一致性。 6. **日志配置**： - 配置合适的MyBatis日志，如Log4j或SLF4J，以便在开发和调试过程中能够查看执行的SQL语句和绑定...
DynamicSpringTransactional:http上博客文章的支持代码
05-14
6. **代码示例**：`DynamicSpringTransactional-master`可能包含了一系列的Java类和测试用例，展示如何创建、使用和配置动态事务。 在实际开发中，动态事务管理可以用于处理复杂的业务场景，比如不同的用户角色、...
【Java 基础】SpringBoot 中 @Transactional 注解的使用与实践
yuxiangdeming的博客
06-12 2万+
事务管理是应用系统开发中必不可少的一部分。Spring 为事务管理提供了丰富的功能支持。Spring 事务管理分为编程式和声明式的两种方式。本篇只说明声明式注解。 事务：是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作；这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行；事务是一组不可再分割的操作集合（工作逻辑单元）。 事务的四大特性：只需在方法加上 @Transactional 注解就可以了。如下有一个保存数据的方法，加入 @transactiona
@Transactional()的使用
19.2.04.157N的博客
06-14 941
@Transactional()的使用
【数据库学习】事务及Spring事务机制：@Transactional
午后阳光
07-17 4492
1，Spring中的Transacational spring 中的 @Transactional 基于动态代理的机制，提供了一种透明的事务管理机制，方便快捷解决在开发中碰到的问题。 1）原理 在应用系统调用声明了 @Transactional 的目标方法时，Spring默认使用AOP代理，在代码运行时生成一个代理对象,如右图中所示调用者Caller并不是直接调用的目标类上的目标方法(Target Method)，而是调用的代理类(AOP Proxy)。 根据 @Transactional 的属性配置信息，
@Transactional事务不生效的情况小结
皮球
08-28 3684
@Transactional事务不生效的情况小结
@Transactional的传播属性REQUIRES_NEW深入理解
DRD
06-04 8446
spring boot项目；sql server；druid连接池；requires_new传播属性；隔离接别
@Transactional 会导致
08-26
使用 @Transactional 注解的方法将自动被封装在一个事务中，当方法执行结束时，如果没有发生异常，则事务将被提交，否则将回滚。 这种方式可以确保数据库操作的一致性和完整性。如果在同一个事务中执行多个数据库...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天狼1222

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值