关于事务的概念

理解事务之前，先来看一下生活中最常见的例子：ATM取钱。
比如你去ATM机取1000块钱。大概有两个重要的步骤，你的银行卡扣了1000块钱，ATM机取出1000块。这两个步骤必须要么都执行，要么都不执行。如果银行卡扣除了1000块但是ATM出钱失败的话，你将会损失1000元；如果银行卡扣钱失败但是ATM却出了1000块，那么银行将损失1000元。所以，如果一个步骤成功另一个步骤失败对双方都不是好事，如果不管哪一个步骤失败了以后，整个取钱过程都能回滚，也就是完全取消整个过程的全部操作的话，这对双方来说都是很好的体验。

事务就是用来解决类似问题的。事务是一系列的动作，操作，它们综合在一起才是一个完整的工作单元，这些动作必须全部完成，如果有一个失败或者出错的话，那么事务就会回滚到最开始的状态，仿佛什么都没发生过一样。

在企业级应用程序开发中，事务管理必不可少的技术，用来确保数据的完整性和一致性。

事务有四大特性，ACID

原子性（Atomicity）：事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用。
一致性（Consistency）：一旦事务完成（不管成功还是失败），系统必须确保它所建模的业务处于一致的状态，而不会是部分完成部分失败。在现实中的数据不应该被破坏。
隔离性（Isolation）：可能有许多事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。
持久性（Durability）：一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响，这样就能从任何系统崩溃中恢复过来。通常情况下，事务的结果被写到持久化存储器中。

Spring事务控制核心接口类

Spring事务管理的实现有许多细节，如果对整个接口框架有个大体了解会非常有利于我们理解事务，下面通过讲解Spring的事务接口来了解Spring实现事务的具体策略。

Spring事务管理涉及的接口的联系如下图：
这里写图片描述

接下来会一一解释上面spring事务管理设计的接口含义。

事务属性定义

上面讲到的事务管理器接口PlatformTransactionManager通过getTransaction(TransactionDefinition definition)方法来得到事务，这个方法里面的参数是TransactionDefinition类，这个类就定义了一些基本的事务属性。那么什么是事务属性呢？事务属性可以理解成事务的一些基本配置，描述了事务策略如何应用到方法上。每个平台相关的事务管理实现都必须有5个方面的事务属性，因此spring放在一个类中进行管理事务属性。包括如图所示：
这里写图片描述

TransactionDefinition接口内容如下：

public interface TransactionDefinition { 
int getPropagationBehavior(); // 返回事务的传播行为 
int getIsolationLevel();  // 返回事务的隔离级别，事务管理器根据它来控制另外一个事务可以看到本事务内的哪些数据
int getTimeout();  // 返回事务必须在多少秒内完成 
boolean isReadOnly(); // 事务是否只读，事务管理器能够根据这个返回值进行优化，确保事务是只读的
 }

spring事务管理器

Spring并不直接管理事务，或者说不关心事务具体的实现代码，而是提供了对多种事务管理器的支持，提供一种事务规则，一种接口规范。他们将事务管理的职责委托给Hibernate或者JTA等持久化机制所提供的相关平台框架的事务来实现。

Spring事务管理器的接口是org.springframework.transaction.PlatformTransactionManager，通过这个接口，Spring为各个平台如JDBC、Hibernate等都提供了对应的事务管理器，但是具体的实现就是各个平台自己的事情了。此接口的内容如下：

Public interface PlatformTransactionManager()...{ 

// 由TransactionDefinition得到TransactionStatus对象 
TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;

 // 提交 
Void commit(TransactionStatus status) throws TransactionException; 

// 回滚 
Void rollback(TransactionStatus status) throws TransactionException; 
}

spring事务管理器接口只定义了获取事务属性、事务提交、事务回滚的方法。至于怎么配置事务属性、事务如何提交、怎么回滚，就要交给各大平台的框架去实现具体的事务控制代码了。
从这里可知具体的事务管理机制对Spring来说是透明的，它并不关心具体实现，这些是对应各个平台需要关心的，所以Spring事务管理的一个优点就是为不同的事务API提供一致的编程模型，如JTA、JDBC、Hibernate、JPA。当需要指定底层事务由哪一个平台实现，只要调用接口即可。

本文所有的案例将采用jdbc提供的事务管理机制。

