Spring事务（1）

最新推荐文章于 2025-06-03 16:57:53 发布
最新推荐文章于 2025-06-03 16:57:53 发布
阅读量1.5k 收藏 53
点赞数 53
CC 4.0 BY-SA版权
分类专栏： Java EE进阶 文章标签： spring java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cool_tao6/article/details/140613522

目录

一、事务回顾

1、什么是事务？

2、为什么需要事务？

3、事务的操作

二、Spring 中事务的实现

1、代码准备：

（1）创建项目 spring-trans，引入 Spring Web，MyBatis，MySQL等依赖

（2）配置文件

（3）实体类

（4）Mapper

（5）Service

（6）Controller

2、Spring编程式事务（了解）

（1）观察事务提交

（2）观察事务回滚

3、Spring 声明式事务 @Transactional

（1）添加依赖

（2）在需要事务的方法上添加 @Transactional 注解

（3）Transactional 作用

1、重新抛出异常

2、手动回滚事务

一、事务回顾

        事务是在数据库阶段学习的内容，也是数据库里的机制。

1、什么是事务？

        事务是一组操作的集合，是一个不可分割的操作。

        事务会把所有的操作作为一个整体，一起向数据库提交或者是撤销操作请求。所以这组操作要么同时成功，要么同时失败。

2、为什么需要事务？

        我们在进行程序开发时，也会有事务的需求。

        比如转账操作：

第一步：A 账户 - 100元。    第二步：B 账户 + 100元。

        如果没有事务，第一步执行成功了，第二步执行失败了，那么 A账户的100元就平白无故消失了。如果使用事务就可以解决这个问题，让这个组操作要么一起成功，要么一起失败。

        比如秒杀系统：

第一步：下单成功。     第二步：扣减库存。

        下单成功后，库存也需要同步减少。如果下单成功，库存扣减失败，那么就会造成下单超出的情况。所以就需要把这两部操作放在同一个事务中。要么一起成功，要么一起失败。

        这里理解事务概念为主，实际企业开发时，并不是简单的通过事务来处理。

3、事务的操作

        事务的操作主要有三步：

1、开启事务 start transaction / begin（一组操作前开启事务）

2、提交事务：commit（这组操作全部成功，提交事务）

3、回滚事务：rollback（这组操作中间任何一个操作出现异常，回滚事务）

-- 开启事务
start transaction;

-- 提交事务
commit;

-- 回滚事务
rollback;

二、Spring 中事务的实现

        Spring 对事务也进行了实现，Spring 中的事务操作分为两类：

1、编程式事务（手动写代码操作事务）。

2、声明式事务（利用注解自动开启和提交事务）。

        在学习事务之前，我们先准备数据和数据的访问代码

需求：用户注册，注册时在日志表中插入一条操作记录。

-- 创建数据库
DROP DATABASE IF EXISTS trans_test;

CREATE DATABASE trans_test DEFAULT CHARACTER SET utf8mb4;

use trans_test;

-- 用户表
DROP TABLE IF EXISTS user_info;
CREATE TABLE user_info (
        `id` INT NOT NULL AUTO_INCREMENT,
        `user_name` VARCHAR (128) NOT NULL,
        `password` VARCHAR (128) NOT NULL,
        `create_time` DATETIME DEFAULT now(),
        `update_time` DATETIME DEFAULT now() ON UPDATE now(),
        PRIMARY KEY (`id`)
) ENGINE = INNODB DEFAULT CHARACTER
SET = utf8mb4 COMMENT = '用户表';

-- 操作日志表
DROP TABLE IF EXISTS log_info;
CREATE TABLE log_info (
        `id` INT PRIMARY KEY auto_increment,
        `user_name` VARCHAR ( 128 ) NOT NULL,
        `op` VARCHAR ( 256 ) NOT NULL,
        `create_time` DATETIME DEFAULT now(),
        `update_time` DATETIME DEFAULT now() ON UPDATE now()
) DEFAULT charset 'utf8mb4';

1、代码准备：

（1）创建项目 spring-trans，引入 Spring Web，MyBatis，MySQL等依赖

（2）配置文件

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/trans_test?characterEncoding=utf8&useSSL=false
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver
mybatis:
  configuration: # 配置打印 MyBatis⽇志
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    map-underscore-to-camel-case: true #配置驼峰⾃动转换

（3）实体类

import lombok.Data;
import java.util.Date;

@Data
public class UserInfo {
    private Integer id;
    private String userName;
    private String password;
    private Date createTime;
    private Date updateTime;
}
import lombok.Data;
import java.util.Date;

@Data
public class LogInfo {
    private Integer id;
    private String userName;
    private String op;
    private Date createTime;
    private Date updateTime;
}

（4）Mapper

        UserInfoMapper

