Spring 中声明式事务和编程式事务的使用

最新推荐文章于 2024-10-04 20:45:00 发布
最新推荐文章于 2024-10-04 20:45:00 发布
阅读量3k 收藏 32
点赞数 7
文章标签： spring java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68288689/article/details/131269148
版权

在 MySQL 中我们也学习了事务, 那么事务它到底是什么呢 ?
在数据库中, 事务是指一系列的操作被视为一个完整的、原子性的工作. 在进行复杂业务逻辑时, 可能出现多个 SQL 操作需要同时进行, 但是如果这些操作不是原子性的, 就会导致数据库的不一致性和完整性的问题.
比如常见的转账操作中, 张三给李四转账 100 元, 那么张三账户 -100, 李四账户 +100, 但资金转移过程由于出现某种错误, 导致张三钱扣了, 但李四却没收到钱. 因此为了保证数据的一致性和原子性, 我们需要使用事务来确保一组操作的原子性.

在 Spring 中, 提供了两种事务, 一种是编程式另一种是声明式来管理我们的事务

一. 编程式事务

编程式事务, 顾名思义是一种通过编写具体代码来实现事务管理的方式. 在编程式事务中, 开发人员需要手动编写代码来控制事务的开始、提交和回滚等操作.
下面就来演示一个编程式事务

1. 构建 Mapper 接口

我们需要操作的是数据库, 因此肯定是需要 Mybatis 的两个组件的 接口和接口的XML 实现.( 可以看我往期文章 )

@Mapper // 注意添加 Mapper 注解进行申明
    public interface UserMapper {
        int del(@Param("id") Integer id);
    }

2. XML 接口功能实现

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.example.demo.mapper.UserMapper">
    <!-- 注意XXXMapper 的名称要对应 -->
    <delete id="del" >
    delete from userinfo where id=#{id}
    </delete>
    </mapper>

3. 建立 service 调用链

遵循我们的标准分层协议, 数据库中的操作一般由 service 调用, 最终提供方法供外部使用

@Service
    public class UserService {
        @Autowired
        private UserMapper userMapper;

        public int del(Integer id) {
            return userMapper.del(id);
        }
    }

4. 建立 controller 调用

外部通过控制器访问 service 调用链, 从而进行外部调用.

@RestController
    @RequestMapping("/user")
    public class UserController {

        @Autowired
        private UserService userService;

        // 编程式事务
        @Autowired
        private DataSourceTransactionManager transactionManager; // 事务管理器

        @Autowired
        private TransactionDefinition transactionDefinition; // 定义事务属性

        @RequestMapping("/del")
        public int del(Integer id) {

            if (id == null || id <= 0) return 0;

            TransactionStatus transactionStatus = null;
            int result = 0;

            try {

                // 1. 开启事务
                // 传入 transactionDefinition 给事务管理器 transactionManager 创建一个 transactionStatus 事务
                transactionStatus = transactionManager.getTransaction(transactionDefinition);

                result = userService.del(id);
                System.out.println("删除 : " + result + " 条数据");

                // 2. 事务提交
                transactionManager.commit(transactionStatus);

            } catch (Exception e) {
                // 事务对象正常
                if (transactionStatus != null) {
                    transactionManager.rollback(transactionStatus); // 事务回滚
                }
                return 0;
            }
            return result;
        }
    }

可以看到, 这个代码里, 当我们访问路由方法时, 如果出现了异常主动进行回滚, 正常执行则提交事务.
在 try 语句块中主动构建算数异常 : int a = 10 / 0; 加入到上述代码中, 执行路由方法观察是否进行回滚, 访问路由方法, 传入 id = 1
image.png
控制台显示我们已经删除了一条数据, 但我们预期的是发生异常后, 主动进行回滚, 数据库不被污染
image.png
可以看到, 异常后是成功的回滚了的.
image.png
这就是一个简单的编程式事务, 它非常的灵活, 而且也非常的受控, 但是它需要手写很多的事务代码, 因此存在可读性上会较差, 开发效率降低等问题.

二. 声明式事务

声明式事务是通过声明配置爱实现事务的管理方式. 在声明式事务中, 只需要在代码中通过添加事务注解或者 XML 配置文件中进行配置, 从而将事务管理交给框架来处理, 而无需手动编写大量的事务管理代码

