【09】Spring笔记--声明式事务

最新推荐文章于 2023-03-30 08:48:08 发布
最新推荐文章于 2023-03-30 08:48:08 发布
阅读量205 收藏
点赞数
分类专栏： Spring 文章标签： spring java 声明式事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42701294/article/details/110287014
版权

【09】Spring笔记–声明式事务

一、声明式事务的使用

对于声明式事务，使用@Transactional 注解 进行标注即可，可以放在类或方法上，Spring就会产生AOP的功能，这是Spring事务的底层实现

  • 放在类上，该类的所有公共非静态方法都将启用事务功能
  • 放在方法上，就代表这个方法启用事务

在 @Transactional 中，可配置许多属性，比如事务的隔离级别和传播行为，或者回滚策略

当启动事务时，就会根据事务定义器内的配置去设置事务，首先根据传播行为去确定事务的策略，然后是隔离级别、超时时间、只读等内容设置

查看 @Transactional 源码

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
    // 通过Bean name指定事务管理器
    @AliasFor("transactionManager")
    String value() default "";

    // 同value属性
    @AliasFor("value")
    String transactionManager() default "";

    // 传播行为设置
    Propagation propagation() default Propagation.REQUIRED;

    // 隔离级别设置
    Isolation isolation() default Isolation.DEFAULT;

    // 超时时间 单位秒
    int timeout() default -1;

    // 是否只读事务
    boolean readOnly() default false;

    // 指定异常回滚，默认所有异常都回滚
    Class<? extends Throwable>[] rollbackFor() default {};

    // 指定异常名称回滚，~
    String[] rollbackForClassName() default {};

    // 指定发送哪些异常不回滚，~
    Class<? extends Throwable>[] noRollbackFor() default {};

    String[] noRollbackForClassName() default {};
}
1.1 Spring 事务管理器

在Spring中，事务管理器的顶层接口是PlatformTransactionManager，当我们在Spring boot里面引入MyBatis时，就会自动创建一个 DataSourceTransactionManager 对象，作为事务管理器

查看PlatformTransactionManager源码

public interface PlatformTransactionManager extends TransactionManager {
    // 获取事务，还可以设置数据属性
    TransactionStatus getTransaction(@Nullable TransactionDefinition var1) throws TransactionException;

    // 提交事务
    void commit(TransactionStatus var1) throws TransactionException;

    // 回滚事务
    void rollback(TransactionStatus var1) throws TransactionException;
}

Spring 在事务管理时，就会将这些方法按照约定织入对应的流程中。TransactionDefinition 是一个事务定义器，依赖于 @Transactional 的配置项生成，通过它可以设置事务的属性

二、隔离级别

隔离级别是数据库的概念。场景：对于商品库存，时刻都是多个线程共享的数据，这样就会在多线程环境下扣减商品库存。对于数据库而已，则出现多个事务同时访问同一记录的情况，就会引起数据出现不一致的情况，便是数据库的丢失更新问题

2.1 数据库事务的4个特性
  • 原子性（Atomicity）：事务是最小的执行单位，不可分割。事务中的一系列操作要么都成功，要么都失败。
  • 一致性（Consistency）：事务前后，数据保持一致。比如，转账业务中，2个人的总额在事务前后保持不变
  • 隔离性（Isolation）：并发事务中，一个事务不会影响到其他事务的执行，不会互相干扰
  • 持久性（Durability）：事务对数据的修改是永久的，不会因为数据库的故障而改变
2.2 事务隔离级别
  1. 读未提交：允许读取到其他事务尚未提交的数据变更，可能导致脏读，丢失修改，不可重复读，幻读
  2. 读已提交：只允许读取到已经提交的数据变更，防止了脏读，不可重复读，幻读仍存在
  3. 可重复读：在一个事务中，对同一数据的多次读取结果是一致的。除非数据被事务本身所修改
  4. 串行化：所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰。最高级的隔离级别，可以防止幻读
2.3 使用隔离级别

查看隔离级别源码

package org.springframework.transaction.annotation;

