Java框架 Spring5--事务

1. 事务概念

1.1 什么是事务

（1）事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操

作都失败

（2）典型场景：银行转账

* lucy 转账 100 元给 mary

* lucy 少 100，mary 多 100

1.2 事务四个特性（ACID）

        ⚫ 原子性（Atomicity）：事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用。

  ⚫ 一致性 （Consistency）：一旦事务完成（不管成功还是失败），系统必须确保它所建模的业务处于一致的状态，而不会是部分完成部分失败。在现实中的数据不应该被破坏。

        ⚫ 隔离性 （Isolation）：可能有许多事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。

        ⚫ 持久性 （Durability）：一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响，这样就能从任何系统崩溃中恢复过来。通常情况下，事务的结果被写到持久化存储器中。

2. 搭建事务操作环境

2.1 创建数据库表，并添加记录


CREATE TABLE t_account(
	id INT PRIMARY KEY,
	username VARCHAR(20),
	money DECIMAL(10,2)
);
 
INSERT INTO t_account VALUES
(1,'lucy',1000),(2,'mary',1000);

2.2 编写spring配置文件


<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:context="http://www.springframework.org/schema/context"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   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">
 
	
	<context:component-scan base-package="com.chenyixin.spring5.demo_10_tx"/>
 
	
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
		  destroy-method="close">
		<property name="url" value="jdbc:mysql:///book_db"/>
		<property name="username" value="root"/>
		<property name="password" value="root"/>
		<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
	bean>
	
	
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"/>
	bean>
beans>

2.3 编写Java代码

1. service 注入 dao，在 dao 注入 JdbcTemplate，在 JdbcTemplate 注入 DataSource

2.在 dao 创建两个方法：多钱和少钱的方法，在 service 创建方法（转账的方法）

代码示例：

1. UserDaoImpl 类：


@Repository
public class UserDaoImpl implements UserDao {
 
    @Autowired
    private JdbcTemplate jdbcTemplate;
 
    @Override // name 增加 money 元
    public void addMoney(String name, BigDecimal money) {
        String sql = "update t_account set money = money + ? where username = ?";
        jdbcTemplate.update(sql, money, name);
    }
 
    @Override // name 减少 money 元
    public void reduceMoney(String name, BigDecimal money) {
        String sql = "update t_account set money = money - ? where username = ?";
        jdbcTemplate.update(sql, money, name);
    }
}

2. UserService 类


@Service
public class UserService {
    @Autowired
    private UserDao userDao;
 
    // 用户 username1 向 username2 转账 money 元
    public void accountMoney(String username1, String username2, BigDecimal money) {
        userDao.reduceMoney(username1,money);
        userDao.addMoney(username2,money);
    }
}

3.测试类


public class UserServiceTest {
    private static UserService userService = null;
    static {
        ApplicationContext context = 
        new ClassPathXmlApplicationContext("demo10_tx.xml");
 
        userService = context.getBean("userService", UserService.class);
    }
    @Test
    public void accountMoney() {
        // lucy 向 mary 转账 100 元
        userService.accountMoney("lucy","mary",new BigDecimal(100));
    }
}

结果：

2.4 代码执行过程中出现异常，有问题

上面代码，如果正常执行没有问题的，但是如果代码执行过程中出现异常，有问题


public void accountMoney(String username1, String username2, BigDecimal money) {
        userDao.reduceMoney(username1, money);
 
        // 模拟异常
        int i = 10 / 0;
 
        userDao.addMoney(username2, money);
    }

（1）上面问题如何解决呢？

使用事务进行解决

（2）事务操作过程（ 编程式事务管理）


// 用户 username1 向 username2 转账 money 元
    public void accountMoney(String username1, String username2, BigDecimal money) {
        try {
            // 第一步 开启事务
 
            // 第二步 进行业务操作
            userDao.reduceMoney(username1, money);
 
            // 模拟异常
            int i = 10 / 0;
 
            userDao.addMoney(username2, money);
 
            // 第三步 没有异常 提交事务
        } catch (Exception e) {
            // 第四步 出现异常 回滚事务
        }
    }

3. Spring 事务管理介绍

1、事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层）

2、在 Spring 进行事务管理操作

        有两种方式：编程式事务管理(如上代码)和声明式事务管理（推荐使用）

        1. 编程式事务管理
                编程式事务管理是侵入性事务管理，使用TransactionTemplate或者直接使用

