Spring事务使用总结

最新推荐文章于 2024-05-04 04:06:58 发布
最新推荐文章于 2024-05-04 04:06:58 发布
阅读量262 收藏
点赞数 1
分类专栏： springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abreaking2012/article/details/107341555
版权

Spring对事务的支持

首先，程序是否支持事务，取决于数据库，比如Mysql的Innodb引擎，那么就支持事务；如果是Myisam引擎，那么就根本不支持事务。

Spring支持两种方式的事务管理，一种是编程式，另一种是注解式。编程式对代码入侵太大，一般使用情况较少；基本上都是通过注解方式来进行事务管理。

事务传播行为

事务传播行为是为了解决业务层方法之间互相调用的事务问题。

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。

Propagation.REQUIRED

使用的最多的一个事务传播行为，我们平时经常使用的@Transactional注解默认使用就是这个事务传播行为。如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。也就是说：

  1. 如果外部方法没有开启事务的话，Propagation.REQUIRED修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。
  2. 如果外部方法开启事务并且被Propagation.REQUIRED的话，所有Propagation.REQUIRED修饰的内部方法和外部方法均属于同一事务 ，只要一个方法回滚，整个事务均回滚。

举个例子：

@Component
@EnableTransactionManagement //相当于配置文件的spring-tx配置，springboot自动包括该注解
public class A {
    @Autowired
    JdbcTemplate jdbcTemplate;
    @Autowired
    B b;
    @Transactional(propagation=Propagation.REQUIRED)
    public void requiredA(){
        b.requiredB(); //1
        jdbcTemplate.update("insert into user(id,name) value (1,'zhangsan')");
        //除于0 ，制造一个程序异常
        int s = 3/0; //2
    }

}
@Component
@EnableTransactionManagement
public class B {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional(propagation=Propagation.REQUIRED)
    public void requiredB(){
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");

    }
}

在方法A里面，制造一个异常//2处，此时方法A会回滚，那么方法B也就会回滚。

或者将异常放在方法B中，就算方法A对异常进行了try catch处理，方法B回滚了，那么方法A也一样会回滚。

@Component
@EnableTransactionManagement 
public class A {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Autowired
    B b;

    @Transactional(propagation=Propagation.REQUIRED)
    public void requiredA(){
       jdbcTemplate.update("insert into user(id,name) value (1,'zhangsan')");
        try{
          //将异常放在B中，就算异常捕获了，A还是会回滚
            b.requiredB();
        }catch (Throwable e){
            System.out.println(e.getMessage());
        }
    }

}
@Component
@EnableTransactionManagement
public class B {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional(propagation=Propagation.REQUIRED)
    public void requiredB(){
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");
        //除于0 ，制造一个程序异常
        int s = 3/0; //2
    }
}

Propagation.REQUIRES_NEW

创建一个新的事务，如果当前存在事务，则把当前事务挂起。也就是说不管外部方法是否开启事务，Propagation.REQUIRES_NEW修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。

比如上面，我们将方法B的注解改为：@Transactional(propagation=Propagation.REQUIRES_NEW)

@Component
@EnableTransactionManagement //相当于配置文件的spring-tx配置，springboot自动包括该注解
public class A {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Autowired
    B b;

    @Transactional(propagation=Propagation.REQUIRED)
    public void requiredNewA(){
        b.requiredNewB(); //1
        jdbcTemplate.update("insert into user(id,name) value (1,'zhangsan')");
        //除于0 ，制造一个程序异常
        int s = 3/0; //2
    }

}
@Component
@EnableTransactionManagement
public class B {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional(propagation=Propagation.REQUIRES_NEW)
    public void requiredNewB(){
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");
    }
}

此时，方法A抛出了异常，方法A会回滚，但是方法B不会回滚，因为方法B是独立的事务。
同理，如果方法B回滚，同样也不会对方法A造成影响，比如：

@Component
@EnableTransactionManagement //相当于配置文件的spring-tx配置，springboot自动包括该注解
public class A {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Autowired
    B b;

    @Transactional(propagation=Propagation.REQUIRED)
    public void nestedA(){
        b.nestedB();
        jdbcTemplate.update("insert into user(id,name) value (1,'zhangsan')");
        //除于0 ，制造一个程序异常
        int s = 3/0;
    }

}
@Component
@EnableTransactionManagement
public class B {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional(propagation=Propagation.NESTED)
    public void nestedB(){
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");
    }
}

此时，方法A回滚，那么方法B也就会回滚。

如果将异常放在方法B里面：

@Component
@EnableTransactionManagement //相当于配置文件的spring-tx配置，springboot自动包括该注解
public class A {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Autowired
    B b;

    @Transactional(propagation=Propagation.REQUIRED)
    public void nestedA(){
        b.nestedB();
        jdbcTemplate.update("insert into user(id,name) value (1,'zhangsan')");
        
    }

}
@Component
@EnableTransactionManagement
public class B {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional(propagation=Propagation.NESTED)
    public void nestedB(){
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");
        //除于0 ，制造一个程序异常
        int s = 3/0;
    }
}