import org.springframework.transaction.TransactionDefinition;

public enum Isolation {

    // 默认隔离级别（使用基础数据存储的默认隔离级别。 所有其他级别对应于JDBC隔离级别。
	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;
	}
}

三、传播行为

传播行为是方法之间调用事务采取的策略问题。

大多数情况下，我们会认为数据库事务要么全部成功，要么都失败。但也有特殊情况，比如，执行一个批量程序，它会处理很多的交易，绝大多数交易可以顺序完成，但极少数交易可能出现问题，我们不能因为这几个异常交易而回滚整个批量任务。而是只回滚那些出现异常的交易

3.1 传播行为的定义
事务行为说明
REQUIRED默认传播行为，如果当前存在事务，就沿用当前事务。否则新建一个事务运行子方法
SUPPORTS支持当前事务，如果当前没有事务，则将继续采用无事务方式运行子方法
MANDATORY必须使用事务，如果当前没有事务，就抛出异常
REQUIRES_NEW无论当前是否存在事务，都新建事务运行方法。如果当前存在事务，把当前事务挂起
NOT_SUPPORTED不支持事务，如果当前存在事务，就挂起事务，运行方法
NEVER不支持事务，如果当前存在事务，则抛出异常
NESTED如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与REQUIRED类似的操作。

Spring中，是通过枚举类 Propagation定义的，

public enum Propagation {

	REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),

	SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),

	MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),

	REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),

	NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),

	NEVER(TransactionDefinition.PROPAGATION_NEVER),

	NESTED(TransactionDefinition.PROPAGATION_NESTED);

	private final int value;

	Propagation(int value) {
		this.value = value;
	}

	public int value() {
		return this.value;
	}
}
3.2 测试传播行为-REQUIRED

REQUIRED：默认传播行为，如果当前存在事务，就沿用当前事务，否则新建一个事务运行子方法

示例：批量插入用户

1.项目结构：

在这里插入图片描述

2.UserService接口，和批量操作接口 UserBatchService

public interface UserService {
    int insertUser(User user);
}

// 批量操作接口
public interface UserBatchService {
    int insertUsers(List<User> users);
}

3.对应实现类

// UserService
@Service
public class UserServieImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    // 开启事务，其他默认
    @Transactional
    @Override
    public int insertUser(User user) {
        return userMapper.insertUser(user);
    }
}


// UserBatchService实现类
@Service
public class UserBatchServieImpl implements UserBatchService {

    @Autowired
    private UserService userService;

    // 开启事务，隔离级别=读已提交、传播行为=沿用当前事务（当前事务存在的话
    @Transactional(isolation = Isolation.READ_COMMITTED,propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    @Override
    public int insertUsers(List<User> users) {
        final int[] count = {0};
        users.forEach(user-> {
            count[0] += userService.insertUser(user);
        });
        return count[0];
    }
}

4.测试方法

    @Test
    public void testBatchUser(){
        User user = new User();
        user.setUsername("Tom2");
        user.setAddress("北京");

        User user2 = new User();
        user2.setUsername("Cat2");
        user2.setAddress("上海");

        List<User> list = new ArrayList<>();
        list.add(user);
        list.add(user2);

        userBatchService.insertUsers(list);
    }

5.查看输出日志

在这里插入图片描述

从中可以观察出，当调用子方法 insertUser() 时，会加入已经存在的事务。这就是 Propagation.REQUIRED 隔离级别。

3.2 测试传播行为-REQUIRES_NEW

REQUIRES_NEW：无论当前事务是否存在，都会创建新事务运行方法

1.改变 UserServiceImpl的事务设置

@Service
public class UserServieImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    // 设置隔离级别=读已提交 、传播行为=REQUIRES_NEW
    @Transactional(isolation = Isolation.READ_COMMITTED,propagation = Propagation.REQUIRES_NEW)
    @Override
    public int insertUser(User user) {
        return userMapper.insertUser(user);
    }
}

在这里插入图片描述