PlatformTransactionManager，对于编程式事务管理，Spring推荐使用TransactionTemplate。

        2. 声明式事务管理
                声明式事务管理建立在AOP之上，其本质是对方法前后进行拦截，然后在目标方法

开始之前创建或者加入一个事务，执行完目标方法之后根据执行的情况提交或者回滚。

        3.区别
                编程式事务每次实现都要单独实现，但业务量大功能复杂时，使用编程式事务无疑是痛苦的，而声明式事务不同，声明式事务属于无侵入式，不会影响业务逻辑的实现，只需要在配置文件中做相关的事务规则声明或者通过注解的方式，便可以将事务规则应用到业务逻辑中。
                显然声明式事务管理要优于编程式事务管理，这正是Spring倡导的非侵入式的编程方式。唯一不足的地方就是声明式事务管理的粒度是方法级别，而编程式事务管理是可以到代码块的，但是可以通过提取方法的方式完成声明式事务管理的配置。

3、声明式事务管理

（1）基于注解方式（推荐使用）

（2）基于 xml 配置文件方式

4、在 Spring 进行声明式事务管理，底层使用 AOP 原理

5、Spring 事务管理 API

提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类

4. 注解声明式事务管理

4.1 在 spring 配置文件配置事务管理器

事务管理器

        无论使用Spring的哪种事务管理策略(编程式或声明式)，事务管理器都是必须的
事务管理器是Spring的核心事务管理抽象，管理封装了一组独立于技术的方法

@Transactional 注解的事务管理。

        默认配置下 Spring 只会回滚运行时、未检查异常(继承自 RuntimeException 的异常)或者 Error。
        @Transactional 注解只能应用到 public 方法才有效。
        使用mybatis ， spring boot 会自动配置一个 DataSourceTransactionManager，只需在方法(或者类)加上 @Transactional 注解，就自动纳入 Spring 的事务管理了。

代码示例：


	<bean id="transactionManager" 
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		
		<property name="dataSource" ref="dataSource"/>
	bean>

4.2 在 spring 配置文件，开启事务注解

（ 1 ）在 spring 配置文件引入名称空间 tx

（2）开启事务注解


<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:context="http://www.springframework.org/schema/context"
	   xmlns:tx="http://www.springframework.org/schema/tx"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   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/tx
	   http://www.springframework.org/schema/tx/spring-tx.xsd">
 
	
	<context:component-scan base-package="com.chenyixin.spring5.demo_10_tx"/>
 
	
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
		  destroy-method="close">
		<property name="url" value="jdbc:mysql:///book_db"/>
		<property name="username" value="root"/>
		<property name="password" value="root"/>
		<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
	bean>
 
	
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"/>
	bean>
 
	
	<bean id="transactionManager" 
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		
		<property name="dataSource" ref="dataSource"/>
	bean>
 
	
	<tx:annotation-driven transaction-manager="transactionManager"/>
beans>

4.3 在 service 类上面（或者 service 类里面方法上面）添加事务注解

（1）@Transactional，这个注解添加到类上面，也可以添加方法上面

（2）如果把这个注解添加类上面，这个类里面所有的方法都添加事务

（3）如果把这个注解添加方法上面，为这个方法添加事务


@Service
@Transactional
public class UserService {
    @Autowired
    private UserDao userDao;
 
    // 用户 username1 向 username2 转账 money 元
    public void accountMoney(String username1, String username2, BigDecimal money) {
        userDao.reduceMoney(username1, money);
 
        // 模拟异常
        int i = 10 / 0;
        userDao.addMoney(username2, money);
    }
}

5. 声明式事务管理参数配置

5.1 注解@Transactional 或 xml文件tx中 attributes 属性中，可以配置事务相关参数

5.2 propagation：事务传播行为

事务的传播性一般用在事务嵌套 的场景，比如一个事务方法里面调用了另外一个事务方法，那么两个方法是各自作为独立的方法提交还是内层的事务合并到外层的事务一起提交，这就是需要事务传播机制的配置来确定怎么样执行。

常用的事务传播机制如下：

