专栏首页好好学java的技术栈Spring 事务底层原理,你会了吗?

Spring 事务底层原理,你会了吗?

作者:香沙小熊
链接:https://www.jianshu.com/p/fc97500bcb5f

一、数据库的事物的基本特性

事物是区分文件存储系统与Nosql数据库重要特性之一,其存在的意义是为了保证即使在并发情况下也能正确的执行crud操作。怎样才算是正确的呢?这时提出了事物需要保证的四个特性即ACID:

  • A: 原子性(atomicity)事物中各项操作,要么全做要么全不做,任何一项操作的失败都会导致整个事物的失败;
  • C: 一致性(consistency)事物结束后系统状态是一致的;
  • I: 隔离性(isolation)并发执行的事物彼此无法看到对方的中间状态;
  • D: 持久性(durability)事物完成后所做的改动都会被持久化,即使发生灾难性的失败。在高并发的情况下,要完全保证其ACID特性是非常困难的,除非把所有的事物串行化执行,但带来的负面的影响将是性能大打折扣。很多时候我们有些业务对事物的要求是不一样的,所以数据库中设计了四种隔离级别,供用户基于业务进行选择。

隔离级别

脏读(Dirty Read)

不可重复读(NonRepeatable Read)

幻读(Phantom Read)

读未提交(Read uncommitted)

可能

可能

可能

读已提交(Read committed)

不可能

可能

可能

可重复读(Repeatable read)

不可能

不可能

可能

可串行化(SERIALIZABLE)

不可能

不可能

不可能

脏读 :

一个事物读取到另一事物未提交的更新数据

不可重复读 :

在同一事物中,多次读取同一数据返回的结果有所不同, 换句话说, 后续读取可以读到另一事物已提交的更新数据. 相反, “可重复读”在同一事物中多次读取数据时, 能够保证所读数据一样, 也就是后续读取不能读到另一事物已提交的更新数据。

幻读 :

查询表中一条数据如果不存在就插入一条,并发的时候却发现,里面居然有两条相同的数据。这就幻读的问题。

二、Sring 对事物的支持与使用

知识点:1.spring 事物相关API说明 2.声明式事物的使用 3.事物传播机制

  1. spring 事物相关API说明 spring 事物是在数据库事物的基础上进行封装扩展 其主要特性如下:a.支持原有的数据事物的隔离级别 b.加入了事物传播的概念 提供多个事物的和并或隔离的功能 c.提供声明式事物,让业务代码与事物分离,事物变得更易用。

怎么样去使用Spring事物呢?spring 提供了三个接口供使用事物。分别是:

  • TransactionDefinition 事物定义

image.png

  • PlatformTransactionManager 事物管理

image.png

  • TransactionStatus 事物运行时状态

image.png

基于API实现事物
public class SpringTransactionExample {
    private static String url = "jdbc:mysql:///localhost:3306/test";
    private static String user = "root";
    private static String password = "123456";

    public static Connection openConnection() throws ClassNotFoundException, SQLException {
        Class.forName("com.mysql.jdbc.Driver");
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
        return conn;
    }

    public static void main(String[] args) {
        final DriverManagerDataSource ds = new DriverManagerDataSource(url, user, password);
        final TransactionTemplate template = new TransactionTemplate();
        template.setTransactionManager(new DataSourceTransactionManager(ds));
        template.execute(new TransactionCallback<Object>() {
            @Override
            public Object doInTransaction(TransactionStatus status) {
                Connection conn = DataSourceUtils.getConnection(ds);
                Object savePoint = null;
                try {
                    {
                        // 插入
                        PreparedStatement prepare = conn.
                                prepareStatement("insert INTO account (accountName,user,money) VALUES (?,?,?)");
                        prepare.setString(1, "111");
                        prepare.setString(2, "aaaa");
                        prepare.setInt(3, 10000);
                        prepare.executeUpdate();
                    }
                    // 设置保存点
                    savePoint = status.createSavepoint();
                    {
                        // 插入
                        PreparedStatement prepare = conn.
                                prepareStatement("insert INTO account (accountName,user,money) VALUES (?,?,?)");
                        prepare.setString(1, "222");
                        prepare.setString(2, "bbb");
                        prepare.setInt(3, 10000);
                        prepare.executeUpdate();
                    }
                    {
                        // 更新
                        PreparedStatement prepare = conn.
                                prepareStatement("UPDATE account SET money= money+1 where user=?");
                        prepare.setString(1, "asdflkjaf");
                        Assert.isTrue(prepare.executeUpdate() > 0, "");
                    }
                } catch (SQLException e) {
                    e.printStackTrace();
                } catch (Exception e) {
                    System.out.println("更新失败");
                    if (savePoint != null) {
                        status.rollbackToSavepoint(savePoint);
                    } else {
                        status.setRollbackOnly();
                    }
                }
                return null;
            }
        });
    }
}