事务状态

上面讲到的调用PlatformTransactionManager接口的getTransaction()的方法得到的是TransactionStatus接口的一个实现，这个接口的内容如下：

public interface TransactionStatus{ 

  boolean isNewTransaction(); // 是否是新的事物
  boolean hasSavepoint(); // 是否有恢复点
  void setRollbackOnly(); // 设置为只回滚 
  boolean isRollbackOnly(); // 是否为只回滚 
  boolean isCompleted; // 是否已完成 

}

可以发现这个接口描述的是一些处理事务提供简单的控制事务执行和查询事务状态的方法，在回滚或提交的时候需要应用对应的事务状态。

总结

spring事务管理器接口专门定义一个事务属性的类来管理事务的传播行为和隔离级别等配置，然后专门定义一个事务状态的接口来监听事务的状态，最后核心就是给外部各大平台持久化框架提供一个规范，一个接口，供JDBC、Hibernate等这些平台通过自己内部底层实现的代码完成对数据库的操作。

接下来就是了解spring事务如何应用到具体的开发。

编程式事务

通过硬编码方式，自己手动的控制事务，就叫做编程式事务控制。

Jdbc代码：
        Conn.setAutoCommite(false);  // 设置手动控制事务
Hibernate代码：
        Session.beginTransaction();    // 开启一个事务

【细粒度的事务控制： 可以对指定的方法、指定的方法的某几行添加事务控制】

优点： 比较灵活，细粒度的。
缺点，开发起来比较繁琐，每次都要开启、提交、回滚事务。即要写很多代码。

声明式事务

Spring提供了对事务的管理, 这个就叫声明式事务管理。

Spring提供了对事务控制的实现。用户如果想用Spring的声明式事务管理，只需要在配置文件中配置即可； 不想使用时直接移除配置。这个实现了对事务控制的最大程度的解耦，也解决了编程式事务开发繁琐，不利于维护等问题。但是缺点就是粗粒度的事务控制，不能只针对方法中的某一行，最小粒度为在某一个方法上配置事务。

Spring声明式事务管理，核心实现原理就是基于Aop技术，面向切面编程思想，可插配的方式添加事务管理。如果还有搞懂AOP技术或者Aop实现机制之动态代理，可以参看我之前的博文。

http://blog.csdn.net/nwpu_geeker/article/details/79133860

编程式和声明式事务的区别

Spring提供了对编程式事务和声明式事务的支持，编程式事务允许用户在代码中精确定义事务的边界，而声明式事务（基于AOP）有助于用户将操作与事务规则进行解耦。

简单地说，编程式事务侵入到了业务代码里面，但是提供了更加详细的事务管理；而声明式事务由于基于AOP，所以既能起到事务管理的作用，又可以不影响业务代码的具体实现。

总结两点区别：
从入侵性也就是解耦性出发。
从粗细粒度出发。

XML方式实现spring事务管理

开发步骤：
1） 引入spring-aop相关的4个jar文件
2） 引入aop名称空间 【XML配置方式需要引入】
3） 引入tx名称空间 【事务方式必须引入】

代码如下：
Dept.java

public class Dept {
    private int id;
    private String deptName;

    public int getId() {
        return id;
    }

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

    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }

}

DeptDao.java 简单模拟了保存数据到数据库中

public class DeptDao {
    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public void save(Dept dept) {
        String sql = "insert into t_dept(deptName) values(?)";
        jdbcTemplate.update(sql, dept.getDeptName());
    }

}

DeptService.java 业务层也是事务控制层

public class DeptService {
    private DeptDao deptDao;
    public void setDeptDao(DeptDao deptDao) {
        this.deptDao = deptDao;
    }

    public void save(Dept dept) {
        deptDao.save(dept);
        int i=1/0;
        deptDao.save(dept);
    }

}

注意：service处理业务代码，有时候不止一次调用dao层的方法与数据库操作，因此将事务控制在该service层中。
本次案例简单模拟系统出错后，是否执行事务控制，数据库是否回滚。

bean.xml

