Spring框架（四）——Spring中的事务管理

最新推荐文章于 2023-12-13 19:51:44 发布

老臣、

最新推荐文章于 2023-12-13 19:51:44 发布

阅读量1.3k

点赞数 1

分类专栏： Java Spring Spring技术栈

本文链接：https://blog.csdn.net/vae1314chuanchen/article/details/79357032

版权

Java 同时被 3 个专栏收录

35 篇文章 0 订阅

订阅专栏

Spring技术栈

19 篇文章 3 订阅

订阅专栏

Spring

11 篇文章 0 订阅

订阅专栏

一、事务简介

什么是事务？

　　事务就是一系列的动作，它们被当做一个单独的工作单元。这些动作要么全部完成，要么全部不起作用。

事务的四个关键属性(ACID)

　　原子性(atomicity): 事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成要么完全不起作用。
　　一致性(consistency): 一旦所有事务动作完成，事务就被提交。数据和资源就处于一种满足业务规则的一致性状态中。
　　隔离性(isolation): 可能有许多事务会同时处理相同的数据，因此每个事物都应该与其他事务隔离开来，防止数据损坏。
　　持久性(durability): 一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响。通常情况下，事务的结果被写到持久化存储器中。

什么是事务管理？

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

二、Spring 中的事务管理

　　作为企业级应用程序框架，Spring 在不同的事务管理 API 之上定义了一个抽象层。而应用程序开发人员不必了解底层的事务管理 API，就可以使用 Spring 的事务管理机制。
　　
　　编程式事务管理：将事务管理代码嵌入到业务方法中来控制事务的提交和回滚。在编程式管理事务时，必须在每个事务操作中包含额外的事务管理代码。
　　
　　声明式事务管理：大多数情况下比编程式事务管理更好用。它将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。事务管理作为一种横切关注点，可以通过 AOP 方法模块化。Spring 通过 Spring AOP 框架支持声明式事务管理。
　　
　　下面会主要说一下声明式事务管理。

Spring 中的事务管理器

　　Spring 从不同的事务管理 API 中抽象了一整套的事务机制。开发人员不必了解底层的事务 API，就可以利用这些事务机制。有了这些事务机制，事务管理代码就能独立于特定的事务技术了。
　　Spring 的核心事务管理抽象是org.springframework.transaction.PlatformTransactionManager
它为事务管理封装了一组独立于技术的方法。无论使用 Spring 的哪种事务管理策略(编程式或声明式)，事务管理器都是必须的。事务管理器以普通的 Bean 形式声明在 Spring IOC 容器中。

三、从一个简单案例中看事务管理

　　下面看一个简单的案例，银行转账。用户甲给用户乙转账200元人民币，先将用户甲的账户余额减少200元，然后再将用户乙的账户余额增加200元。这里的操作就是一个事务，必须同时完成，如果在用户甲的余额减少之后，出现了某些异常操作，进而导致用户乙的余额没有增加，这时为了确保数据的完整性和一致性，应当使用事务管理进行回滚。

数据表中的数据

这里写图片描述
　　一个简单的Account表，包括用户ID，用户名，以及用户余额。这个案例整合了MyBatis框架对数据库进行操作。
　

转账的业务类如下

@Service("iTransfer")
public class TransferImpl implements ITransfer {

    @Autowired
    private AccountInformationMapper accountInformationMapper;

    @Override
    public void transfer(int outId, int intoId, int money) {
        AccountInformation outAccount= accountInformationMapper.selectByPrimaryKey(outId);
        AccountInformation intoAccount= accountInformationMapper.selectByPrimaryKey(intoId);
        int outMoney = outAccount.getBalance()-money;
        int intoMoney = intoAccount.getBalance()+money;
        //转出账户余额减少
        accountInformationMapper.updateMoneyByPrimaryKey(outId, outMoney);
        //转入账户余额增加
        accountInformationMapper.updateMoneyByPrimaryKey(intoId, intoMoney);
    }
}

　　可以看到转账的业务类实际上就是操作数据库将转出账户余额减少，转入账户余额增加。

测试类如下

public class Test {

    public static void main(String[] args) throws Exception{
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext-transaction.xml");
        ITransfer iTransfer = (ITransfer) ctx.getBean("iTransfer");
        //ID为1001的用户给ID为1002的用户转账200元
        iTransfer.transfer(1001,1002,200);
    }
}

　　在数据库连接正常的情况下跑一下测试类可以看到，转账成功，如下所示：
　　这里写图片描述

　　下面我们强行给转账制造点异常，接着看转账的业务类代码：
　　

@Service("iTransfer")
public class TransferImpl implements ITransfer {