@Mapper
public interface UserInfoMapper {
    @Insert("insert into user_info(user_name, password) values (#{name}, #{password})")
    Integer insert(String name, String password);
}

        LogInfoMapper

@Mapper
public interface LogInfoMapper {
    @Insert("insert into log_info(user_name, op) values (#{name}, #{op})")
    Integer insertLog(String name, String op);
}

（5）Service

        UserService:

@Service
public class UserService {
    @Autowired
    private UserInfoMapper userInfoMapper;
    public Integer registry(String name, String password) {
        return userInfoMapper.insert(name, password);
    }
}

        LogService:

@Service
public class LogService {
    @Autowired
    private LogInfoMapper logInfoMapper;

    public void insertLog(String name, String op) {
        //记录用户操作
        logInfoMapper.insertLog(name, "用户注册");
    }
}

（6）Controller

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

    @Autowired
    private UserService userService;

    @RequestMapping("/registry")
    public Boolean registry(String name, String password) {
        //用户注册
        Integer ret = userService.registry(name, password);
        return true;
    }
}

2、Spring编程式事务（了解）

        Spring 手动操作事务和上面 MYSQL操作事务类似，有3个重要操作步骤：

1、开启事务（获取事务）

2、提交事务

3、回滚事务

        SpringBoot 内置了两个对象：

1、DataSourceTransactionManager 事务管理器。用来获取事务（开启事务），提交或回滚事务。

2、TransactionDefinition 是事务的属性，在获取事务的时候需要将 TransactionDefinition 传递进去，从而获得一个事务 TransactionStatus。

        下面根据代码的实现来学习：

@RequestMapping("/user")
@RestController
public class UserController {
    //JDBC 事务管理器
    @Autowired
    private DataSourceTransactionManager dataSourceTransactionManager;
    //定义事务属性
    @Autowired
    private TransactionDefinition transactionDefinition;

    @Autowired
    private UserService userService;

    @RequestMapping("/registry")
    public Boolean registry(String name, String password) {
        //开启事务
        TransactionStatus transactionStatus = dataSourceTransactionManager.getTransaction(transactionDefinition);
        //用户注册
        Integer ret = userService.registry(name, password);
        //提交事务
        dataSourceTransactionManager.commit(transactionStatus);
        //回滚事务
        //dataSourceTransactionManager.rollback(transactionStatus);
        return true;
    }
}

（1）观察事务提交

        //提交事务
        dataSourceTransactionManager.commit(transactionStatus);

        运行程序：127.0.0.1:8080/user/registry?name="lisi"&&password="123"

（2）观察事务回滚

        //回滚事务
        dataSourceTransactionManager.rollback(transactionStatus);

        运行程序：127.0.0.1:8080/user/registry?name="zhangsan"&&password="1234"

        数据库没多出数据：

        和事务提交相比，日志少了一行。

        以上代码虽然可以实现事务，但操作也很繁琐，有没有更简单的实现方法呢？接下来我们学习声明式事务（注解）。

3、Spring 声明式事务 @Transactional

        声明式事务的实现很简单，两步操作：

（1）添加依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
</dependency>

（2）在需要事务的方法上添加 @Transactional 注解

        无需手动开启事务和提交事务，进入方法时自动开启事务。方法执行完会自动提交事务，如果中途发生了没有处理的异常会自动回滚事务。

        我们来看代码的实现：

@RequestMapping("/trans")
@RestController
public class TransactionalController {
    @Autowired
    private UserService userService;

    @Transactional
    @RequestMapping("/registry")
    public String registry(String name, String password) {
        //用户注册
        Integer ret = userService.registry(name, password);
        if(ret > 0) return  "注册成功";
        return "注册失败";
    }
}

        运行程序：127.0.0.1:8080/trans/registry?name="wangwu"&&password="12345"，发现数据插入成功。

现在修改程序，使之出现异常：

@RequestMapping("/trans")
@RestController
public class TransactionalController {
    @Autowired
    private UserService userService;

    @Transactional
    @RequestMapping("/registry")
    public String registry(String name, String password) {
        //用户注册
        Integer ret = userService.registry(name, password);
        //强制程序抛出异常
        int a = 10/0;
        if(ret > 0) return  "注册成功";
        return "注册失败";
    }
}

        运行程序：127.0.0.1:8080/trans/registry?name="wangwu"&&password="12345"，发现数据插入失败。事务发生回滚了。

        上面因为有异常，事务回滚了。

        我们一般会在业务逻辑层当中来控制事务，因为在业务逻辑层当中，一个业务功能可能会包含多个数据访问的操作。在业务逻辑层来控制事务，我们就可以将多个数据访问操作控制在一个事务范围内。上述代码在Controller中书写，只是为了方便学习。

（3）Transactional 作用

        @Transactional 可以用来修饰方法或类：