<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
         http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--数据源(数据库连接)配置  -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
        <property name="initialPoolSize" value="3"></property>
        <property name="maxPoolSize" value="7"></property>
        <property name="maxStatements" value="100"></property>
        <property name="acquireIncrement" value="2"></property>
    </bean>

    <!-- 创建jdbcTemplate 实例 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- dao 实例 -->
    <bean id="deptDao" class="edu.dao.DeptDao">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>

    <!-- service实例 -->
    <bean id="deptService" class="edu.service.DeptService">
        <property name="deptDao" ref="deptDao"></property>
    </bean>

    <!-- spring声明式事务管理配置 -->
    <!-- 1.配置事务管理器类 -->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 2.配置事务增强，事务属性，如何管理事务？ -->
    <tx:advice id="txAdvice" transaction-manager="txManager">
      <tx:attributes>
          <tx:method name="get*" read-only="true"/>
          <tx:method name="find*" read-only="true"/>
          <tx:method name="*" read-only="false"/>
      </tx:attributes>
    </tx:advice>
    <!-- aop配置 切入点配置（拦截哪些方法，应用上面的事务增强配置） -->
    <aop:config>
      <!-- 配置切入点 事务控制加在所有service层下的类方法中-->
     <aop:pointcut expression="execution(* edu.service.*.*(..))" id="pt"/>
     <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
    </aop:config>

    <!-- 开启注解扫描 -->
    <!--<context:component-scan base-package="edu.test.aop"></context:component-scan>-->

    <!-- 注解方式实现事务： 指定注解方式实现事务 -->
    <!--<tx:annotation-driven transaction-manager="txManager"/>-->
</beans>

测试 App.java 是否能将数据插入到数据库中

public class App {

    private ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    @Test
    public void testTX() {
        Dept dept = new Dept();
        dept.setDeptName("销售部");
        DeptService deptService=(DeptService) ac.getBean("deptService");
        deptService.save(dept);
    }
}

因此service层在保存一行数据之后出错，数据不会插入到表中，执行事务回滚。数据库没有数据插入。如果把int i=1/0;这一行代码删除，数据库会保存数据如下：
这里写图片描述

注解方式实现spring事务管理

使用注解实现Spring的声明式事务管理，更加简单！

开发步骤：
1） 必须引入Aop相关的jar文件
2） bean.xml中指定注解方式实现声明式事务管理以及应用的事务管理器类
3）在需要添加事务控制的地方，写上: @Transactional

关键 @Transactional注解：
1）应用事务的注解
2）定义到方法上： 当前方法应用spring的声明式事务
3）定义到类上： 当前类的所有的方法都应用Spring声明式事务管理;
4）定义到父类上： 当执行父类的方法时候应用事务。

Bean.xml中指定注解的方式实现。

<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
         http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--数据源(数据库连接)配置  -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
        <property name="initialPoolSize" value="3"></property>
        <property name="maxPoolSize" value="7"></property>
        <property name="maxStatements" value="100"></property>
        <property name="acquireIncrement" value="2"></property>
    </bean>

    <!-- 创建jdbcTemplate 实例 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- dao 实例 -->
    <bean id="deptDao" class="edu.dao.DeptDao">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>

    <!-- service实例 -->
    <bean id="deptService" class="edu.service.DeptService">
        <property name="deptDao" ref="deptDao"></property>
    </bean>

    <!-- spring声明式事务管理配置 -->
    <!-- 1.配置事务管理器类 -->
    <bean id="txManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>


    <!-- 开启注解扫描 -->
    <context:component-scan base-package="edu.test.aop"></context:component-scan>

    <!-- 注解方式实现事务： 指定注解方式实现事务 -->
    <tx:annotation-driven transaction-manager="txManager" />
</beans>

在service层中加入事务管理注解

public class DeptService {
    private DeptDao deptDao;
    public void setDeptDao(DeptDao deptDao) {
        this.deptDao = deptDao;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public void save(Dept dept) {
        deptDao.save(dept);
        int i=1/0;
        deptDao.save(dept);
    }

}

以spring注解的方式实现事务控制和xml配置方式的不同之处主要是以上的内容。其他代码同上面的xml实现，这里就不在赘述了。
测试结果与上面相同，当加入事务管理时，如果出错，事务会回滚，不会将记录插入数据库中。

附：事务传播行为

这里写图片描述

其中最常用的事务传播行为是 propagation.required和propagation.requires_new。前者也是spring默认的传播行为。 这两个的区别在于propagation.required在于当前如果处于事务内，就不会创建新的事务，而是会加入当前事务。而propagation.requires_new不管当前有没有事务都会创建一个新的事务，当这个新的事务结束，才继续执行其他的事务。

下面通过案例来模拟测试这两个事务传播行为的用法和区别。

需求：在每次保存数据的之前加入日志，及时保存数据出现问题，也不会影响到日志信息的保存。这就是两个不同的事务。

关键代码如下：
DeptDao.java—保存部门

@Repository
public class DeptDao {