    @Autowired
    private AccountInformationMapper accountInformationMapper;

    @Override
    public void transfer(int outId, int intoId, int money) {
        AccountInformation outAccount= accountInformationMapper.selectByPrimaryKey(outId);
        AccountInformation intoAccount= accountInformationMapper.selectByPrimaryKey(intoId);
        int outMoney = outAccount.getBalance()-money;
        int intoMoney = intoAccount.getBalance()+money;
        //转出账户余额减少
        accountInformationMapper.updateMoneyByPrimaryKey(outId, outMoney);
        int i = 1/0;
        //转入账户余额增加
        accountInformationMapper.updateMoneyByPrimaryKey(intoId, intoMoney);
    }
}

　　在添加了int i = 1/0;这行代码之后，程序会抛出除数不为零的异常。我们再执行测试类，结果如下：
　　这里写图片描述
　　很明显，钱转丢了，Tom的余额减少了，异常之后，Jery的余额还是800，这就导致了钱转丢了。为了确保数据的完整性和一致性，我们使用了Spring中的事务管理。

四、用事务通知声明式地管理事务

　　为了在 Spring中启用声明式事务管理，可以通过 tx Schema 中定义的<tx:advice> 元素声明事务通知，为此必须事先将这个 Schema 定义添加到<beans>根元素中去。
　　声明了事务通知后，就需要将它与切入点关联起来。由于事务通知是在 <aop:config>元素外部声明的，所以它无法直接与切入点产生关联。所以必须在<aop:config>元素中声明一个增强器通知与切入点关联起来。

　　示例代码如下：
　　

    <!-- 配置spring事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--控制住数据源  -->
        <property name="dataSource" ref="dataSource"></property>
        <!--当提交事物失败的时候是否回滚-->
        <property name="rollbackOnCommitFailure" value="true"/>
    </bean>

    <!--配置事物的通知，事务增强，事务如何切入  -->
    <tx:advice id="txAdvice">
        <tx:attributes>
            <!-- 配置事务方法 -->
            <tx:method name="transfer"/>
        </tx:attributes>
    </tx:advice>

    <!--基于xml配置形式的事务（必要主要的都是使用配置式） 配置切面 -->
    <aop:config>
        <!-- 配置切入点 -->
        <aop:pointcut expression="execution(* com.spring.transaction.service.ITransfer.transfer(..))" id="txPoint"/>
        <!-- 配置事务增强 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPoint"/>
    </aop:config>

　　当我们在applicationContext-transaction.xml文件中添加了以上代码，再次执行测试类，就会发现没有出现转丢钱的情况，这是因为出现异常的时候，Spring的事物管理器将我们的事物进行了回滚。
　　
　　完整的applicationContext-transaction.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:context="http://www.springframework.org/schema/context"
       xmlns:mybatis-spring="http://mybatis.org/schema/mybatis-spring"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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://mybatis.org/schema/mybatis-spring
       http://mybatis.org/schema/mybatis-spring.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:component-scan base-package="com.spring.transaction"/>

    <context:property-placeholder location="classpath:db.properties"/>

    <!-- Spring用来控制业务逻辑。数据源、事务控制、aop -->
    <!--数据连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

    <!--
        配置和MyBatis的整合
        目的：1、spring管理所有组件。mapper的实现类。
                service==>Dao   @Autowired:自动注入mapper；
             2、spring用来管理事务，spring声明式事务
    -->
    <!--创建出SqlSessionFactory对象  -->
    <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <!-- configLocation指定全局配置文件的位置 -->
        <property name="configLocation" value="classpath:mybatis-config.xml"></property>
        <!--mapperLocations: 指定mapper文件的位置-->
        <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
    </bean>

    <!-- 扫描所有的mapper接口的实现,让这些mapper能够自动注入;
        base-package: 指定mapper接口的包名 -->
    <mybatis-spring:scan base-package="com.spring.transaction.dao"/>

    <!-- 配置扫描器，将mybatis接口的实现加入到ioc容器中 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--扫描所有dao接口的实现，加入到ioc容器中 -->
        <property name="basePackage" value="com.spring.transaction.dao"></property>
    </bean>

    <!-- 配置spring事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--控制住数据源  -->
        <property name="dataSource" ref="dataSource"></property>
        <!--当提交事物失败的时候是否回滚-->
        <property name="rollbackOnCommitFailure" value="true"/>
    </bean>

    <!--配置事物的通知，事务增强，事务如何切入  -->
    <tx:advice id="txAdvice">
        <tx:attributes>
            <!-- 配置事务方法 -->
            <tx:method name="transfer"/>
        </tx:attributes>
    </tx:advice>

    <!--基于xml配置形式的事务（必要主要的都是使用配置式） 配置切面 -->
    <aop:config>
        <!-- 配置切入点 -->
        <aop:pointcut expression="execution(* com.spring.transaction.service.ITransfer.transfer(..))" id="txPoint"/>
        <!-- 配置事务增强 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPoint"/>
    </aop:config>