事务	功能
REQUIRED	Spring默认的传播机制，能满足绝大部分业务需求，如果外层有事务，则当前事务加入到外层事务，一块提交，一块回滚。如果外层没有事务，新建一个事务执行
REQUES_NEW	该事务传播机制是每次都会新开启一个事务，同时把外层事务挂起，当当前事务执行完毕，恢复上层事务的执行。如果外层没有事务，执行当前新开启的事务即可
SUPPORT	如果外层有事务，则加入外层事务，如果外层没有事务，则直接使用非事务方式执行。完全依赖外层的事务
NOT_SUPPORT	该传播机制不支持事务，如果外层存在事务则挂起，执行完当前代码，则恢复外层事务，无论是否异常都不会回滚当前的代码
NEVER	该传播机制不支持外层事务，即如果外层有事务就抛出异常
MANDATORY	与NEVER相反，如果外层没有事务，则抛出异常
NESTED	该传播机制的特点是可以保存状态保存点，当前事务回滚到某一个点，从而避免所有的嵌套事务都回滚，即各自回滚各自的，如果子事务没有把异常吃掉，基本还是会引起全部回滚的。传播规则回答了这样一个问题：一个新的事务应该被启动还是被挂起，或者是一个方法是否应该在事务性上下文中运行。

如：

5.3 ioslation：事务隔离级别

事务的隔离级别定义一个事务可能受其他并发务活动活动影响的程度，可以把事务的隔离级别想象为这个事务对于事物处理数据的自私程度。

在一个典型的应用程序中，多个事务同时运行，经常会为了完成他们的工作而操作同一个数据。并发虽然是必需的，但是会导致以下问题：

脏读（Dirty read）
        脏读发生在一个事务读取了被另一个事务改写但尚未提交的数据时。如果这些改变在稍后被回滚了，那么第一个事务读取的数据就会是无效的。

不可重复读（Nonrepeatable read）
        不可重复读发生在一个事务执行相同的查询两次或两次以上，但每次查询结果都不相同时。这通常是由于另一个并发事务在两次查询之间更新了数据。不可重复读重点在修改。

幻读（Phantom reads）
        幻读和不可重复读相似。当一个事务（T1）读取几行记录后，另一个并发事务（T2）插入了一些记录时，幻读就发生了。在后来的查询中，第一个事务（T1）就会发现一些原来没有的额外记录。幻读重点在新增或删除。

在理想状态下，事务之间将完全隔离，从而可以防止这些问题发生。然而，完全隔离会影响性能，因为隔离经常涉及到锁定在数据库中的记录（甚至有时是锁表）。完全隔离要求事务相互等待来完成工作，会阻碍并发。因此，可以根据业务场景选择不同的隔离级别。

READ_UNCOMMITTED
        允许读取尚未提交的更改。可能导致脏读、幻读或不可重复读。

READ_COMMITTED （Oracle 默认级别）
        允许从已经提交的并发事务读取。可防止脏读，但幻读和不可重复读仍可能会发生。

REPEATABLE_READ （MYSQL默认级别）
        对相同字段的多次读取的结果是一致的，除非数据被当前事务本身改变。可防止脏读和不可重复读，但幻读仍可能发生。

ISERIALIZABLE
        完全服从ACID的隔离级别，确保不发生脏读、不可重复读和幻影读。这在所有隔离级别中也是最慢的，因为它通常是通过完全锁定当前事务所涉及的数据表来完成的。

如：

5.4 timeout：超时时间

事务超时

（ 1 ）事务需要在一定时间内进行提交，如果不提交进行回滚

（2）默认值是 -1 ，设置时间以秒单位进行计算

        为了使一个应用程序很好地执行，它的事务不能运行太长时间。因此，声明式事务的下一个特性就是它的超时。

        假设事务的运行时间变得格外的长，由于事务可能涉及对数据库的锁定，所以长时间运行的事务会不必要地占用数据库资源。这时就可以声明一个事务在特定秒数后自动回滚，不必等它自己结束。

        由于超时时钟在一个事务启动的时候开始的，因此，只有对于那些具有可能启动一个新事务的传播行为（PROPAGATION_REQUIRES_NEW、PROPAGATION_REQUIRED、ROPAGATION_NESTED）的方法来说，声明事务超时才有意义。

如：

5.5 readOnly：是否只读

只读

（ 1 ）读：查询操作，写：添加修改删除操作

（2） readOnly 默认值 false ，表示可以查询，可以添加修改删除操作

（3）设置 readOnly 值是 true ，设置成 true 之后，只能查询

如果一个事务只对数据库执行读操作，那么该数据库就可能利用那个事务的只读特性，采取某些优化措施。通过把一个事务声明为只读，可以给后端数据库一个机会来应用那些它认为合适的优化措施。由于只读的优化措施是在一个事务启动时由后端数据库实施的，因此，只有对于那些具有可能启动一个新事务的传播行为（PROPAGATION_REQUIRES_NEW、PROPAGATION_REQUIRED、 ROPAGATION_NESTED）的方法来说，将事务声明为只读才有意义。