1、修饰方法时：只有修饰 public 方法时才生效（修饰其他方法时不会报错，也不生效）。[推荐]

2、修饰类时：对 @Transactional 修饰的类中所有的 public 方法都生效。

        方法 / 类被 @Transactional 注解修饰时，在目标方法执行开始前，会自动开启事务，方法执行结束之后，自动提价事务。

        如果在方法执行过程中，出现异常，且异常未被捕获，就进行事务回滚操作。

        如果异常被程序捕获，方法就被认为是成功执行，依然会提交事务。

修改上述代码，对异常进行捕获：

@RequestMapping("/trans")
@RestController
public class TransactionalController {
    @Autowired
    private UserService userService;

    @Transactional
    @RequestMapping("/registry")
    public String registry(String name, String password) {
        //用户注册
        Integer ret = userService.registry(name, password);
        //捕获异常
        try {
            int a = 10/0;
        } catch (Exception e) {
            e.printStackTrace();
        }
        if(ret > 0) return  "注册成功";
        return "注册失败";
    }
}

        运行程序：127.0.0.1:8080/trans/registry?name="zhaoliu"&&password="12345"，数据库新增了一行数据

        说明事务没有回滚，而是提交事务了。

        上面运行程序，发现虽然程序出错了，但是由于异常被捕获了，所以事务依然得到了提交。如果需要事务进行回滚，有以下两种方式：

1、重新抛出异常

2、手动回滚事务

1、重新抛出异常
@RequestMapping("/trans")
@RestController
public class TransactionalController {
    @Autowired
    private UserService userService;

    @Transactional
    @RequestMapping("/registry")
    public String registry(String name, String password) {
        //用户注册
        Integer ret = userService.registry(name, password);
        //强制程序抛出异常
        try {
            int a = 10/0;
        } catch (Exception e) {
//            e.printStackTrace();
            //将异常抛出去
            throw e;
        }
        if(ret > 0) return  "注册成功";
        return "注册失败";
    }
}

        运行程序：127.0.0.1:8080/trans/registry?name="zhaoliu"&&password="12345"，发现

        手动抛出异常后，说明事务回滚了。（异常并没有被捕获）

2、手动回滚事务

        使用 TransactionAspectSupport.currentTransactionStatus() 得到当前事务，并使用 SetRollbackOnly 设置 setRollbackOnly。

@RequestMapping("/trans")
@RestController
public class TransactionalController {
    @Autowired
    private UserService userService;

    @Transactional
    @RequestMapping("/registry")
    public String registry(String name, String password) {
        //用户注册
        Integer ret = userService.registry(name, password);
        //强制程序抛出异常
        try {
            int a = 10/0;
        } catch (Exception e) {
//            e.printStackTrace();
            //将异常抛出去
//            throw e;
            //手动回滚事务
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
        if(ret > 0) return  "注册成功";
        return "注册失败";
    }
}