2.从日志可以看出，对于子方法 insertUser() 调用时，会开启一个新的事务，独立提交，完全脱离原有事务的管控，每一个事务都有自己独立的隔离级别和锁

3.3 测试传播行为-NESTED

NESTED：在当前方法调用子方法时，如果子方法发生异常，只回滚子方法执行过的SQL，而不回滚当前方法的事务

1.改变 UserSeviceImpl 的事务设置

@Service
public class UserServieImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    // 设置隔离级别=读已提交 、传播行为=REQUIRES_NEW
    @Transactional(isolation = Isolation.READ_COMMITTED,propagation = Propagation.NESTED)
    @Override
    public int insertUser(User user) {
        return userMapper.insertUser(user);
    }
}

在这里插入图片描述

从日志中可以看出，当调用 insertUser() 时，就会创建 nested类型事务

3.4 NESTED传播行为和REQUIRES_NEW区别

NESTED 传播行为会沿用当前事务的隔离级别和锁等特性，而REQUIRES_NEW 则可以拥有自己独立的隔离级别和锁等特性。

四、@Transactional 自调用失效问题

4.1 什么是自调用失效问题

之前测试传播行为时，使用的是 UserBatchServiceImpl 去调用 UserService的方法去完成批量导入用户，如果我们不使用 UserBatchService，而把 insertUsers() 也放在 UserServie里面。让它调用本类和 insertUser() 会怎么呢？就像这样

@Service
public class UserServieImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    // 设置隔离级别=读已提交 、传播行为=REQUIRES_NEW
    @Transactional(isolation = Isolation.READ_COMMITTED,propagation = Propagation.REQUIRES_NEW)
    @Override
    public int insertUser(User user) {
        return userMapper.insertUser(user);
    }

    // 批量插入接口
    @Transactional(isolation = Isolation.READ_COMMITTED,propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    @Override
    public int insertUsers(List<User> users) {
        final int[] count = {0};
        users.forEach(user-> {
            count[0] += this.insertUser(user);
        });
        return count[0];
    }
}

在这里插入图片描述

从日志可以看出，调用 insertUser() 时，没有开启事务。所以该方法上的 @Transactional 注解失效了

4.2 失效的原因

因为 Spring数据库事务，底层实现是 AOP，AOP的原理又是动态代理。

在自调用过程中，是类的自身调用，而不是代理对象去调用，就没有使用 AOP ，所以注解失效。

4.3 如何解决？

1.第一种：使用2个 Service，像上面一样。UserBatchService 去调用 UserService。

2.第二种：从容器里面去获取代理对象去启用AOP，就像下面这样

@Service
public class UserServieImpl implements UserService , ApplicationContextAware {

    @Autowired
    private UserMapper userMapper;

    private ApplicationContext applicationContext;

    // 实现生命周期方法，设置IOC容器
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    // 单条插入
    @Transactional(isolation = Isolation.READ_COMMITTED,propagation = Propagation.REQUIRES_NEW)
    @Override
    public int insertUser(User user) {
        return userMapper.insertUser(user);
    }

