首页 > > 程序设计 > Java技术 >

spring5 源码深度解析----- @Transactional注解…

2019-10-12 08:39:49来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

spring5 源码深度解析----- @Transactional注解的声明式事物介绍（100%理解事务）

面的几个章节已经分析了spring基于@AspectJ的源码，那么接下来我们分析一下Aop的另一个重要功能，事物管理。

事务的介绍

1.数据库事物特性

  • 原子性
    多个数据库操作是不可分割的，只有所有的操作都执行成功，事物才能被提交；只要有一个操作执行失败，那么所有的操作都要回滚，数据库状态必须回复到操作之前的状态
  • 一致性
    事物操作成功后，数据库的状态和业务规则必须一致。例如：从A账户转账100元到B账户，无论数据库操作成功失败，A和B两个账户的存款总额是不变的。
  • 隔离性
    当并发操作时，不同的数据库事物之间不会相互干扰（当然这个事物隔离级别也是有关系的）
  • 持久性
    事物提交成功之后，事物中的所有数据都必须持久化到数据库中。即使事物提交之后数据库立刻崩溃，也需要保证数据能能够被恢复。

2.事物隔离级别

当数据库并发操作时，可能会引起脏读、不可重复读、幻读、第一类丢失更新、第二类更新丢失等现象。

  • 脏读
    事物A读取事物B尚未提交的更改数据，并做了修改；此时如果事物B回滚，那么事物A读取到的数据是无效的，此时就发生了脏读。
  • 不可重复读
    一个事务执行相同的查询两次或两次以上，每次都得到不同的数据。如：A事物下查询账户余额，此时恰巧B事物给账户里转账100元，A事物再次查询账户余额，那么A事物的两次查询结果是不一致的。
  • 幻读
    A事物读取B事物提交的新增数据，此时A事物将出现幻读现象。幻读与不可重复读容易混淆，如何区分呢？幻读是读取到了其他事物提交的新数据，不可重复读是读取到了已经提交事物的更改数据（修改或删除）

对于以上问题，可以有多个解决方案，设置数据库事物隔离级别就是其中的一种，数据库事物隔离级别分为四个等级，通过一个表格描述其作用。

隔离级别脏读不可重复读幻象读
READ UNCOMMITTED 允许 允许 允许
READ COMMITTED 脏读 允许 允许
REPEATABLE READ 不允许 不允许 允许
SERIALIZABLE 不允许 不允许 不允许

3.Spring事物支持核心接口

 
  • TransactionDefinition-->定义与spring兼容的事务属性的接口
public interface TransactionDefinition {
    // 如果当前没有事物，则新建一个事物；如果已经存在一个事物，则加入到这个事物中。
    int PROPAGATION_REQUIRED = 0;
    // 支持当前事物，如果当前没有事物，则以非事物方式执行。
    int PROPAGATION_SUPPORTS = 1;
    // 使用当前事物，如果当前没有事物，则抛出异常。
    int PROPAGATION_MANDATORY = 2;
    // 新建事物，如果当前已经存在事物，则挂起当前事物。
    int PROPAGATION_REQUIRES_NEW = 3;
    // 以非事物方式执行，如果当前存在事物，则挂起当前事物。
    int PROPAGATION_NOT_SUPPORTED = 4;
    // 以非事物方式执行，如果当前存在事物，则抛出异常。
    int PROPAGATION_NEVER = 5;
    // 如果当前存在事物，则在嵌套事物内执行；如果当前没有事物，则与PROPAGATION_REQUIRED传播特性相同
    int PROPAGATION_NESTED = 6;
    // 使用后端数据库默认的隔离级别。
    int ISOLATION_DEFAULT = -1;
    // READ_UNCOMMITTED 隔离级别
    int ISOLATION_READ_UNCOMMITTED = Connection.TRANSACTION_READ_UNCOMMITTED;
    // READ_COMMITTED 隔离级别
    int ISOLATION_READ_COMMITTED = Connection.TRANSACTION_READ_COMMITTED;
    // REPEATABLE_READ 隔离级别
    int ISOLATION_REPEATABLE_READ = Connection.TRANSACTION_REPEATABLE_READ;
    // SERIALIZABLE 隔离级别
    int ISOLATION_SERIALIZABLE = Connection.TRANSACTION_SERIALIZABLE;
    // 默认超时时间
    int TIMEOUT_DEFAULT = -1;
    // 获取事物传播特性
    int getPropagationBehavior();
    // 获取事物隔离级别
    int getIsolationLevel();
    // 获取事物超时时间
    int getTimeout();
    // 判断事物是否可读
    boolean isReadOnly();
    // 获取事物名称
    @Nullable
    String getName();
}
  1. Spring事物传播特性表：