Propagation.NESTED

如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。也就是说：

它大部分情况都等价于Propagation.REQUIRS_NEW，但是：
如果主事务回滚了，那么NESTED也会回滚。比如：

@Component
@EnableTransactionManagement //相当于配置文件的spring-tx配置，springboot自动包括该注解
public class A {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Autowired
    B b;

    @Transactional(propagation=Propagation.REQUIRED)
    public void nestedA(){
        b.nestedB(); //1
        jdbcTemplate.update("insert into user(id,name) value (1,'zhangsan')");
        //除于0 ，制造一个程序异常
        int s = 3/0; //2
    }

}
@Component
@EnableTransactionManagement
public class B {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional(propagation=Propagation.NESTED)
    public void nestedB(){
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");
    }
}

此时方法A产生了异常，出现了回滚，那么方法B也会回滚。

Propagation.MANDATORY

如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。（mandatory：强制性）
这个一般用得的比较少。
比如方法A有事务：

@Component
@EnableTransactionManagement //相当于配置文件的spring-tx配置，springboot自动包括该注解
public class A {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Autowired
    B b;

   @Transactional(propagation=Propagation.REQUIRED) //1
    public void mandatoryA(){
        b.mandatoryB();
        jdbcTemplate.update("insert into user(id,name) value (1,'zhangsan')");

    }

}
@Component
@EnableTransactionManagement
public class B {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Transactional(propagation=Propagation.MANDATORY)
    public void mandatoryB(){
        jdbcTemplate.update("insert into user(id,name) value (3,'wangwu')");
    }
}

此时程序正常，未见异常。
如果将//1处，方法A的@Transactional注解去掉，再次运行执行方法A，就会出现如下异常：

org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory'

Propagation.NOT_SUPPORTED

表示不支持事务，方法不会以事务的方式进行。如果有事务存在，将它挂起，以无事务状态运行 。
无事务,就是指底层的Connection对象的autoCommit、isolation等属性与数据库有关,与dataSource设置的属性有关，不会被Spring改变。

事务隔离级别

Spring有一个枚举类Isolation，专门定义事务隔离级别。

public enum Isolation {
    DEFAULT(TransactionDefinition.ISOLATION_DEFAULT),
    READ_UNCOMMITTED(TransactionDefinition.ISOLATION_READ_UNCOMMITTED),
    READ_COMMITTED(TransactionDefinition.ISOLATION_READ_COMMITTED),
    REPEATABLE_READ(TransactionDefinition.ISOLATION_REPEATABLE_READ),
    SERIALIZABLE(TransactionDefinition.ISOLATION_SERIALIZABLE);

    private final int value;
    Isolation(int value) {
        this.value = value;
    }
    public int value() {
        return this.value;
    }

}
  • DEFAULT:使用后端数据库默认的隔离级别，MySQL 默认采用的 REPEATABLE_READ 隔离级别 Oracle 默认采用的 READ_COMMITTED 隔离级别;
  • READ_UNCOMMITTED:最低的隔离级别，使用这个隔离级别很少，因为它允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读;
  • READ_COMMITTED : 允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生;
  • REPEATABLE_READ : 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生;
  • SERIALIZABLE : 最高的隔离级别，完全服从 ACID 的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别;

Spring 事务失效的几种情况

@Transactional只有在ublic方法才起作用

@Transactional注解作用的方法，private方法直接就编译出错，protected方法注解不会生效。比如：

    @Transactional
    protected void pA(){
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");
        int s =3/0;
    }

该方法的事务不会生效

自调用

在一个非事务方法里调用一个事务方法，此时事务方法的事务就会失效。比如：

@Component
@EnableTransactionManagement
public class TxInvalidMaster {

    @Autowired
    JdbcTemplate jdbcTemplate;

    public void a(){
        jdbcTemplate.update("insert into user(id,name) value (1,'zhangsan')");
        b();
    }

    @Transactional
    public void b(){
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");
        int s =3/0;
    }
}

执行方法a，会发现方法b的事务并没有生效。

属性rollbackFor指定异常不正确

比如，下面方法抛出的是IoException，但是rollbackFor却是SQLException，那么此时事务也不会回滚

    @Transactional(rollbackFor = SQLException.class)
    public void rollbackForA() throws IOException {
        jdbcTemplate.update("insert into user(id,name) value (2,'lisi')");
        throw new IOException("123");
    }

参考文章