输出

更新失败

查询数据库

2、声明示事物

我们前面是通过调用API来实现对事物的控制,这非常的繁琐,与直接操作JDBC事物并没有太多的改善,所以Spring提出了声明示事物,使我们对事物的操作变得非常简单,甚至不需要关心它。

编写服务类

@Transactional

public void addAccount(String name, int initMenoy) {

String accountid = new SimpleDateFormat("yyyyMMddhhmmss").format(new Date());

jdbcTemplate.update("insert INTO account (accountName,user,money) VALUES (?,?,?)", accountid, name, initMenoy);

// 人为报错

int i = 1 / 0;</code>

}

演示添加 @Transactional 注解和不添加注解的情况。

3、事物传播机制

类别

事物传播类型

说明

支持当前事物

PROPAGATION_REQUIRED

(必须的)

如果当前没有事物,就新建一个事物,如果已经存在一个事物中,加入到这个事物中。这是最常见的选择。

支持当前事物

PROPAGATION_SUPPORTS

(支持)

支持当前事物,如果当前没有事物,就以非事物方式执行。

支持当前事物

PROPAGATION_MANDATORY

(强制)

使用当前的事物,如果当前没有事物,就抛出异常。

不支持当前事物

PROPAGATION_REQUIRES_NEW

(隔离)

新建事物,如果当前存在事物,把当前事物挂起。

不支持当前事物

PROPAGATION_NOT_SUPPORTED

(不支持)

以非事物方式执行操作,如果当前存在事物,就把当前事物挂起。

不支持当前事物

PROPAGATION_NEVER

(强制非事物)

以非事物方式执行,如果当前存在事物,则抛出异常。

套事物

PROPAGATION_NESTED

(嵌套事物)

如果当前存在事物,则在嵌套事物内执行。如果当前没有事物,则执行与PROPAGATION_REQUIRED类似的操作。

常用事物传播机制:

  • PROPAGATION_REQUIRED, 这个也是默认的传播机制;
  • PROPAGATION_NOT_SUPPORTED 可以用于发送提示消息,站内信、短信、邮件提示等。不属于并且不应当影响主体业务逻辑,即使发送失败也不应该对主体业务逻辑回滚。
  • PROPAGATION_REQUIRES_NEW 总是新启一个事物,这个传播机制适用于不受父方法事物影响的操作,比如某些业务场景下需要记录业务日志,用于异步反查,那么不管主体业务逻辑是否完成,日志都需要记录下来,不能因为主体业务逻辑报错而丢失日志;

l 演示常用事物的传播机制

用例1:

创建用户时初始化一个帐户,表结构和服务类如下。

表结构

服务类

功能描述

user

UserSerivce

创建用户,并添加帐户

account

AccountService

添加帐户

UserSerivce.createUser(name) 实现代码

@Transactional
public void createUser(String name) {

    // 新增用户基本信息

    jdbcTemplate.update("INSERT INTO `user` (name) VALUES(?)", name);

    //调用accountService添加帐户

    accountService.addAccount(name, 10000);

 }

AccountService.addAccount(name,initMoney) 实现代码(方法的最后有一个异常)

@Transactional(propagation = Propagation.REQUIRED)
public void addAccount(String name, int initMoney) {

    String accountid = new SimpleDateFormat("yyyyMMddhhmmss").format(new Date());

    jdbcTemplate.update("insert INTO account (accountName,user,money) VALUES (?,?,?)", accountid, name, initMenoy);

    // 出现分母为零的异常

    int i = 1 / 0;

}

实验预测一:

createUser

addAccount(异常)

预测结果

场景一

无事物

required

createUser (成功) addAccount(不成功)

场景二

required

无事物

createUser (不成功) addAccount(不成功)

场景三

required

not_supported

createUser (不成功) addAccount(成功)

场景四

required

required_new

createUser (不成功) addAccount(不成功)

场景五

required(异常移至createUser方法未尾)

required_new

createUser(不成功)

addAccount(成功)

场景六

required(异常移至createUser方法未尾)(addAccount 方法移至createUser方法的同一个类里)

required_new

createUser (不成功) addAccount(不成功)

三、aop 事物底层实现原理

讲事物原理之前我们先来做一个实验,当场景五的环境改变,把addAccount 方法移至UserService 类下,其它配置和代码不变:

@Override
@Transactional
public void createUser(String name) {

    jdbcTemplate.update("INSERT INTO `user` (name) VALUES(?)", name);

    addAccount(name, 10000);

    // 人为报错
    int i = 1 / 0;

}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void addAccount(String name, int initMoney) {

    String accountid = new SimpleDateFormat("yyyyMMddhhmmss").format(new Date());

    jdbcTemplate.update("insert INTO account (accountName,user,money) VALUES (?,?,?)", accountid, name, initMoney);

}

