Spring的事务管理

最新推荐文章于 2025-08-13 22:07:55 发布
原创 最新推荐文章于 2025-08-13 22:07:55 发布 · 191 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #事务管理

本文深入探讨Spring框架下的事务管理，包括事务的概念、特性和隔离级别，详细解析Spring的事务管理API，展示如何通过编程式事务管理和声明式事务管理来控制事务的传播行为。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Spring的事务管理

一、事务回顾

  1. 什么是事务
    • 事务：逻辑上的一组操作，组成这组操作的各个单元，要么全做，要么全不做
  2. 事务的特性
    • 原子性：事务不可分割
    • 一致性：事务执行前后数据完整性保持一致
    • 隔离性：一个事务的执行不应该受到其他事务的干扰
    • 持久性：事务一旦成功，数据就用持久化到数据库
  3. 如果不考虑隔离性引发的安全性问题
  • 读问题
    • 脏读：一个事物读到了另一个事务未提交的数据
    • 不可重复读：一个事务读到另一个事务已经提交的update的数据，导致一个事务中多次查询结果不一致
    • 虚读，幻读：一个事务读到另一个事务已提交的insert的数据，导致一个事务中多次查询结果不一致
  • 写问题
    • 丢失更改
  1. 解决读问题
    • 设置事务隔离级别
      • Read uncommitted：读未提交，任何问题都解决不了。效率高，安全性低。
      • Read committed：读提交，解决脏读，但是不可重复读和虚读有可能发生。（Oracle 默认隔离级别）
      • Repeatable read:重复读，解决脏读和不可重复读，但是虚读可能发生（MySQL 默认隔离级别）
      • Serializable：解决所有读问题，不允许事务并发。

二、Spring的事务管理API

  1. PlatformTransactionManager:平台事务管理器
    • 平台事务管理器：是一个接口，是spring用于管理事务的真正的对象
      • DataSourceTransactionManager:底层使用了JDBC来管理事务时使用
      • HibernateTransactionManager:底层使用了Hibernate管理事务时使用
  2. TransactionDefinition:事务定义信息
    • 事务定义：用于定义事务的相关信息如隔离级别、超时信息、传播行为、是否只读
  3. TransactionStatus：事务的状态
    • 事务状态：用于记录事务在事务管理过程中，事务的状态对象
  4. 事务管理的API的关系
    • Spring进行事务管理的时候，首先事务平台管理器根据事务定义信息进行事务的管理，产生各种状态，将这些状态的信息记录到事务状态的对象中

三、Spring的事务传播行为

  1. Spring中提供了七种事务的传播行为

如果遇到了特别复杂的业务逻辑，有可能出现业务层之间的相互调用，事务的传播行为主要用来解决业务层方法相互调用问题

  • 保证多个操作在同一个事务中
    • PROPAGATION_REQUIRED : 默认值，B调用了A，如果A中有事务，使用A中的事务，如果A中没有事务，创建一个新的事务，将操作包含进来
    • PROPAGATION_ SUPPORTS ：支持事务，如果A中有事务，使用A中的事务，如果A中没有事务就不使用事务
    • PROPAGATION_ MANDATORY：如果A中有事务，使用A中的事务，如果A中没有事务则抛出异常
  • 保证多个操作不在同一个事务中
    • PROPAGATION_REQUIRES_NEW: 如果A中有事务，将A的事务挂起，创建新事物，只包含自身操作。如果A中没有事务，创建一个新事务，只包含自身操作。
    • PROPAGATION_ NOT_ SUPPORTED:如果A中有事务，将A的事务挂起。不使用事务管理
    • PROPAGATION_ NEVER:如果A中有事务，抛出异常
  • 嵌套式事务
  • PROPAGATION_NESTED:如果A中有事务，按照A的事务执行，执行完成之后，设置一个保存点，执行B中的操作，如果没有异常执行通过，如果有异常可以选择回滚到最初时，也可以回滚到保存点。

四、事务管理

  1. 搭建Spring的事务管理环境,演示转账
    • 创建数据库与表，初始化一些数据
    • 创建实体对象
    • 创建Service的接口和实现类
    • 创建Dao的接口和实现类
    • 配置Service和Dao，交给Spring，及其他
CREATE TABLE `account` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `name` varchar(20) COLLATE utf8mb4_bin DEFAULT NULL,
      `money` double DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) 

public class Account {
    private Integer id;
    private String name;
    private Double money;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}


public interface AccountService {
    /**
     * 转账
     * @param form 转出账号
     * @param to 转入账号
     * @param money 金额
     */
    void transfer(String form,String to,Double money);
}

public class AccountServiceImpl implements AccountService {
    @Resource(name = "accountDao")
    private AccountDao accountDao;

    @Override
    public void transfer(String form, String to, Double money) {
        accountDao.outMoney(form,money);
        // 人为异常，测试异常转账时打开
       // int 5/0;
        accountDao.inMoney(to,money);
    }
}