    // 批量插入
    @Transactional(isolation = Isolation.READ_COMMITTED,propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    @Override
    public int insertUsers(List<User> users) {

        // 从容器中获取代理对象
        UserService userService = applicationContext.getBean(UserService.class);

        final int[] count = {0};
        users.forEach(user-> {
            // 使用代理对象插入用户，AOP生效。事务开启成功
            count[0] += userService.insertUser(user);
        });
        return count[0];
    }
}

在这里插入图片描述

参考：《深入浅出Spring Boot 2.x》

昫 灬
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Spring事务传播级别
zengjyxxz的博客
06-01 353
主流数据库隔离级别： 未提交读（隔离事务的最低级别，只能保证不读取物理上损坏的数据） 已提交读（数据库引擎的默认级别） 可重复读 可序列化（隔离事务的最高级别，事务之间完全隔离） 主流数据库默认隔离级别： mysql默认的事务处理级别是’REPEATABLE-READ’,也就是可重复读。 oracle数据库支持READ COMMITTED 和 SERIALIZABLE这两种事务隔离级别。 sql server 默认系统事务隔离级别是read committed,也就是读已提交。 传播行为（pragation
声明式事务的使用
qq_37630321的博客
03-10 208
声明式事务 声明式事务分为XML声明式事务和注解声明式事务。 声明式事务的原理：在编程事务的基础上，加入了AOP动态代理的功能。 XML事务 1、配置XML文件 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="...
Spring事务的使用配置和详细介绍（ 编程式事务+声明式事务+隔离级别+传播行为+回滚机制）
m0_46193073的博客
01-16 2536
Spring框架中的事务 有很多人觉得我们有了Spring，就再也不需要去处理获得连接、事务提交、回滚和关闭连接等这些操作了，其实并不是这样的，事实上Spring并不是直接管理事务的，只是提供了多种事务管理器，让持久化机制所提供的平台框架的事务来实现事务管理。 Spring事务管理的三大接口底层的实现关系如图所示: 三者的关系非常清晰，TransactionDefinition 将 Tran...
【Spring事务】声明式事务 使用详解
ebb29bbe的博客
03-02 1454
个人简介：Java领域新星创作者；阿里云技术博主、星级博主、专家博主；正在Java学习的路上摸爬滚打，记录学习的过程~
声明式事务的应用(以ssm项目为例)
wudinaniya的博客
08-26 4175
添加事务在实际项目中是必不可少的,事务是用来实现要么全都成功,要么全都不成功, 而主要针对的就是要不成功就全都不成功的问题. 想象你给你女朋友转账,这边刚扣了钱,你女朋友账户还没收到钱呢,突然出故障了,比如停电了. 那怎么办. 这就涉及到一个关键的知识点:事务. 利用的事务的回滚,把你账户上扣的钱再回滚到你账户上. 本篇采用maven构建war工程涉及主要知识点: spring+sp
Spring学习笔记之九--声明式事务
05-24
本篇文章将深入探讨Spring框架的一个关键特性——声明式事务管理。通过声明式事务，开发者可以避免手动处理事务的繁琐工作，提高代码的可读性和可维护性。 首先，我们了解什么是事务。在数据库操作中，事务是一系列...
Spring学习笔记-cqupt
03-19
- **事务管理**：Spring 提供了对事务的声明式和编程式管理。 - **框架集成**：Spring 可以与众多其他框架无缝集成，如 MyBatis、Hibernate 等。 3. **Spring 的组成** Spring 框架由多个模块组成，包括核心容器...
spring学习笔记(十六)-声明式事务的例子
05-24
在本篇“spring学习笔记(十六)-声明式事务的例子”中，我们将深入探讨这一主题。 首先，声明式事务管理基于AOP（面向切面编程）实现，Spring通过代理模式在方法调用前后自动插入事务管理的代码。它主要通过两种方式...
spring-analysis-master.zip
12-05
2. 声明式事务管理：基于AOP，通过@Transactional注解实现事务的自动管理，简化了事务处理代码。 五、Spring Boot 1. Spring Boot简化了Spring应用的初始搭建和配置，通过自动配置和起步依赖，快速启动微服务。 2...
SSH笔记-事务管理
06-17
虽然注解和XML配置更常见，但Spring也支持编程式事务管理，允许开发者在代码中显式地开始、提交、回滚事务。这种方法灵活性较高，但增加了代码的复杂性。 在SSHnote_Spring_15_TransactionManager这个压缩包中，...
Spring事务传播：REQUIRED、REQUIRES_NEW、NESTED事务传播举例对比
laozhang42的博客
02-16 3113
Spring事物传播：REQUIRED、REQUIRES_NEW、NESTED三种事物传播机制举例对比
Spring——声明式事务的使用
万里顾一程的博客
04-12 638
文章目录Spring——声明式事务1、事务的回顾2、声明式事务 Spring——声明式事务 1、事务的回顾 一组业务要么都成功，要么都失败 事务在项目开发中很重要，涉及到数据的一致性问题 确保数据的完整性和一致性 事务的ACID原则 原子性（atomicity）：事务中包括的操作要么都做，要么都不做， 一致性（consistency）：针对一个事务操作前与操作后的状态一致。一致性和原子性密切相关（因为一个事务不管做或者没做，数据库都处于一致状态，但如果事务中一个操作做了，但另一个操作没做，则逻辑上就会
Spring声明式事务的使用与其实现原理
morris
03-22 4028
简单使用 引入依赖 compile("mysql:mysql-connector-java:8.0.23") compile(project(":spring-jdbc")) 引入spring-jdbc后会自动引入spring-tx事务管理。 配置类 package com.morris.spring.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotat
SpringBoot声明式事务的简单运用
热门推荐
JustryDeng
06-27 5万+
关于事物的基本概念等这里就不介绍了。 Spring声明式事物的实现，有两种方式；第一种是配置xml，第二种是使用相关注解(这两种方式可详见《程序员成长笔记(一)》的相关章节)。SpringBoot中默认配置了第二种方式，所以，SpringBoot直接使用注解即可。下面介绍SpringBoot通过注解开启事物的使用。 SpringBoot使用事物的步骤： 第一步：在启动类上开启...
Spring声明式事务的使用(@Transactional)
北辰之北灬的博客
10-19 1313
前言 Spring声明式事务是基于Spring AOP实现的，如果对Spring AOP不太了解，可以先了解一下Spring AOP。 事务约定 对于声明式事务，时使用@Transactional注解进行标注的。这个标注可以标注在类或者方法上，当它标注在类上时，代表这个类所有公共（public）非静态的方法都将启用事务功能。 在@Transactional中，还允许配置多种配置，如：事务的...
Spring基础学习之声明式事务
weixin_45301250的博客
10-18 223
前言： 小伙伴们，大家好，我是狂奔の蜗牛rz，当然你们可以叫我蜗牛君，我是一个学习Java半年多时间的小菜鸟，同时还有一个伟大的梦想，那就是有朝一日，成为一个优秀的Java架构师。 这个Spring基础学习系列是用来记录我学习Spring框架基础知识的全过程 (这个系列是参照B站狂神的Spring5最新教程来写的，由于是之前整理的，但当时没有发布出来，所以有些地方可能有错误，希望大家能够及时指正！) 之后我将会以一天一更的速度更新这个系列，还没有学习Spring5框架的小伙伴可以参照我的博客学习一下；当然
Spring声明式事务@Transactional使用
一气道盟王富贵儿
11-10 806
背景 作为一个后端开发，@Transactional一直在用，但总会碰到各种离奇的不生效的情况，每次都是到处查资料解决。就想写一篇文章整理一下，后面遇到就不用到处找了，有新情况也再补充。 @Transactional 声明式事务 spring支持 编程式事务 和 声明式事务 两种。编程式事务也就是用代码手动控制事务的开始、提交或回滚，这样业务代码就变得不纯粹，功能代码和辅助代码杂糅到一起，并且会有许多重复代码。所以我们一般使用声明式事务。声明式事务一般有两种方式，一是基于tx和aop命名空间的xml
spring之JdbcTemplate实现增加删除修改功能
qq_42388853的博客
08-31 503
说白了就是用spring操作数据库， 要记得导入组件扫描： 代码如下： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.o
《Spring系列》第15章 声明式事务(一) 基础使用
最新发布
迦南学院
03-30 342
Transactional，这个注解添加到类上面，也可以添加方法上面如果把这个注解添加类上面，这个类里面所有的方法都添加事务如果把这个注解添加方法上面，为这个方法添加事务看一下其源码@Target({// 事务传播行为 Propagation propagation() default Propagation . REQUIRED;// 事务的隔离级别 Isolation isolation() default Isolation . DEFAULT;
spring2.0宝典一书笔记
11-15
另外，spring框架还支持面向切面编程（AOP），提供了声明式事务管理和用户自定义切面等特性。最后，spring框架还提供了持久化支持，方便开发者进行数据库操作。 最后，书籍介绍了spring框架的基本设计思想。其中，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值