Spring学习——事务管理

2021-02-04

字数统计: 2.2k字 | 阅读时长≈ 9分

事务

什么是事务

事务在项目开发过程中十分重要，涉及到数据的一致性的问题。
事务管理是企业级应用程序开发中必备技术，用来确保数据的完整性和一致性。
事务就是把一系列的动作作为一个独立的单元，这些动作要么全部完成，要么全部不起作用。

事务的四个属性ACID

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

Spring的声明式事务

测试没有事务管理的情况

操作：添加和删除一名用户

设计：删除用的SQL语句出错。

输出结果：应该是添加成功，删除失败。

1、首先在接口UserMapper中添加两个方法。

public interface UserMapper {
    public List<User> selectUser();

    public int deleteUser(int id);

    public int addUser(User user);
}

2、编写UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.asher.dao.UserMapper">
    <insert id="addUser" parameterType="user">
        insert into mybatis.user (id,name,pwd)
        values (#{id},#{name},#{pwd});
    </insert>

    <delete id="deleteUser" parameterType="int">
        test delete from mybatis.user where id=#{id}
    </delete>
</mapper>

3、测试

public class MyTest {
    @Autowired
    private UserService userService;

    @Test
    public void test() {
        //  添加用户
        int i=userService.addUser(new User(4, "asher", "1234567"));
        System.out.println(i);
        // 删除用户
        int j =userService.deleteUser(4);
        System.out.println(j);
    }
}

4、数据库开始数据

QQ20210204-152404@2x

5、运行结果

QQ20210204-152922@2x

QQ20210204-153017@2x

没有进行事务的管理；我们想让他们都成功才成功，有一个失败，就都失败，我们就应该需要事务！

在过去，我们使用手动管理事务是很麻烦的，现在使用Spring框架提供的事务管理机制，可以释放我们双手，只要配置好就行了。

Spring事务管理

Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。

编程式事务管理

将事务管理代码嵌到业务方法中来控制事务的提交和回滚
缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码

实列说明

Spring为了简化事务管理的代码：提供了模板类 TransactionTemplate，所以手动编程的方式来管理事务，只需要使用该模板类即可！

<!--
	1. 步骤一:配置一个事务管理器，Spring使用PlatformTransactionManager接口来管理事务，所以咱们需要使用到他的实现类！！
-->
     <!-- 配置事务管理器 -->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"/>
        </bean>
 
<!-- 2. 步骤二:配置事务管理的模板 -->
        <!-- 配置事务管理的模板 -->
        <bean id="transactionTemplate" Ωlass="org.springframework.transaction.support.TransactionTemplate">
            <property name="transactionManager" ref="transactionManager"/>
        </bean>
 
<!--    3. 步骤三:在需要进行事务管理的类中,注入事务管理的模板-->
        <bean id="accountService" class="com.itheima.demo1.AccountServiceImpl">
            <property name="accountDao" ref="accountDao"/>
            <property name="transactionTemplate" ref="transactionTemplate"/>
        </bean>

在业务层使用模板管理事务：

// 注入事务模板对象
        private TransactionTemplate transactionTemplate;
        public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
            this.transactionTemplate = transactionTemplate;
        }
 
        public void pay(final String out, final String in, final double money) {
            transactionTemplate.execute(new TransactionCallbackWithoutResult() {
                protected void doInTransactionWithoutResult(TransactionStatus status) {
                    // 扣钱
                    accountDao.outMoney(out, money);
                    int a = 10/0;
                    // 加钱
                    accountDao.inMoney(in, money);
                }
            });
        }

声明式事务管理

一般情况下比编程式事务好用。
将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。
其实在使用过程中，其实声明式的事务管理就是AOP的使用的实例，说白了就是AOP。

使用Spring管理事务，注意头文件的约束导入 : tx aop

xmlns:tx="http://www.springframework.org/schema/tx"
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">

xmlns:tx="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">

事务管理器

无论是哪种事务管理策略，事务管理器都是必须的。
Spring的核心事务管理抽象，管理封装了一组独立于技术的方法来管理事务。

JDBC事务

<!-- 事务管理-->
    <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

配置好事务管理器后，需要配置事务的通知

<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
   <tx:attributes>
       <!--配置哪些方法使用什么样的事务,配置事务的传播特性-->
       <tx:method name="add" propagation="REQUIRED"/>
       <tx:method name="delete" propagation="REQUIRED"/>
       <tx:method name="update" propagation="REQUIRED"/>
       <tx:method name="search*" propagation="REQUIRED"/>
       <tx:method name="get" read-only="true"/>
       <tx:method name="*" propagation="REQUIRED"/>
   </tx:attributes>
</tx:advice>

spring事务传播特性：

事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为：

propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。
propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。
propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。
propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作。

Spring 默认的事务传播行为是 PROPAGATION_REQUIRED，它适合于绝大多数的情况。

假设 ServiveX#methodX() 都工作在事务环境下（即都被 Spring 事务增强了），假设程序中存在如下的调用链：Service1#method1()->Service2#method2()->Service3#method3()，那么这 3 个服务类的 3 个方法通过 Spring 的事务传播机制都工作在同一个事务中。

就好比，我们刚才的几个方法存在调用，所以会被放在一组事务当中！

织入事务

<!-- 基于配置文件的事务管理-->
    <tx:advice id="txAdvice" transaction-manager="dataSourceTransactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

   <aop:config proxy-target-class="true">
       <aop:pointcut id="transcationPoint" expression="execution(* com.asher..*.*(..))"/>
       <aop:advisor advice-ref="txAdvice" pointcut-ref="transcationPoint"></aop:advisor>
   </aop:config>

进行测试

@Test
   public void test() {
       //  添加用户
       int i=userService.addUser(new User(4, "asher", "1234567"));
       System.out.println(i);
       // 删除用户
       int j =userService.deleteUser(4);
       System.out.println(j);

       //查询所有用户
       List<User> users=userService.selectUser();
       for (User user : users) {
           System.out.println(user);
       }
   }

基于注解的事务管理

配置事务管理器

<!-- 事务管理-->
    <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

开启注解事务事务驱动

1 2	<!-- 基于注解的事务管理--> <tx:annotation-driven transaction-manager="dataSourceTransactionManager"></tx:annotation-driven>

测试类中添加注解

1
2
3

@Transactional //基于注解事务管理
public class MyTest {
}