演示新场景

经过演示我们发现得出的结果与场景五并不 一至,required_new 没有起到其对应的作用。原因在于spring 声明示事物使用动态代理实现,而当调用同一个类的方法时,是会不会走代理逻辑的,自然事物的配置也会失效。

通过一个动态代理的实现来模拟这种场景

UserSerivce proxyUserSerivce = (UserSerivce) Proxy.newProxyInstance(LubanTransaction.class.getClassLoader(),
        new Class[]{UserSerivce.class}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                try {

                    System.out.println("开启事物:"+method.getName());

                    return method.invoke(userSerivce, args);

                } finally {

                    System.out.println("关闭事物:"+method.getName());

                }

            }

        });

proxyUserSerivce.createUser("kpioneer");

当我们调用createUser 方法时 仅打印了 createUser 的事物开启、关闭,并没有打印addAccount 方法的事物开启、关闭,由此可见addAccount 的事物配置是失效的。

如果业务当中上真有这种场景该如何实现呢?在spring xml中配置 暴露proxy 对象,然后在代码中用AopContext.currentProxy() 就可以获当前代理对象

<!-- 配置暴露proxy -->
<aop:aspectj-autoproxy expose-proxy="true"/>

// 基于代理对象调用创建帐户,事物的配置又生效了

@Transactional
public void createUser(String name) {

    // 新增用户基本信息

    jdbcTemplate.update("INSERT INTO `user` (name) VALUES(?)", name);

    // 暴露proxy 对象 调用accountService添加帐户
    ((UserSerivce) AopContext.currentProxy()).addAccount(name, 10000);
    // 人为报错
    int i = 1 / 0;
 }
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void addAccount(String name, int initMoney) {

    String accountid = new SimpleDateFormat("yyyyMMddhhmmss").format(new Date());

    jdbcTemplate.update("insert INTO account (accountName,user,money) VALUES (?,?,?)", accountid, name, initMoney);
}
但是并不推荐这样写事务,还是另写AccountService类 调用addAccount最好

本文分享自微信公众号 - 好好学java(SIHAIloveJAVA)

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2020-03-14

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Spring AOP 中 JDK 和 CGLib 动态代理哪个更快?

    昨天一位小伙伴面试的时候被问到:Spring AOP中JDK和CGLib动态代理哪个效率更高?在知识星球整理了一下,今天特分享出来,供大家参考!

    好好学java
  • 微信支付和支付宝支付到springmvc+spring+mybatis环境全过程(支付宝和微信支付)

    好好学java
  • Github上 10 个开源免费且优秀的后台控制面板

    Web 开发中几乎的平台都需要一个后台管理,但是从零开发一套后台控制面板并不容易,幸运的是有很多开源免费的后台控制面板可以给开发者使用,那么有哪些优秀的开源免费...

    好好学java
  • 总结 2014 年中国互联网十大段子

      段子年年有,今年特别多。追寻回忆,搜集了一年中和互联网行业相关的一些段子,以飨读者。网络段子或赞扬或讽刺,或嘲弄,或戏谑,或调侃,或规劝,目的尽在不言中。一...

    小莹莹
  • LinkedHashMap和LruCache源码分析

    LinkedHashMap是HashMap的子类,与HashMap有着同样的存储结构,但它加入了一个双向链表的头结点,将所有put到LinkedHashMap的...

    曾大稳
  • MongoDB 稀疏(间隙)索引(Sparse Indexes)

    a、间隙索引就是创建索引的索引列在某些文档上列不存在,导致索引存在间隙。 b、间隙索引在创建时应指定选项:{ sparse: true } c、间隙索引...

    Leshami
  • Ambari集成Elasticsearch 5.x

    1、资源URL https://github.com/Jaraxal/ambari-elasticsearch-service 下载得到ambari-ela...

    程裕强
  • Scrum与OKR融合实践经验分享

    很多软件公司的研发团队都喜欢用Scrum管理研发流程,Scrum是一个诞生于20世纪90年代的敏捷方法论,CORNERSTONE内部也一直在使用这一方法。

    CORNERSTONE
  • 动态调用类中的方法(无)(有)参数

    1、Type类,方法用Invoke调用的时候就 使用null:表示该方法是无参数的

    静心物语313
  • 物联网入门:搭建MQTT服务器

    MQTT(消息队列遥测传输)是ISO 标准下基于发布/订阅范式的消息协议。它工作在 TCP/IP协议族上,是为硬件性能低下的远程设备以及网络状况糟糕的情况下而设...

    无敌小笼包

扫码关注云+社区

领取腾讯云代金券