public interface AccountDao {
    /**
     * 转出
     * @param from
     * @param money
     */
    void outMoney(String from ,Double money);

    /**
     * 转入
     * @param to
     * @param money
     */
    void inMoney(String to ,Double money);
}

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>edu.xufe</groupId>
  <artifactId>springdemo08</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>springdemo08 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <spring.version>4.3.18.RELEASE</spring.version>
    <mysql.version>5.1.8</mysql.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>


    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</version>
    </dependency>


    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
      <scope>compile</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/log4j/log4j -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.2</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!--  druid相关pom-->
    <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.10</version>
    </dependency>

  </dependencies>
  <build>
    <finalName>springdemo08</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>


<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
   <!-- 配置service-->
    <bean id="accountService" class="edu.xufe.tx.service.impl.AccountServiceImpl" >
        <property name="accountDao" ref="accountDao"/>
    </bean>
    <!--配置Dao-->
    <bean id="accountDao" class="edu.xufe.tx.dao.impl.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--第二种方式 通过context标签引入-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--配置Druid连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
</beans>
  1. 编辑测试类：模拟转账及转账过程中出现了异常，查看数据库中的变化
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class AccountServiceTest {
    @Resource(name = "accountService")
    private AccountService accountService;

    @Test
    public void testTransfer() {
        accountService.transfer("如花","如花1",500d);
    }
}

五、Spring的事务管理：编程式事务（需要手动写代码）

  1. 配置平台事务管理器
 <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
  1. Spring提供了事务管理的模板类
    • 配置事务管理的模板类
    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
    <property name="transactionManager" ref="transactionManager"/>
</bean>
  2. 在业务层注入事务管理的模板
public class AccountServiceImpl implements AccountService {
    /**
     * 注入Dao
     */
    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    /**
     * 注入事务管理的模板
     */
    private TransactionTemplate transactionTemplate;

    public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
        this.transactionTemplate = transactionTemplate;
    }

    @Override
    public void transfer(String form, String to, Double money) {
        accountDao.outMoney(form,money);
        // 人为异常，测试异常转账时打开
       // int 5/0;
        accountDao.inMoney(to,money);
    }
}

<!-- 配置service-->
    <bean id="accountService" class="edu.xufe.tx.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
        <property name="transactionTemplate" ref="transactionTemplate"/>
    </bean>
  1. 编写事务管理代码
public class AccountServiceImpl implements AccountService {
    /**
     * 注入Dao
     */
    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    /**
     * 注入事务管理的模板
     */
    private TransactionTemplate transactionTemplate;

    public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
        this.transactionTemplate = transactionTemplate;
    }

    @Override
    public void transfer(final String form, final String to, final Double money) {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
                accountDao.outMoney(form,money);
                // 人为异常，测试异常转账时打开
                // int 5/0;
                accountDao.inMoney(to,money);
            }
        });


    }
}
  1. 测试。模拟转账正常和转账发生异常情况

源代码github：https://github.com/greatdistance/spring_project_demo/tree/master/springdemo08