</beans>

五、用 @Transactional 注解声明式地管理事务

　　除了在带有切入点, 通知和增强器的 Bean 配置文件中声明事务外，Spring 还允许简单地用 @Transactional 注解来标注事务方法。
　　为了将方法定义为支持事务处理的，可以为方法添加 @Transactional 注解。根据 Spring AOP 基于代理机制，只能标注公有方法。可以在方法或者类级别上添加 @Transactional 注解。当把这个注解应用到类上时，这个类中的所有公共方法都会被定义成支持事务处理的。
　　在 Bean 配置文件中只需要启用<tx:annotation-driven>元素，并为之指定事务管理器就可以了。如果事务处理器的名称是 transactionManager, 就可以在<tx:annotation-driven>元素中省略 transaction-manager 属性，这个元素会自动检测该名称的事务处理器。
　　

首先配置applicationContext-transaction.xml，先配置spring事务管理器，然后开启基于注解的事务。示例代码如下：

    <!-- 配置spring事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--控制住数据源  -->
        <property name="dataSource" ref="dataSource"></property>
        <!--当提交事物失败的时候是否回滚-->
        <property name="rollbackOnCommitFailure" value="true"/>
    </bean>

    <!-- 开启基于注解的事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

然后在需要支持事务处理的类或方法上添加@Transactional 注解即可，也就是在我们的转账方法transfer上面添加@Transactional 注解。示例代码如下：

    @Transactional
    public void transfer(int outId, int intoId, int money) {
        AccountInformation outAccount= accountInformationMapper.selectByPrimaryKey(outId);
        AccountInformation intoAccount= accountInformationMapper.selectByPrimaryKey(intoId);
        int outMoney = outAccount.getBalance()-money;
        int intoMoney = intoAccount.getBalance()+money;
        //转出账户余额减少
        accountInformationMapper.updateMoneyByPrimaryKey(outId, outMoney);
        int i = 1/0;
        //转入账户余额增加
        accountInformationMapper.updateMoneyByPrimaryKey(intoId, intoMoney);
    }

　　再次执行测试类，会发现运行效果同用事务通知声明式地管理事务一样。
　　

六、设置事务属性

propagation : 事务传播行为
isolation : 事务隔离级别
read-only : 只读
rollback-for : 发生那些异常回滚
no-rollback-for : 发生那些异常不回滚
timeout : 过期信息

设置事务传播属性

　　当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。事务的传播行为可以由传播属性指定。Spring 定义了 7 种类传播行为。
　　Spring 支持的事务传播行为如下所示：
这里写图片描述
　　1）事务传播属性可以在 @Transactional 注解的 propagation 属性中定义。
　

@Transactional(propagation = Propagation.REQUIRED)

　　2）在 Spring 事务通知中, 也可以像下面这样在<tx:method>元素中设定传播事务属性。

    <tx:advice id="txAdvice">
        <tx:attributes>
            <!-- 配置事务方法 -->
            <tx:method name="transfer" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

设置隔离事务属性

　　在说事物的隔离之前我们先看一下由并发事务所导致的问题。当同一个应用程序或者不同应用程序中的多个事务在同一个数据集上并发执行时，可能会出现许多意外的问题。
　　
　　并发事务所导致的问题可以分为下面三种类型：
　　脏读：对于两个事物 T1，T2。 T1 读取了已经被 T2 更新但还没有被提交的字段。之后，若 T2 回滚，T1读取的内容就是临时且无效的。
　　不可重复读：对于两个事物 T1， T2。 T1 读取了一个字段，然后 T2 更新了该字段。之后，T1再次读取同一个字段，值就不同了。

　　从理论上来说，事务应该彼此完全隔离，以避免并发事务所导致的问题。然而，那样会对性能产生极大的影响，因为事务必须按顺序运行。
　　在实际开发中，为了提升性能，事务会以较低的隔离级别运行。事务的隔离级别可以通过隔离事务属性指定。
　　
　　Spring 支持的事务隔离级别如下：
这里写图片描述
　　注：事务的隔离级别要得到底层数据库引擎的支持，而不是应用程序或者框架的支持。Oracle 支持的 2 种事务隔离级别：READ_COMMITED、SERIALIZABLE。Mysql 支持 4 中事务隔离级别。