    @Resource
    private JdbcTemplate jdbcTemplate;

    public void save(Dept dept){
        String sql = "insert into t_dept (deptName) values(?)";
        jdbcTemplate.update(sql,dept.getDeptName());
    }
}

LogDao.java—保存日志

@Repository
public class LogDao {

    @Resource
    private JdbcTemplate jdbcTemplate;

    // 始终开启事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void insertLog() {
        jdbcTemplate.update("insert into log_ values('在保存Dept..')");
    }
}

这里偷懒在dao层之间加上了事务控制，按道理来说应该再写一个service层的。

DeptService.java

@Service
public class DeptService {

    // 部门dao
    @Resource
    private DeptDao deptDao;

    // 日志dao
    @Resource
    private LogDao logDao;

    /*
     * 事务控制？
     */
    @Transactional(
            readOnly = false,  // 读写事务
            timeout = -1,       // 事务的超时时间不限制
            //noRollbackFor = ArithmeticException.class,  // 遇到数学异常不回滚
            isolation = Isolation.DEFAULT,              // 事务的隔离级别，数据库的默认
            propagation = Propagation.REQUIRED          // 事务的传播行为
    )
    public void save(Dept dept){
        logDao.insertLog();  // 保存日志  【自己开启一个事务】
        int i = 1/0;
        deptDao.save(dept);  // 保存部门
    }
}

Service层加入事务控制。这里简单配置了一下事务属性，事务属性配置为支持读写，事务超时时间不限制，事务隔离级别为默认的，事务传播行为为Propagation.REQUIRED。 而LogDao里的insertLog()方法设置为Propagation.REQUIRES_NEW。这里的区别就体现出来了。

测试App.java —测试发生错误数据库是否能插入数据

@Test
    public void testApp() throws Exception {
        //容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("edu/bean.xml");

        // 模拟数据
        Dept dept = new Dept();
        dept.setDeptName("测试部");

        DeptService deptService = (DeptService) ac.getBean("deptService");
        deptService.save(dept);
    }

因为在service层模拟了by zero错误，在数据库中的部门表将回滚事务，不会插入数据，但是在日志表中日志信息将被插入。原因就是配置了传播行为不同，这是两次不同的事务，互不影响。如果都是默认的传播行为，日志表也不会插入数据了。

总结

也就是说如果事务比较多，多个具有事务控制的service的相互调用，且比较复杂的需求，事务的配置变得尤其重要了。所以要学好事务属性，包括怎么设置传播行为，隔离级别等一些常用配置。

# spring
Logo
魔乐社区

魔乐社区（Modelers.cn) 是一个中立、公益的人工智能社区，提供人工智能工具、模型、数据的托管、展示与应用协同服务，为人工智能开发及爱好者搭建开放的学习交流平台。社区通过理事会方式运作，由全产业链共同建设、共同运营、共同享有，推动国产AI生态繁荣发展。

更多推荐

小参数・大码力・易部署 | Qwen3.6-27B上线魔乐社区，基于昇腾的部署教程来了

继一周前模型开源发布后，千问再度开源Qwen3.6-27B —— 一个拥有270亿参数的稠密多模态模型，也是社区呼声最高的模型规格。Qwen3.6-27B 依然支持多模态思考与非思考模式，在智能体编程方面达到了旗舰级表现，全面超越前代开源旗舰 Qwen3.5-397B-A17B（总参数397B / 激活参数17B的MoE模型）。作为稠密架构，它无需MoE路由即可部署，是开发者在实用、可广泛部署规模

avatar 魔乐社区
cover

量化挑战赛冠军专访：4小时啃下W4A8量化，我靠的是这些经验

avatar 魔乐社区
cover

替你试过了，消费级显卡可以跑的开源文生图SOTA模型，顶级渲染、高密度文本绘图

avatar 魔乐社区