分析Spring事务管理原理及应用
张彦峰的博客
04-10 5万+
通过配置已经大体知道了spring事务管理实现的原理就是AOP，不难推测，spring会提供实现事务管理相关功能的切面，切点和通知相关的类，来完成对于事务相关功能的支持。我们以配置最简单的注解式配置为例，分析其实现方式。
万字长文深入理解Spring事务管理：配置、实现与最佳实践
学而时习之，不亦说乎？温故而知新，可以为师矣！
08-08 9951
Spring事务管理是企业级应用开发中的关键技术之一，确保数据一致性和完整性。本文将全面介绍Spring事务管理的基本概念、配置方式、实现原理及常见应用。通过详细的示例代码和源码解析，读者将深入理解Spring事务管理的工作机制，掌握如何在实际项目中配置和优化事务管理，实现高效可靠的事务处理。
Spring事务管理
几许的博客
09-01 927
Spring提供的事务管理是数据层的事务还是业务层的事务?
Spring事务管理详解
热门推荐
java123456111的博客
05-24 1万+
什么是事务 事务是逻辑上的一组操作，要么都执行，要么都不执行。 需要注意的是：事务能否生效数据库引擎是否支持事务是关键。比如常用的 MySQL 数据库默认使用支持事务的 innodb引擎。但是，如果把数据库引擎变为 myisam，那么程序也就不再支持事务了！ 事务的特性（ACID） 原子性：一个事务（transaction）中的所有操作，或者全部完成，或者全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。即，事务
记spring事务管理的配置
m0_59250245的博客
08-26 1151
记录下spring配置类相关注解和设置，了解导入依赖的作用。
Spring 事务管理详解：机制与实现
lssffy的博客
10-04 1857
事务（Transaction）是指一个操作序列，必须被作为一个单元来执行，即该操作序列中的所有操作要么全部执行成功，要么全部回滚。事务的主要特性被称为ACID原子性（Atomicity）：事务中的所有操作要么全部完成，要么全部取消。一致性（Consistency）：事务完成时，数据库从一个一致状态转换到另一个一致状态。隔离性（Isolation）：不同事务之间相互独立，互不干扰。持久性（Durability）：事务完成后，数据的变更是永久性的。
Spring 事务管理配置方法
jingde528的博客
07-11 1015
Spring中声明式的事务配置方法有两种，一种是注解方式，另一种可能用AOP切片方式来实现。
Spring事务管理与Spring AOP详解
Java领域优秀创作者
06-17 853
在企业级应用开发中，事务管理和面向切面编程（AOP）是两个至关重要的概念。Spring框架作为Java企业级应用的首选框架之一，为事务管理和AOP提供了强大的支持。本文将详细解析Spring的事务管理和Spring AOP，让读者能够深入理解其工作原理、应用场景及实现方式。
深入理解 Spring 事务管理及其配置
2302_80084329的博客
09-14 1397
Spring 事务管理是现代企业级应用中不可或缺的一部分。通过事务管理，开发者可以保证一系列的数据库操作要么全部成功，要么全部回滚，确保数据一致性。在本文中，我们将讨论 Spring 事务管理的角色、配置以及常见的事务传播行为。
Spring 事务管理简介
qq_65249767的博客
05-04 3042
Spring 事务管理简介
spring事务管理
10-27
### Spring事务管理详解 #### 一、Spring事务管理概述 Spring框架提供了强大的事务管理功能，使得开发者能够更方便地管理应用程序中的事务。Spring事务管理主要包括两种类型：编程式事务管理和声明式事务管理。 -...
Spring事务管理Demo
05-01
Spring事务管理的目的是确保数据的一致性和完整性，尤其是在多操作、多资源的环境中。本Demo将深入探讨Spring如何实现事务的管理。 首先，Spring提供了两种主要的事务管理方式：编程式事务管理和声明式事务管理。 ...
Spring事务管理-积分功能实现
03-23
基于tx命名空间的声明式事务管理案例
Spring事务管理开发必备jar包
03-07
本资源包提供了进行Spring事务管理开发所需的所有关键库，包括框架基础、核心组件、AOP（面向切面编程）支持、日志处理、编译工具以及与数据库交互的相关jar包。下面将对这些知识点进行详细解释： 1. **Spring框架*...
【SpringBoot系列-02】自动配置机制源码剖析
最新发布
专注后端技术架构，AI技术分享
08-13 130
Spring Boot自动配置机制深度解析：通过@SpringBootApplication注解中的@EnableAutoConfiguration启动自动配置流程，核心由AutoConfigurationImportSelector实现。该选择器从META-INF/spring.factories加载候选配置类，经过去重、排除处理、条件过滤等步骤（包括@ConditionalOnClass等条件注解的评估），最终筛选出符合条件的配置类注册到Spring容器。整个过程体现了约定优于配置的设计理念，开发者可通
SpringBoot手写操作日志自动记录功能
2403_87729201的博客
08-10 379
本文介绍了基于SpringAOP的操作日志自动记录方案。通过自定义@LogAnnotation注解和切面编程，实现业务方法零侵入的日志记录功能。方案包含数据库表设计（sys_log）、自定义注解定义、核心切面实现（LogAspect）及配套工具类（HttpContextUtil、IPUtil）。使用时只需在Controller方法上添加注解，切面会自动记录操作人、方法信息、参数、耗时等数据并存入数据库。该方案解决了手动记录日志的繁琐问题，提供完整的操作审计能力，执行流程涵盖请求处理全过程。
Spring IoC实现原理详解
Rockandrollman的博客
08-12 921
Spring IoC实现原理详解
基于SpringBoot校园管理系统
2501_90968670的博客
08-13 468
校园管理系统是一个基于Spring Boot + Vue.js的全栈应用，专注于高校内部的多角色协作管理。系统实现了院校管理、单位管理、用户管理、通知推送、投票管理等功能模块，满足管理员、院校管理员、普通用户三类角色的不同操作需求。核心目标是提升校园管理效率，实现通知精准推送与数据可视化统计。
Java 反射技术：企业级开发框架Spring的 “隐形引擎“
qq_20294455的博客
08-10 659
摘要： Java反射技术是突破编译期限制的底层机制，通过Class对象实现运行时类操作。其核心应用包括框架依赖注入（如Spring）、动态代理和对象映射（如MyBatis），但伴随性能损耗和安全风险。优化策略涵盖反射对象缓存、字节码生成（CGLIB）和批量操作，同时需配合SecurityManager进行权限管控。开发者应遵循最小权限原则，结合严格测试确保代码安全。反射技术平衡了灵活性与封装性，是Java高级开发的核心技能，在框架设计与动态编程中持续发挥关键作用。
Spring事务管理配置方式演示
标题所揭示的知识点是Spring事务管理的配置方式。Spring作为Java领域一个极为重要的框架，其事务管理是企业级开发中不可或缺的一部分。事务管理是保证数据库操作的原子性、一致性、隔离性和持久性的关键技术。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值