设置隔离事务属性：
1）用 @Transactional 注解声明式地管理事务时可以在 @Transactional 的 isolation 属性中设置隔离级别。

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT)

2）在 Spring事务通知中，可以在 <tx:method> 元素中指定隔离级别。

    <tx:advice id="txAdvice">
        <tx:attributes>
            <!-- 配置事务方法 -->
            <tx:method name="transfer" 
                       propagation="REQUIRED"
                       isolation="DEFAULT"
            />
        </tx:attributes>
    </tx:advice>

设置回滚事务属性

　　默认情况下只有未检查异常(RuntimeException和Error类型的异常)会导致事务回滚。而受检查异常不会。
　　
　　事务的回滚规则可以通过 @Transactional 注解的 rollbackFor 和 noRollbackFor 属性来定义。这两个属性被声明为 Class[] 类型的。因此可以为这两个属性指定多个异常类。
　　rollbackFor: 遇到时必须进行回滚
　　noRollbackFor: 一组异常类，遇到时必须不回滚

    @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT,
            rollbackFor = {IOException.class, SQLException.class}, noRollbackFor = ArithmeticException.class
    )

　　在 Spring事务通知中，可以在<tx:method>元素中指定回滚规则。如果有不止一种异常，用逗号分隔。
　　

    <tx:advice id="txAdvice">
        <tx:attributes>
            <!-- 配置事务方法 -->
            <tx:method name="transfer"
                       propagation="REQUIRED"
                       isolation="DEFAULT"
                       rollback-for="java.io.IOException, java.sql.SQLException"
                       no-rollback-for="java.lang.ArithmeticException"
            />
        </tx:attributes>
    </tx:advice>

设置超时和只读事务属性

　　由于事务可以在行和表上获得锁，因此长事务会占用资源，并对整体性能产生影响。
　　如果一个事物只读取数据但不做修改，数据库引擎可以对这个事务进行优化。
　　
　　超时事务属性：事务在强制回滚之前可以保持多久，这样可以防止长期运行的事务占用资源。
　　只读事务属性：表示这个事务只读取数据但不更新数据，这样可以帮助数据库引擎优化事务。

　　设置超时和只读事务属性
　　1）超时和只读属性可以在 @Transactional 注解中定义。超时属性以秒为单位来计算。
　　

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT,
            rollbackFor = {IOException.class, SQLException.class},
            noRollbackFor = ArithmeticException.class,
            readOnly = true,
            timeout = 30
    )

　　2）在 Spring事务通知中，超时和只读属性可以在<tx:method>元素中进行指定。
　　

    <tx:advice id="txAdvice">
        <tx:attributes>
            <!-- 配置事务方法 -->
            <tx:method name="transfer"
                       propagation="REQUIRED"
                       isolation="DEFAULT"
                       rollback-for="java.io.IOException, java.sql.SQLException"
                       no-rollback-for="java.lang.ArithmeticException"
                       read-only="true"
                       timeout="30"
            />
        </tx:attributes>
    </tx:advice>

附：pom.xml文件

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mh</groupId>
    <artifactId>com.m</artifactId>
    <packaging>war</packaging>
    <version>1.0</version>
    <name>com.mh Maven Webapp</name>
    <url>http://maven.apache.org</url>

    <properties>
        <jdk.version>1.8</jdk.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>

        <org.springframework.version>4.1.6.RELEASE</org.springframework.version>
        <org.mybatis.version>3.4.4</org.mybatis.version>
        <org.mybatis.spring.version>1.3.0</org.mybatis.spring.version>
    </properties>
    <dependencies>

        <!-- Spring核心包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>

        <!--spring-jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <!-- pring与aspectJ的整合-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>

        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${org.mybatis.version}</version>
        </dependency>

        <!--mybatis-spring整合-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>${org.mybatis.spring.version}</version>
        </dependency>

        <!--数据库连接池 c3p0-->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>

        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>

        <!-- MBG -->
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.5</version>
        </dependency>

    </dependencies>

    <build>
        <finalName>com.mh</finalName>

        <plugins>
            <!--compiler插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>${jdk.version}</source>
                    <target>${jdk.version}</target>
                </configuration>
            </plugin>
        </plugins>

    </build>
</project>

老臣、

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Spring框架（四）——Spring中的事务管理

一、事务简介什么是事务？　　事务就是一系列的动作，它们被当做一个单独的工作单元。这些动作要么全部完成，要么全部不起作用。事务的四个关键属性(ACID)　　原子性(atomicity): 事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成要么完全不起作用。　　一致性(consistency): 一旦所有事务动作完成，事务就被提交。数据和资源就处于一种满足...
复制链接

扫一扫

专栏目录