        运行程序：127.0.0.1:8080/trans/registry?name="zhaoliu"&&password="12345"，发现事务回滚了。

Spring手动开启事务提交事务
BUG指挥课堂
05-22 4097
但是，有时候我们需要手动开启事务，以便更细粒度地控制事务的边界。需要注意的是，TransactionCallbackWithoutResult是一个抽象类，其中的doInTransactionWithoutResult方法是一个抽象方法，你需要在其中实现你的业务逻辑代码。通过以上的方式，你就能手动开启事务并进行事务的操作了。在Spring中，事务是通过TransactionTemplate或者注解的方式来管理的。以上两种方法都可以实现手动开启事务的功能，具体选择哪种方法取决于项目的需求和开发团队的偏好。
Spring 手动管理事务
After 95
08-05 1028
import com.neo.model.pojo.product.online.ProductOnline; import com.neo.repository.product.online.ProductOnlineMapper; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.datasourc
手动管理Spring事务
liutao146593的博客
12-16 825
手动管理Spring事务
Spring 中如何开启事务？
最新发布
残影的博客
06-03 759
在 Java 后端面试中，Spring 事务管理是中高级工程师绕不开的话题。面试官不仅想知道你是否会用，更关注你是否理解其作用范围、事务传播机制、异常回滚条件、底层 AOP 实现等细节。理解 Spring 事务的原理与配置，不仅能帮你在面试中脱颖而出，更能在实际开发中避免经典“假提交、未回滚、事务失效”等隐性 Bug。Spring 事务不是仅靠就能解决一切问题，理解其原理 + 范围 + 异常机制 + AOP 动态代理才是硬实力；
spring 手动开启事务
qq_40929531的博客
03-08 1812
【代码】spring 手动开启事务。
spring手动控制事务
lockie的博客
10-15 4613
实际项目中要实现spring的事务大多数我们都是使用 @Transactional(rollbackFor = Exception.class) 注解即可，但是有些业务场景需要我们手动处理事务我们就可以这样： //开启事务 DefaultTransactionDefinition defaultTransactionDefinition = new DefaultTransactionDefinition(); // 嵌套事务 defaultTransactionDefinition.setPropag
spring事务1
08-08
1. **编程式事务管理**： 编程式事务管理是指在代码中显式地进行事务开始、提交和回滚等操作。例如，使用JDBC时，通常会设置`Connection.setAutoCommit(false)`来禁用自动提交，然后在适当的时候调用`commit()`或`...
Spring事务处理原理步骤详解
08-19
Spring事务处理原理步骤详解 Spring事务处理原理步骤详解是指在Spring框架中实现事务处理的整个过程，它涉及到事务处理的实现、事务处理原理和事务管理器的配置等几个方面。下面是Spring事务处理原理步骤详解的知识...
Spring事务流程图
06-04
Spring事务管理是Spring框架的核心特性之一，主要用于处理应用程序中的数据一致性问题。在Spring中，事务管理分为编程式和声明式两种方式。本篇文章将详细解释Spring事务管理的流程，以及如何通过时序图来理解这一...
深入理解Spring事务原理
09-02
Spring事务管理是Spring框架的核心特性之一，它使得开发者能够在应用层面上轻松地处理数据库事务，无需直接接触底层的事务控制。本文将深入探讨Spring事务原理，包括事务的基本概念、Spring事务的传播属性、数据库...
spring 事务传播 demo
06-05
1. **PROPAGATION_REQUIRED**：这是默认的传播行为，表示如果当前存在事务，则加入该事务；如果不存在，则创建一个新的事务。这也是最常用的模式。 2. **PROPAGATION_SUPPORTS**：如果当前存在事务，那么运行在该...
使用spring手动控制事务
weixin_33671935的博客
09-01 162
前言：    建议不要使用spring自动控制事务，一般不需要回滚的DAO方法（如查询），建议不要使用事务，由于使用事务的时候，会锁住表，过多的使用事务，可能会出现死锁的现象。单条更新语句也不需要使用事务，数据库会自动回滚。    使用spring手动控制事务  Java代码     private DataSourceTransactionManager transactio...
Spring 事务
lfm1010123的博客
10-31 2830
一、Spring 事务的实现方式 二、Spring 事务的隔离级别 三、Spring 事务的传播机制
在Spring中如何手动开启事务（使用编程式事务）
白羊座的橙子
06-13 1416
一、使用 transactionManager1、向容器中注入事务管理器2、使用 transactionManager 提交事务3、测试二、使用TransactionTemplate1、向容器中注入 TransactionTemplate2、开启事务。
Spring手动开启事务
qq_44505797的博客
06-06 4875
开发工具与关键技术： Java 作者：肖广斌 撰写时间：2021年5月18日 事务是什么呐？ 事务（Transaction），一般是指要做的或所做的事情。事务是访问数据库的一个操作序列，数据库应用系统通过事务集来完成对数据库的存取。事务的正确执行使得数据库从一种状态转换成另一种状态。 为什么要用事务？ 事务是为解决数据安全操作提出的，事务控制实际上就是控制数据的安全访问。 举一个简单点的例子：就是支付宝转账业务，A账号要给B账号转200块，A账号少200，B账号要加200，假如转账过程中网络出现错误，A账号
spring如何手动开启事务
扶摇而上九万里
05-10 1228
private final TransactionTemplate transactionTemplate; void test(){ transactionTemplate.execute((status) -> { //具体业务 return Boolean.TRUE; }); }
spring手动控制事务开启_Spring+Mybatis 手动控制事务
weixin_34158442的博客
12-24 435
@OverridepublicbooleantestDelete(StringjobCode)throwsException {booleanflag=false;//1.获取事务控制管理器DataSourceTransactionManagertransactionManager= HqznContext.getBean("transactionManager", DataSourceTrans...
spring手动使用事务
b13001216978的博客
12-15 1020
spring项目手动控制事务（非分布式事务） 先上代码： @Autowired private PlatformTransactionManager platformTxManager ; @RequestMapping("/testPlatformTransactionManager ") public int testPlatformTransactionManager (){ DefaultTransactionDefinition txDefinition = new Default.
SpringBoot中如何手动开启事务
m0_74825223的博客
02-28 787
一、使用 TransactionTemplate1、配置 TransactionTemplate2、使用 TransactionTemplate二、使用 PlatformTransactionManager 直接管理事务1、注入 PlatformTransactionManager在Spring Boot中，虽然大多数情况下推荐使用@Transactional注解来管理事务，但有时需要更灵活地手动控制事务。
评论 41
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

tao滔不绝

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

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

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

打赏作者

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

抵扣说明：

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

余额充值