传播特性名称说明
PROPAGATION_REQUIRED 如果当前没有事物，则新建一个事物；如果已经存在一个事物，则加入到这个事物中
PROPAGATION_SUPPORTS 支持当前事物，如果当前没有事物，则以非事物方式执行
PROPAGATION_MANDATORY 使用当前事物，如果当前没有事物，则抛出异常
PROPAGATION_REQUIRES_NEW 新建事物，如果当前已经存在事物，则挂起当前事物
PROPAGATION_NOT_SUPPORTED 以非事物方式执行，如果当前存在事物，则挂起当前事物
PROPAGATION_NEVER 以非事物方式执行，如果当前存在事物，则抛出异常
PROPAGATION_NESTED

如果当前存在事物，则在嵌套事物内执行；

如果当前没有事物，则与PROPAGATION_REQUIRED传播特性相同
  1. Spring事物隔离级别表：
事务隔离级别  脏读  不可重复读  幻读
 读未提交（read-uncommitted）  是  是  是
 不可重复读（read-committed）  否   是  是
 可重复读（repeatable-read）  否   否   是
 串行化（serializable）  否   否   否 

mysql默认的事务隔离级别为 可重复读repeatable-read

　　3.PlatformTransactionManager-->Spring事务基础结构中的中心接口

public interface PlatformTransactionManager {
    // 根据指定的传播行为，返回当前活动的事务或创建新事务。
    TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException;
    // 就给定事务的状态提交给定事务。
    void commit(TransactionStatus status) throws TransactionException;
    // 执行给定事务的回滚。
    void rollback(TransactionStatus status) throws TransactionException;
}

Spring将事物管理委托给底层的持久化框架来完成，因此，Spring为不同的持久化框架提供了不同的PlatformTransactionManager接口实现。列举几个Spring自带的事物管理器：

事物管理器说明
org.springframework.jdbc.datasource.DataSourceTransactionManager 提供对单个javax.sql.DataSource事务管理，用于Spring JDBC抽象框架、iBATIS或MyBatis框架的事务管理
org.springframework.orm.jpa.JpaTransactionManager 提供对单个javax.persistence.EntityManagerFactory事务支持，用于集成JPA实现框架时的事务管理
org.springframework.transaction.jta.JtaTransactionManager 提供对分布式事务管理的支持，并将事务管理委托给Java EE应用服务器事务管理器

 

  • TransactionStatus-->事物状态描述
  1. TransactionStatus接口
public interface TransactionStatus extends SavepointManager, Flushable {
    // 返回当前事务是否为新事务（否则将参与到现有事务中，或者可能一开始就不在实际事务中运行）
    boolean isNewTransaction();
    // 返回该事务是否在内部携带保存点，也就是说，已经创建为基于保存点的嵌套事务。
    boolean hasSavepoint();
    // 设置事务仅回滚。
    void setRollbackOnly();
    // 返回事务是否已标记为仅回滚
    boolean isRollbackOnly();
    // 将会话刷新到数据存储区
    @Override
    void flush();
    // 返回事物是否已经完成，无论提交或者回滚。
    boolean isCompleted();
}
  1. SavepointManager接口
public interface SavepointManager {
    // 创建一个新的保存点。
    Object createSavepoint() throws TransactionException;
    // 回滚到给定的保存点。
    // 注意：调用此方法回滚到给定的保存点之后，不会自动释放保存点，
    // 可以通过调用releaseSavepoint方法释放保存点。
    void rollbackToSavepoint(Object savepoint) throws TransactionException;
    // 显式释放给定的保存点。（大多数事务管理器将在事务完成时自动释放保存点）
    void releaseSavepoint(Object savepoint) throws TransactionException;
}

Spring编程式事物

  • 表
CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '自增主键',
  `balance` int(11) DEFAULT NULL COMMENT '账户余额',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COMMENT='--账户表'
  • 实现
 1 import org.apache.commons.dbcp.BasicDataSource;
 2 import org.springframework.dao.DataAccessException;
 3 import org.springframework.jdbc.core.JdbcTemplate;
 4 import org.springframework.jdbc.datasource.DataSourceTransactionManager;
 5 import org.springframework.transaction.TransactionDefinition;
 6 import org.springframework.transaction.TransactionStatus;
 7 import org.springframework.transaction.support.DefaultTransactionDefinition;
 8 
 9 import javax.sql.DataSource;