abreaking2012
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring事务理解和配置
Student108的博客
09-07 2452
文章目录1 Spring事务1.1 事务简介1.1.1 什么是事务1.1.2 事物的特性1.1.3 不考虑事物会引发的安全问题1.1.4 事务隔离级别1.2 事务的传播行为1.3 编程式事务(需要手动写代码,了解)1.3.1 配置平台事务管理器1.3.2 Spring提供了事务管理的模板类1.3.3 在业务层注入事务管理的模板1.3.4 编写事务管理的代码1.4 声明式事务(xml配置)1.4.1 配置事务管理器1.4.2 配置增强1.4.3 AOP的配置1.5 声明式事务(注解)1.5.1 配置事务管理器
Spring 事务使用详解
weixin_33851177的博客
01-13 983
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring事务的使用配置和详细介绍（ 编程式事务+声明式事务+隔离级别+传播行为+回滚机制）
m0_46193073的博客
01-16 2531
Spring框架中的事务 有很多人觉得我们有了Spring，就再也不需要去处理获得连接、事务提交、回滚和关闭连接等这些操作了，其实并不是这样的，事实上Spring并不是直接管理事务的，只是提供了多种事务管理器，让持久化机制所提供的平台框架的事务来实现事务管理。 Spring事务管理的三大接口底层的实现关系如图所示: 三者的关系非常清晰，TransactionDefinition 将 Tran...
Spring系列第43篇：spring中编程式事务怎么用的？
最新发布
2401_84152126的博客
05-04 1049
由于篇幅限制，小编在此截出几张知识讲解的图解《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！Spring系列第24篇：父子容器详解Spring系列第25篇：@Value【用法、数据来源、动态刷新】Spring系列第26篇：国际化详解Spring系列第27篇：spring事件机制详解Spring系列第28篇：Bean循环依赖详解。
Spring 事务编程实践
只有变秃 才能变强
11-04 2758
Spring的事务框架将开发过程中事务管理相关的关注点进行适当的分离，通过Spring的事务框架，我们可以按照统一的编程模型来进行事务编程，却不用关心所使用的数据访问技术以及具体要访问什么 类型的事务资源。Spring 事务的设计理念的基本原则是：让 事务管理 与 数据访问，相分离。当在业务层使用事务的抽象API进行事务管理的时候，不需要关心事务将要管理的资 源是什么，对不同的事务资源的管理将由相应的框架实现类来完成。
spring事务总结.docx
10-09
事务失效、事务回滚、大事务问题、编程式事务
Spring事务处理原理步骤详解
08-19
下面是Spring事务处理原理步骤详解的知识点总结： 一、事务处理实现 在Spring中，事务处理的实现主要通过两种方式：声明式事务和编程式事务。声明式事务是通过在方法上添加@Transactional注解来实现事务处理的，而...
spring事务操作试验
08-11
总结来说，"spring事务操作试验"涵盖了Spring框架中的事务管理基础，包括声明式和编程式事务，以及它们在JDBC操作中的应用。通过实验，读者可以更好地理解事务的生命周期、隔离级别和回滚规则，这些都是构建健壮、...
spring事务案例分析.zip
03-23
在IT行业中，Spring框架...总结，Spring事务管理是其核心功能之一，它简化了事务处理的复杂性，使开发者能够专注于业务逻辑。通过学习和实践案例，我们可以更好地掌握Spring事务的使用，提高应用程序的稳定性和可靠性。
学习spring事务与消息队列
09-01
在本文中，我们将深入探讨Spring事务管理和消息队列在实际应用中的重要性和可能出现的问题，以及如何解决这些问题。Spring事务管理是Java开发中用于确保数据库操作的一致性的重要工具，而消息队列则常用于解耦系统...
spring编程式事务实现
07-30
演示了spring编程式事务的实现，通过TransactionTemplate模板进行事务控制
轻松学习 Spring 事务
trong_ 的烂笔头
09-13 2644
介绍Spring事务是做什么的，编程式，声明式事务（@Transactional相关），Spring事务的5种隔离级别及7种传播机制。
Spring的事务详解
热门推荐
h295928126的博客
06-29 4万+
Spring的事务详解
Spring的四种事务管理（一种编程式事务+三种声明事务）<学习随笔>
强强强子的博客
09-04 1万+
Spring的4种事务管理（1种编程式事务+三种声明事务） 一、Spring事务的介绍 二、编程式事务xml的配置 注入后直接在service层调用模板的方法使用 三、基于AOP方式的声明式事务管理 prop的具体配置 使用AOP声明式事务是时service层必须注入代理类 四、基于Asp
Spring事务的用法与原理
Dustin_CDS的博客
03-25 6998
1. 事务ACID Atomicity原子性：一个事务要么全部执行,要么不执行； Consistency一致性：事务的运行并不改变数据库中数据的一致性，例如检查约束、非空约束、主键约束、外键约束； Isolation隔离性：两个以上的事务不会出现交错执行的状态； Durability持久性：事务执行成功以后,该事务对数据库所作的更改便是持久的保存在数据库之中，不会无缘无故的回滚； ...
Spring 事务的配置和使用详解（包括手动对事务的控制部分）
whbing1471的博客
01-05 1万+
最近项目中用到了spring的注解类的事务管理，所以特地学习和记录一下spring的配置和使用。项目中使用的是springMVC + mybatis + mysql。spring的版本是4.3.0.RELEASE。1. spring 注解事务的配置Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式
Spring声明式事务管理使用步骤
09-12
Spring声明式事务管理使用步骤包括配置事务管理器、配置事务通知、配置事务属性、启用事务管理和在需要进行事务管理的方法中进行操作。通过这些步骤，我们可以简化事务管理的代码，并且使得事务管理更加便捷和高效。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值