04【Spring声明式事、传播行为、AOP事务控制】

一、Spring声明式事务

1.1 回顾事务

1.1.1 什么是事务？

如果一个业务操作中多次访问了数据库，必须保证每条SQL语句都执行成功。如果其中有一条执行失败，所有已经执行过的代码必须回滚。回到没有执行前的状态。称为事务。要么所有的SQL语句全部执行成功，要么全部失败。

1.1.2 事务四大特性

事务特性	含义
原子性（Atomicity）	事务是工作的最小单元，整个工作单元要么全部执行成功，要么全部执行失败
一致性（Consistency）	事务执行前与执行后，数据库中数据应该保持相同的状态。如：转账前总金额与转账后总金额相同。
隔离性（Isolation）	事务与事务之间不能互相影响，必须保持隔离性。
持久性（Durability）	如果事务执行成功，对数据库的操作是持久的。

1.1.3 事务并发访问问题

并发访问下事务产生的问题：

当同时有多个用户在访问同一张表中的记录，每个用户在访问的时候都是一个单独的事务。

事务在操作时的理想状态是：事务之间不应该相互影响，实际应用的时候会引发下面三种问题。应该尽量避免这些问题的发生。通过数据库本身的功能去避免，设置不同的隔离级别。

• 脏读： 一个事务（用户）读取到了另一个事务没有提交的数据
• 不可重复读：一个事务多次读取同一条记录，出现读取数据不一致的情况。一般因为另一个事务更新了这条记录而引发的。
• 幻读：在一次事务中，多次读取到的条数不一致

1.1.4 事务隔离级别

级别	名字	隔离级别	脏读	不可重复读	幻读	数据库默认隔离级别
1	读未提交	read uncommitted	是	是	是
2	读已提交	read committed	否	是	是	Oracle和SQL Server
3	可重复读	repeatable read	否	否	是	MySQL
4	串行化	serializable	否	否	否

• 1）Read uncommitted (读未提交)： 简称RU隔离级别，所有事务中的并发访问问题都会发生，读取的是其他事务没有提交的数据

• 2）Read committed (读已提交)：简称RC隔离级别，会引发不可重复读和幻读的问题，读取的永远是其他事务提交的数据

• 3）Repeatable read (可重复读)：简称RR隔离级别，有可能会引发幻读的问题，一次事务读取到的同一行数据，永远是一样

• 4）Serializable (串行化)： 可以避免所有事务产生的并发访问的问题 效率及其低下

1.1.5 MySQL事务相关命令

• 测试表：

drop table if exists account;-- 创建数据表  
CREATE TABLE account (  id INT PRIMARY KEY AUTO_INCREMENT,  name VARCHAR(10),  money DOUBLE  
);  -- 添加数据  
INSERT INTO account (name, money) VALUES ('a', 1000), ('b', 1000);

• 查询事务隔离级别：

select @@tx_isolation;

• 设置事务隔离级别：

set global transaction isolation level 四种隔离;set global transaction isolation level read uncommitted;
set global transaction isolation level read committed;
set global transaction isolation level repeatable read;
set global transaction isolation level serializable;

需要重启客户端会话

• 开启事务：

start transaction;
或者
begin;

• 提交事务：

commit;

• 回滚事务：

rollback;

1.2 Spring事务管理介绍

1.2.1 编程式事务

• 什么是编程式事务？

编程式事务简单的来说就是采用编程的方式来管理事务，编程式事务需要将事务管理的代码写入到业务方法中，相对于核心业务而言，事务管理的代码显然属于非核心业务，对核心业务代码的侵入性太大；而且如果多个模块都使用同样模式的代码进行事务管理，显然会造成较大程度的代码冗余。

我们之前使用的JDBC API来操作事务就是编程式事务；

1.2.2 声明式事务

• 什么是声明式事务？

声明式事务以声明的方式来实现事务管理，其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

声明式事务简单的来说就是通过一些表达式声明（拦截）一堆需要被事务管理的方法，然后被声明（拦截）的方法通过AOP的方式进行事务管理（执行目标方法之前开启事务，执行目标方法之后提交或者回滚事务）

显然声明式事务管理要优于编程式事务管理：它将事务管理代码从业务方法中分离出来，这正是Spring倡导的非侵入式的开发方式。声明式事务管理使业务代码不受干扰；一个普通的对象，只要加上注解就可以获得完全的事务支持。

声明式事务唯一不足地方是，它的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法等等。

1.2.3 Spring事务管理器

Spring从不同的事务管理API中抽象出了一整套事务管理机制，让事务管理代码从特定的事务技术中独立出来。开发人员通过配置的方式进行事务管理，而不必了解其底层是如何实现的。

Spring所有的事务管理策略类都继承自org.springframework.transaction.PlatformTransactionManager接口。

它为事务管理封装了一组独立于技术的方法。无论使用Spring的哪种事务管理策略（编程式或声明式），事务管理器都是必须的。