10 
11 /**
12  * Spring编程式事物
13  * @author: Chenhao
14  * @create: 2019-10-08 11:41
15  */
16 public class MyTransaction {
17 
18     private JdbcTemplate jdbcTemplate;
19     private DataSourceTransactionManager txManager;
20     private DefaultTransactionDefinition txDefinition;
21     private String insert_sql = "insert into account (balance) values ('100')";
22 
23     public void save() {
24 
25         // 1、初始化jdbcTemplate
26         DataSource dataSource = getDataSource();
27         jdbcTemplate = new JdbcTemplate(dataSource);
28 
29         // 2、创建物管理器
30         txManager = new DataSourceTransactionManager();
31         txManager.setDataSource(dataSource);
32 
33         // 3、定义事物属性
34         txDefinition = new DefaultTransactionDefinition();
35         txDefinition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
36 
37         // 3、开启事物
38         TransactionStatus txStatus = txManager.getTransaction(txDefinition);
39 
40         // 4、执行业务逻辑
41         try {
42             jdbcTemplate.execute(insert_sql);
43             //int i = 1/0;
44             jdbcTemplate.execute(insert_sql);
45             txManager.commit(txStatus);
46         } catch (DataAccessException e) {
47             txManager.rollback(txStatus);
48             e.printStackTrace();
49         }
50 
51     }
52 
53     public DataSource getDataSource() {
54         BasicDataSource dataSource = new BasicDataSource();
55         dataSource.setDriverClassName("com.mysql.jdbc.Driver");
56         dataSource.setUrl("jdbc:mysql://localhost:3306/my_test?useSSL=false&useUnicode=true&characterEncoding=UTF-8");
57         dataSource.setUsername("root");
58         dataSource.setPassword("chenhao1991@");
59         return dataSource;
60     }
61 
62 }
  • 测试类及结果
public class MyTest {
    @Test
    public void test1() {
        MyTransaction myTransaction = new MyTransaction();
        myTransaction.save();
    }
}

运行测试类，在抛出异常之后手动回滚事物，所以数据库表中不会增加记录。

基于@Transactional注解的声明式事物

其底层建立在 AOP 的基础之上，对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。通过声明式事物，无需在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明（或通过等价的基于标注的方式），便可以将事务规则应用到业务逻辑中。

  • 接口
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

/**
 * 账户接口
 * @author: ChenHao
 * @create: 2019-10-08 18:38
 */
@Transactional(propagation = Propagation.REQUIRED)
public interface AccountServiceImp {
    void save() throws RuntimeException;
}
  • 实现
import org.springframework.jdbc.core.JdbcTemplate;

/**
 * 账户接口实现
 * @author: ChenHao
 * @create: 2019-10-08 18:39
 */
public class AccountServiceImpl implements AccountServiceImp {

    private JdbcTemplate jdbcTemplate;

    private static String insert_sql = "insert into account(balance) values (100)";


    @Override
    public void save() throws RuntimeException {
        System.out.println("==开始执行sql");
        jdbcTemplate.update(insert_sql);
        System.out.println("==结束执行sql");

        System.out.println("==准备抛出异常");
        throw new RuntimeException("==手动抛出一个异常");
    }

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
}
  • 配置文件
<?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"
       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">

    <!--开启tx注解-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

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

    <!--数据源-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/my_test?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="chenhao1991@"/>
    </bean>

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

    <!--业务bean-->
    <bean id="accountService" class="com.chenhao.aop.AccountServiceImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>

</beans>
  • 测试
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author: ChenHao
 * @create: 2019-10-08 18:45
 */
public class MyTest {

    @Test
    public void test1() {
        // 基于tx标签的声明式事物
        ApplicationContext ctx = new ClassPathXmlApplicationContext("aop.xml");
        AccountServiceImp studentService = ctx.getBean("accountService", AccountServiceImp.class);
        studentService.save();
    }
}
  • 测试
==开始执行sql
==结束执行sql
==准备抛出异常

java.lang.RuntimeException: ==手动抛出一个异常

    at com.lyc.cn.v2.day09.AccountServiceImpl.save(AccountServiceImpl.java:24)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)

测试方法中手动抛出了一个异常，Spring会自动回滚事物，查看数据库可以看到并没有新增记录。

注意：默认情况下Spring中的事务处理只对RuntimeException方法进行回滚，所以，如果此处将RuntimeException替换成普通的Exception不会产生回滚效果。

接下来我们就分析基于@Transactional注解的声明式事物的的源码实现。

   

 


原文链接:https://www.cnblogs.com/java-chen-hao/p/11635525.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：SpringBootSecurity学习（21）前后端分离版之OAuth2.0非对称加密

下一篇：【Dubbo】Zookeeper+Dubbo项目demo搭建

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签