1. 声明式事务的演示

声明式事务中最主要的就是 @Transactional 事务注解. 对于我们刚刚的删除操作, 同样可以用声明式事务来操作

@RestController
    @RequestMapping("/user2")
    public class UserController2 {

        @Autowired
        private UserService userService;

        /**
* 该方法开启事务, 如果发生异常则进行事务回滚.
*              如果正常执行, 则提交事务
*/
        @RequestMapping("del")
        @Transactional
        public int del(Integer id) {
            if (id == null || id <= 0) return 0;
            return userService.del(id);
        }
    }

service 层中

@Service
    public class UserService {
        @Autowired
        private UserMapper userMapper;

        public int del(Integer id) throws InterruptedException {
            int result = userMapper.del(id);
            return result;
        }
    }

UserMapper 中

@Mapper
    public interface UserMapper {
        int del(@Param("id") Integer id);
    }

XMl 实现

<delete id="del" >
    delete from userinfo where id=#{id}
    </delete>

访问路由方法看其是否能够正常删除 id = 5 的用户image.png
image.png
通过查看数据库, 可以看到它是正常的删除了的.
image.png

手动添加算数异常, 看我们的 @Transactional 事务注解 能否正常生效让其回滚. 此时传入 id = 1

@RequestMapping("del")
    @Transactional
    public int del(Integer id) {
        if (id == null || id <= 0) return 0;
int result = userService.del(id);
int a = 10 / 0;
return result;
}

访问路由方法后, 控制台显示已经删除成功一条数据, 随后发生算数异常
image.png
但是可以看到, 虽然在发生算数异常之前已经删除了 id = 1 的用户, 但是之后异常回滚并没有污染数据.
image.png

2. @Transactional 注解参数

参数参数解释
value当配置了多个事务管理器时, 使用该属性指定选择那个事务管理器
transactionManager当配置了多个事务管理器时, 使用该属性指定选择那个事务管理器
propagation事务的传播行为, 默认值为 Propagation.REQUIRED
isolation事务的隔离级别, 默认值为 Isolation.DEFAULT
timeout事务的超时时间, 默认值为 -1, 表示没有超时时间.
当事务超过设定超时时间则自动进行事务回滚
readOnly指定事务是否为只读事务. 默认值为 false 不开启.
rollbackFor用于指定用于触发事务回滚的异常类型, 可以同时指定多个
rollbackForClassName用于指定用于触发事务回滚的异常类型, 可以同时指定多个
noRollbackFor触发指定异常则不会滚, 可以同时指定多个异常类型
noRollbackForClassName触发指定异常则不会滚, 可以同时指定多个异常类型

3. @Transactional 注解失效场景

虽然 @Transactional 注解用起来非常的香, 不管是加在类上还是方法上都是可以使用的. 但是它却有着很多意想不到的 " 坑 " 等着我们

3.1 非 public 修饰符修饰

@RequestMapping("del")
    @Transactional
    int del(Integer id) {
        if (id == null || id <= 0) return 0;
int result = userService.del(id);
int a = 10 / 0;
return result;
}

当我们不加 public 修饰符时, 普通的类中的方法默认访问权限是 default. 此时当我们再去访问这个路由方法时, 毋庸置疑它是会报错算数异常的.
image.png
刚刚说的, @Transactional 事务注解在发生异常时会主动回滚事务, 然而上数据库中查询后惊奇的发现, 回滚失效了. 这是为什么 ?
image.png

**在 Spring 中, 事务的管理是通过 AOP( 里面的环绕通知来实现的 ), 当一个方法被代理后, Spring 就会在该方法执行前后插入一系列的 AOP 代码, 从而进行管理. **
我们知道, AOP 是通过动态代理的实现的, 因此当方法为非 public 修饰时, 它不能直接被调用也就无法被代理, 也就无法被拦截和增强, 那么它的事务管理也就失效了.

3.2 timeout 超时

设置事务的超时时间为 3 秒

@RequestMapping("del")
    @Transactional(timeout = 3)
    int del(Integer id) throws InterruptedException {
        if (id == null || id <= 0) return 0;
        return userService.del(id);
    }