• 事务管理器主要的实现：
  • DataSourceTransactionManager：使用Spring JDBC 或 Mybatis 等基于DataSource数据源的持久化技术时，使用 该事务管理器
  • JpaTransactionManager：使用JPA时采用的事务管理器
  • JtaTransactionManager：具有多个数据源的全局事务使用该事务管理器
  • JdoTransactionManager：使用JDO进行持久化时 ，使用该事务管理器
  • HibernateTransactionManager：使用Hibernate进行持久化时，使用该事务管理器

1.2.4 事务传播行为

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。

例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。事务的传播行为可以由传播属性指定。Spring定义了7种类传播行为，在org.springframework.transaction.TransactionDefinition类中被定义。

静态常量	说明
PROPAGATION_REQUIRED	如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择，也是Spring的默认值。
PROPAGATION_SUPPORTS	支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY	使用当前的事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW	新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED	以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER	以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED	如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。

TransactionDefinition类中不仅定义了事务的传播行为，也定义了很多事务的隔离级别：

静态常量	说明
ISOLATION_DEFAULT	使用数据库默认的隔离级别，Spring默认值
ISOLATION_READ_UNCOMMITTED	读未提交
ISOLATION_READ_COMMITTED	读已提交
ISOLATION_REPEATABLE_READ	可重复读
ISOLATION_SERIALIZABLE	串行化

1.3 Spring实现声明式事务

1.3.1 案例准备

1）SQL脚本：

drop database if exists spring;create database spring;use spring;-- 创建数据表  
CREATE TABLE account (  id INT PRIMARY KEY AUTO_INCREMENT,  name VARCHAR(10),  money DOUBLE  
);  -- 添加数据  
INSERT INTO account (name, money) VALUES ('a', 1000), ('b', 1000);

2）Maven依赖：

<?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>com.dfbz</groupId><artifactId>01_Spring</artifactId><version>1.0-SNAPSHOT</version><dependencies><!--spring基本环境依赖--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.9.RELEASE</version></dependency><!--spring对jdbc的支持(DataSourceTransaction)--><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.2.9.RELEASE</version></dependency><!--spring对事物的支持--><dependency><groupId>org.springframework</groupId><artifactId>spring-tx</artifactId><version>5.2.9.RELEASE</version></dependency><!--spring对切面AspectsJ的支持--><dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>5.2.9.RELEASE</version></dependency><!--spring对junit的整合--><dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.2.9.RELEASE</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.48</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.2.1</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.18</version></dependency></dependencies></project>

3）jdbc.properties：

jdbc.username=root
jdbc.password=admin
jdbc.url=jdbc:mysql:///spring
jdbc.driverClassName=com.mysql.jdbc.Driver

4）实体类：

package com.dfbz.entity;import lombok.Data;/*** @author lscl* @version 1.0* @intro:*/
@Data
public class Account {private Integer id;private String name;private Double money;
}

1.3.2 事务通知XML配置

1）Spring配置：

<?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:tx="http://www.springframework.org/schema/tx"xmlns:context="http://www.springframework.org/schema/context"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/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"><!--组件扫描--><context:component-scan base-package="com.dfbz" /><!--加载配置文件--><context:property-placeholder location="classpath:jdbc.properties"/><!--druid数据源--><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="username" value="${jdbc.username}"></property><property name="password" value="${jdbc.password}"></property><property name="url" value="${jdbc.url}"></property><property name="driverClassName" value="${jdbc.driverClassName}"></property></bean><bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"><property name="dataSource" ref="dataSource"></property></bean><!-- 配置事务管理器 --><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><!--引用数据源--><property name="dataSource" ref="dataSource"/></bean><!--配置事务通知--><tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><!--isolation:事务隔离级别DEFAULT:使用数据库默认的隔离级别(默认值)READ_UNCOMMITTED:读未提交READ_COMMITTED:读已提交REPEATABLE_READ:可重复读SERIALIZABLE:串行化propagation: 事务传播行为REQUIRED:必须要有事务,如果已经存在事务,则加入到这个事务中,如果没有事务则创建一个新的事务SUPPORTS:支持当前事务,如果调用这个方法之前没有事务则不会开启新的事务MANDATORY:必须存在事务,如果调用此方法之前没有事务,就抛出异常REQUIRES_NEW:新建事务,如果调用此方法之前就已经开启过事务，则将之前的事务挂起NOT_SUPPORTED:非事务方式,如果调用此方法之前就存在事务,则挂起事务NEVER:非事务方式运行,如果调用此方法之前存在事务,则抛出异常NESTED:如果存在事务,则嵌套在事务内执行,如果没有事务则与REQUIRED保存一致read-only: 是否只读true: 只读false:非只读(默认值)timeout: 方法执行超时时间,默认值为-1,代表永不超时,单位为秒rollback-for: 指定特定的异常才回滚(默认情况下,任何的运行时异常事务都会回滚,但编译时异常都不会进行回滚),该配置针对于编译时异常;可以写多个,以逗号隔开no-rollback-for: 指定一个特定的异常事务不回滚,可以写多个,以逗号隔开-->
<!--            <tx:method name="query*" isolation="DEFAULT"propagation="REQUIRED" read-only="true" timeout="3"rollback-for="java.lang.NullPointerException,java.lang.ClassCastException"no-rollback-for="java.lang.ArithmeticException"  />-->
<!--            <tx:method name="query*" read-only="true"/>-->
<!--            <tx:method name="select*" read-only="true"/>-->
<!--            <tx:method name="query*" read-only="true"/>-->
<!--            <tx:method name="save*" read-only="true"/>-->
<!--            <tx:method name="insert*" />-->
<!--            <tx:method name="add*" />-->
<!--            <tx:method name="update*" />-->
<!--            <tx:method name="modify*" />-->
<!--            <tx:method name="delete*" />-->
<!--            <tx:method name="remove*" />--><!--出现ArithmeticException异常不回滚--><tx:method name="transfer" no-rollback-for="java.lang.ArithmeticException"/></tx:attributes></tx:advice><!--配置切面--><aop:config><!--定义切入点--><aop:pointcut id="myPoint" expression="execution(* com.dfbz.service.AccountService.*(..))"/><!--将通知应用到切入点上(织入)--><aop:advisor advice-ref="txAdvice" pointcut-ref="myPoint"></aop:advisor></aop:config>
</beans>