如：

5.6 rollbackFor 与 noRollbackFor ：是否回滚

回滚规则

（ 1） rollbackFor ：设置出现哪些异常进行事务回滚

（2） noRollbackFor ：设置出现哪些异常不进行事务回滚

在默认设置下，事务只在出现运行时异常（runtime exception）时回滚，而在出现受检查异常（checked exception）时不回滚（这一行为和EJB中的回滚行为是一致的）。

不过，可以声明在出现特定受检查异常时像运行时异常一样回滚。同样，也可以声明一个事务在出现特定的异常时不回滚，即使特定的异常是运行时异常。

spring-framework-5.0.x.rar

rar

0星超过10%的资源 30.91MB

下载

如：

6. XML 声明式事务管理

6.1 在 spring 配置文件中进行配置

第一步配置事务管理器

第二步配置通知

第三步配置切入点和切面


<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:context="http://www.springframework.org/schema/context"
	   xmlns:aop="http://www.springframework.org/schema/aop"
	   xmlns:tx="http://www.springframework.org/schema/tx"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   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/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">
 
 
	
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
		  destroy-method="close">
		<property name="url" value="jdbc:mysql:///book_db"/>
		<property name="username" value="root"/>
		<property name="password" value="root"/>
		<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
	bean>
 
	
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"/>
	bean>
 
	
	<bean id="transactionManager" 
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		
		<property name="dataSource" ref="dataSource"/>
	bean>
 
	
	<tx:advice id="txAdvice">
		
		<tx:attributes>
			
			<tx:method name="accountMoney" propagation="REQUIRED" isolation="REPEATABLE_READ"/>
			
		tx:attributes>
	tx:advice>
 
	
	<aop:config>
		
		<aop:pointcut id="pt" expression="execution(* com.chenyixin.spring5.demo_10_tx.service.UserService.*(..))"/>
 
		
		<aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
	aop:config>
 
beans>

6.2 测试


 @Test
    public void accountMoney2() {
        // lucy 向 mary 转账 100 元
        ApplicationContext context = 
        new ClassPathXmlApplicationContext("demo10_tx_xml.xml");
 
        UserService userService = context.getBean("userService", UserService.class);
        userService.accountMoney("lucy","mary",new BigDecimal(100));
    }

结果：

说明回滚成功

7. 完全注解声明式事务管理

7.1 创建配置类，使用配置类替代 xml 配置文件

1. 创建配置类，在类上添加 @Configuration（声明配置类）、@ComponentScan（声明开启注解扫描）、@EnableTransactionManagement（声明开启事务）注解

2. 创建数据库连接池

3. 创建 JdbcTemplate 对象

4 .创建事务管理器


@Configuration // 声明 配置类
@ComponentScan(basePackages = "com.chenyixin.spring5.demo_10_tx") // 注解扫描
@EnableTransactionManagement // 开启事务
public class txConfig {
    // 创建数据库连接池
    @Bean // 与xml文件中bean标签作用相同
    public DruidDataSource getDruidDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///book_db");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }
 
    // 创建 JdbcTemplate 对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        // 到 ioc 容器中根据类型找到 dataSource
        // 注入 dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }
    // 创建事务管理器
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource) {
        DataSourceTransactionManager manager = new DataSourceTransactionManager();
        manager.setDataSource(dataSource);
        return manager;
    }
}

7.2 测试


@Test
    public void accountMoney3() {
        ApplicationContext context = new AnnotationConfigApplicationContext("txConfig");
        UserService userService = context.getBean("userService", UserService.class);
        // lucy 向 mary 转账 100 元
        userService.accountMoney("lucy","mary",new BigDecimal(100));
    }

结果：

说明回滚成功

相关阅读:
Flow 3D学习记录
 字节给我狠狠上了一课：危机来的时候你连准备时间都没有~
nodejs+vue+elementui毕业设计论文选题过程管理系统
 Python的NumPy库（一）基础用法
 msyql事务ACID特性及其实现原理
 算法的时间复杂度与空间复杂度
 mysql部署
 软考高项考试历程回顾
 type_traits元编程库学习
 通过Vue-cli搭建spa项目
原文地址：https://blog.csdn.net/weixin_65637841/article/details/126200511