service 层中调用 del 方法是先休眠 5 秒

@Service
    public class UserService {
        @Autowired
        private UserMapper userMapper;

        public int del(Integer id) throws InterruptedException {
            int result = userMapper.del(id);
            // 休眠 5 秒
            TimeUnit.SECONDS.sleep(5);
            return result;
        }
    }

上面的代码可以看到, 写的是没有问题的, 没有异常出现, 此时去访问路由方法传入 id = 2, 预期超过了我们设置的超时时间, 它是会自动将事务进行回滚操作的.
当去访问这个路由方法时, 很明显是感觉到很慢的, 因为我们设置了休眠 5 秒
image.png

可以看到, 事务因为超时而没有执行原本的删除操作.
image.png

3.3 存在 try/catch 代码块

@RequestMapping("del")
    @Transactional()
    public int del(Integer id) throws InterruptedException {
        if (id == null || id <= 0) return 0;

        int result = 0;
        try {
            result = userService.del(id);
            int a = 10 / 0; // 设置异常
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

访问路由方法, 因为我设置了 catch, 因此将其进行了异常捕获, 页面未报错
image.png
由于我没有对异常进行进一步处理, 在控制台中进行了报错, 预期在数据库中会进行回滚, 不会删除 id = 2 的用户
image.png
然而此时却看到 id = 2 的用户已经被删除了, 没有进行事务的回滚.
image.png

究其原因, 可以知道, @Transactional 注解是使用 AOP 中的环绕通知实现的. 环绕通知中, @ControllerAdvice 控制通知会监测整个框架中的异常. 但是由于我们主动将异常进行捕获了, 并没有交给框架去处理, 从而导致控制通知未检测到, 认为事务正常执行了, 也就不会进行回滚操作了.
对于这种情况下, 我们可以手动的进行回滚事务

@RequestMapping("del")
    @Transactional()
    public int del(Integer id) throws InterruptedException {
        if (id == null || id <= 0) return 0;

        int result = 0;
        try {
            result = userService.del(id);
            int a = 10 / 0; // 设置异常
        } catch (Exception e) {
            // 对异常主动事务回滚处理
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
        return result;
    }

此时我们在尝试删除 id = 1 的用户, 控制台显示已经删除成功
image.png
可以看到, 由于对异常捕获后主动处理进行了回滚, 此时数据库中 id = 1 的用户还存在
image.png

除了主动回滚, 刚说到是由于控制监测没有监测到异常, 由于我们主动捕获但不做处理从而被吞噬了异常, 那么还可以将异常抛出去, 让它能够检测到异常从而主动进行回滚

@RequestMapping("del")
    @Transactional
    public int del(Integer id) throws InterruptedException {
        if (id == null || id <= 0) return 0;

        int result = 0;
        try {
            result = userService.del(id);
            int a = 10 / 0; // 设置异常
        } catch (Exception e) {
            throw e;
        }
        return result;
    }

image.png
此时报错了, 但是主动抛出异常给框架去感知, 它感知到异常主动回滚了.
image.png

3.4 同一个类中调用类内部的 @Transactional 方法

@RequestMapping("/test")
    public int test(Integer id) throws InterruptedException {
        return del(id);
    }

/**
* 该方法开启事务, 如果发生异常则进行事务回滚.
* 如果正常执行, 则提交事务
*/
@RequestMapping("/del")
    @Transactional
    public int del(Integer id) throws InterruptedException {
    if (id == null || id <= 0) return 0;

    int result = 0;
    result = userService.del(id);
    int a = 10 / 0; // 设置异常
    return result;
}

访问 user/test 方法时, 回去调用类里面的 del 方法, 该方法开启了事务, 并且有算数异常, 预期进行回滚不会删除数据
image.png
控制台显示删除成功, 但是由于出现异常, 预期该事务会主动进行回滚操作
image.png
上数据库中查看发现, 此时并没有进行回滚操作, 而执行了删除 id = 2 的操作.
image.png

3.5 不支持事务的数据库

在 MySQL 它是支持很多引擎的, 但是有一些是不支持事务的. 具体的我们可以通过指令来查看有哪些引擎
show engines
image.png

别时须清欢
关注
【Spring笔记08】Spring中的事务（编程式、声明式）
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
06-01 461
这篇文章，主要介绍Spring中的两种事务，编程式事务和基于XML方式的声明式事务。 目录 一、Spring中事务 1.1、什么是事务 1.2、Spring两种事务 （1）数据源配置 1.3、编程式事务 1.4、声明式事务 （1）XML中添加【tx】命名空间 （2）配置事务管理器 （3）配置事务通知 （4）配置事务切面 （5）编写事务处理类方法 （6）编写测试类 一、Spring中事务 1.1、什么是事务 事务，是指将很多件事情看成一个整体，这些事情要么全部执行成功，要么.
Spring声明式事务和编程式事务
qq_52896771的博客
02-02 389
我们现在要使用的事务管理器是org.springframework.jdbc.datasource.DataSourceTransactionManager，将来整合 Mybatis 用的也是这个类。既然事务控制的代码有规律可循，代码的结构基本是确定的，所以框架就可以将固定模式的代码抽取出来，进行相关的封装。TransactionManager接口中什么都没有，但是它还是有存在的意义——定义一个技术体系。封装起来后，我们只需要在配置文件中进行简单的配置即可完成操作。
【Spring】-编程式事务和声明式事务
一起加油吧~
04-17 2791
PlatformTransactionManager 事务管理器TransactionDefinition 事务属性优点：与业务逻辑分离：声明式事务管理将事务管理逻辑从业务代码中分离出来，使得业务逻辑更清晰，降低了代码的耦合性。配置简单：通过注解或XML配置，可以简单地定义事务的传播行为、隔离级别等属性，而无需在每个业务方法中编写重复的事务管理代码。易于维护：由于事务管理逻辑集中在配置中，易于维护和修改，提高了代码的可读性和可维护性。提高一致性。
Spring和Spring Boot事务讲解和案例示范
最新发布
J老熊
10-04 1224
Spring框架提供了强大的事务管理支持，使得开发者能够更轻松地实现事务控制。在本篇文章中，我们将深入探讨Spring的事务管理机制，特别是编程式事务管理、声明式事务管理以及在多数据源环境下的事务处理。
Spring中的编程式事务与声明式事务
m0_66918076的博客
04-24 6522
Spring中的编程式事务与声明式事务
Spring事务管理实现方式之编程式事务与声明式事务详解
热门推荐
半山闲人的专栏
04-12 5万+
1.编程式事务：编码方式实现事务管理（代码演示为JDBC事务管理） Spring实现编程式事务，依赖于2大类，分别是上篇文章提到的PlatformTransactionManager，与模版类TransactionTemplate（推荐使用）。下面分别详细介绍Spring是如何通过该类实现事务管 2.声明式事务：可知编程式事务每次实现都要单独实现，但业务量大功能复杂时，使用编程式事务无疑是痛苦的，而声明式事务不同，声明式事务属于无侵入式，不会影响业务逻辑的实现。
【第九章】 Spring的事务 之 9.3 编程式事务 ——跟我学spring3
jinnianshilongnian的专栏
03-06 447
9.3  编程式事务 9.3.1  编程式事务概述        所谓编程式事务指的是通过编码方式实现事务，即类似于JDBC编程实现事务管理。        Spring框架提供一致的事务抽象，因此对于JDBC还是JTA事务都是采用相同的API进行编程。   java代码： Connection conn = null; UserTransaction tx = nu...
Spring的编程式事务和声明式事务详解
08-29
Spring框架提供了两种事务管理机制：编程式事务和声明式事务。编程式事务是通过编写代码来管理事务，声明式事务则是通过配置文件或注解来管理事务。 事务属性 Spring的事务属性是通过TransactionDefinition接口...
Spring编程式和声明式事务实例讲解小结
08-25
* 基于TransactionInterceptor的声明式事务：Spring声明式事务的基础，通常也不建议使用这种方式。 * 基于TransactionProxyFactoryBean的声明式事务：第一种方式的改进版本，简化了配置文件的书写。 * 基于和命名...
spring 自定义事务管理器，编程式事务，声明式事务@Transactional使用
07-13
本教程将深入探讨如何在Spring中实现自定义事务管理器、编程式事务处理以及声明式事务`@Transactional`的使用。 首先，让我们了解事务管理的基本概念。事务是一组数据库操作，这些操作要么全部执行，要么全部回滚，...
Spring声明式事务和@Aspect的拦截顺序问题的解决
08-27
Spring 框架中，声明式事务和 @Aspect 都可以用于实现Aspect-Oriented Programming（面向方面编程），但是它们的拦截顺序问题往往会导致很多问题。本文将详细介绍 Spring 声明式事务和 @Aspect 的拦截顺序问题的解决...
spring编程式事务实现
07-30
演示了spring编程式事务的实现，通过TransactionTemplate模板进行事务控制
声明式事务及编程式事务
m0_72167535的博客
08-20 974
声明式事务及编程式事务
编程式事务 与 声明式事务
专注于Groovy语言，grails框架与管理之道
10-23 2677
采用声明式事务1、了解事务的传播特性 1、propagation_required:如果当前存在一个事务，则支持当前事务，如果没有事务则开启事务 2、propagation_supports:如果存在一个事务，则支持当前事务，如果没有事务则非事务执行 3、propagation_mandatory:如果存在一个事务，则支持当前事务，如果没有事务则抛出异常 4、propagation_requi
Spring | 事务原理与实践 - 声明式事务及编程式事务
StudyBrainEx
09-24 1116
事务是由数据库管理系统在执行过程中形成的一个逻辑单位，它由一组有限的数据库操作序列组成。通常情况下，事务是由程序单元通过高级语言或数据库的数据操作语言提交的。至此，本篇结束。本文全面深入地探讨了Spring事务的原理、管理类型、深度剖析以及在复杂业务场景中的应用。通过对Spring事务的深度剖析和实际应用案例的探讨，我们可以更加清晰、准确地理解Spring事务在实际开发中的运用，更加灵活地处理各种复杂的业务场景。在实际开发过程中，精确地把握事务边界、合理配置事务属性以及灵活应用分布式事务是至关重要的。
Spring的编程式事务和声明式事务
酸酸酱的博客
10-12 582
spring事务管理的API platfformTransactionManager 平台事务管理器 平台事务管理器： 接口 是spring用于管理事务的真正的对象 DataSourceTransactionManager: 底层使用JDBC管理事务 HibernateTransactionManager: 底层使用Hibernate管理事务 TransactionDefinition 事务定...
Spring系列之spring中编程式事务怎么用的？
azhou的代码园
05-16 1616
本文内容 详解spring中编程式事务的使用。 spring中使用事务的2种方式 spring使事务操作变的异常容易了，spring中控制事务主要有2种方式 编程式事务：硬编码的方式 声明式事务：大家比较熟悉的注解@Transaction的方式 编程式事务 什么是编程式事务？ 通过硬编码的方式使用spring中提供的事务相关的类来控制事务。 编程式事务主要有2种用法 方式1：通过PlatformTransactionManager控制事务 方式2：通过Tran
Spring编程式事务管理
angou6476的博客
05-27 75
以下内容引用自http://wiki.jikexueyuan.com/project/spring/transaction-management/spring-programmatic-transaction-management.html： 编程式事务管理方法允许你在源代码编程的方式下管理事务。虽然带来了极大地灵活性，但是它很难维护。 实践前提： 1、在MySql新建Studen...
Spring系列第43篇：spring中编程式事务怎么用的？
GitHub质检员
08-30 317
通过硬编码的方式使用spring中提供的事务相关的类来控制事务。大家看了之后，会觉得这样用好复杂啊，为什么要这么玩？的确，看起来比较复杂，代码中融入了大量spring的代码，耦合性比较强，不利于扩展，本文的目标并不是让大家以后就这么用，主要先让大家从硬编码上了解spring中事务是如何控制的，后面学起来才会更容易。我们用的最多的是声明式事务，声明式事务的底层还是使用上面这种方式来控制事务的，只不过对其进行了封装，让我们用起来更容易些。下篇文章将详解声明式事务的使用。
Spring编程式与声明式事务详解：实战转账业务
1. **基于TransactionInterceptor的声明式事务**：这是Spring声明式事务的基础，虽然有助于理解事务机制，但实际开发中已不太常用，因为配置复杂度较高。 2. **基于TransactionProxyFactoryBean的声明式事务**：...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值