**默认情况下，任何的运行时异常事务都会回滚，但编译时异常都不会进行回滚；**我们可以通过一些配置来调整

• no-rollback-for：指定什么异常不回滚，可以写多个，以逗号隔开；

• rollback-for：该配置针对于编译时异常；可以写多个，以逗号隔开；

上述两个参数在指定异常时，如果指定某个异常的父类，包括这个异常的所有子类异常都会回滚；

如：no-rollback-for指定的参数是Exception则代表Java中的任何异常都不回滚，

rollback-for指定的参数是Exception则Java中任何的异常都回滚；

2）业务类：

package com.dfbz.service;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;/*** @author lscl* @version 1.0* @intro:*/
@Service
public class AccountService {@Autowiredprivate JdbcTemplate jdbcTemplate;/*** @param str     : 谁要转账* @param target: 转账给谁* @param flag:   模拟异常 true:出现异常 false:不出现异常*/public void transfer(String str, String target, Boolean flag) {jdbcTemplate.update("update account set money=money-500 where name=?", str);if (flag) {// 模拟异常int i = 1 / 0;}jdbcTemplate.update("update account set money=money+500 where name=?", target);}/**** @param id*/public void findById(Integer id) {Account account = jdbcTemplate.queryForObject("select * from account where id=?",new BeanPropertyRowMapper<>(Account.class),id);}
}

3）测试类

package com.dfbz.test;import com.dfbz.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;/*** @author lscl* @version 1.0* @intro:*/
@RunWith(SpringRunner.class)
@ContextConfiguration(locations = "classpath:spring.xml")
public class Demo01 {@Autowiredprivate AccountService accountService;@Testpublic void test1(){accountService.transfer("a","b",false);}
}

1.3.3 注解配置

1）Spring配置

<?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:tx="http://www.springframework.org/schema/tx"xmlns:context="http://www.springframework.org/schema/context"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/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"><!--组件扫描--><context:component-scan base-package="com.dfbz" /><!--加载配置文件--><context:property-placeholder location="classpath:jdbc.properties"/><!--druid数据源--><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="username" value="${jdbc.username}"></property><property name="password" value="${jdbc.password}"></property><property name="url" value="${jdbc.url}"></property><property name="driverClassName" value="${jdbc.driverClassName}"></property></bean><bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"><property name="dataSource" ref="dataSource"></property></bean><!-- 配置事务管理器 --><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><!--引用数据源--><property name="dataSource" ref="dataSource"/></bean><!--开启事务注解驱动transaction-manager: 指定事务管理的名称,默认为transactionManager--><tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven></beans>

2）业务类

package com.dfbz.service;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;/*** @author lscl* @version 1.0* @intro:*/
@Service
public class AccountService {@Autowiredprivate JdbcTemplate jdbcTemplate;/*** @param str     : 谁要转账* @param target: 转账给谁* @param flag:   模拟异常 true:出现异常 false:不出现异常*/
/*    @Transactional(transactionManager = "transactionManager",              // 事务管理器的名称propagation = Propagation.REQUIRED,                     // 传播行为isolation = Isolation.DEFAULT,                          // 隔离级别timeout = 3000,                                         // 超时时间readOnly = false,                                       // 是否只读rollbackFor = {MyException.class},       				// 出现该异常回滚noRollbackFor = {ArithmeticException.class}             // 出现指定异常不回滚)    */@Transactional              // 使用注解方式管理事务public void transfer(String str, String target, Boolean flag) {jdbcTemplate.update("update account set money=money-500 where name=?", str);if (flag) {// 模拟异常int i = 1 / 0;}jdbcTemplate.update("update account set money=money+500 where name=?", target);}
}

3）测试类

package com.dfbz.test;import com.dfbz.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;/*** @author lscl* @version 1.0* @intro:*/
@RunWith(SpringRunner.class)
@ContextConfiguration(locations = "classpath:spring2.xml")
public class Demo02 {@Autowiredprivate AccountService accountService;@Testpublic void test1(){accountService.transfer("a","b",false);}
}