Spring源码解析之编程式事务

一、前言

在Spring中,事务有两种实现方式:

编程式事务管理: 编程式事务管理使用TransactionTemplate可实现更细粒度的事务控制。声明式事务管理: 基于Spring AOP实现。其本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加入一个事务,在执行完目标方法之后根据执行情况提交或者回滚事务。

声明式事务管理不需要入侵代码,通过@Transactional就可以进行事务操作,更快捷而且简单(尤其是配合spring boot自动配置,可以说是精简至极!),且大部分业务都可以满足,推荐使用。

其实不管是编程式事务还是声明式事务,最终调用的底层核心代码是一致的。本文主要介绍编程式事务的一些应用,以及独有的源码分析,再在其他文章中进入核心源码贯穿式讲解。

二、编程式事务解析

编程式事务,Spring已经给我们提供好了模板类TransactionTemplate,可以很方便的使用,如下图:

TransactionTemplate全路径名是:org.springframework.transaction.support.TransactionTemplate。看包名也知道了这是spring对事务的模板类。(spring动不动就是各种Template...),看下类图先:

实现了TransactionOperations、InitializingBean这2个接口(熟悉spring源码的知道这个InitializingBean又是老套路),我们来看下接口源码如下:

public interface TransactionOperations {

	@Nullable
	<T> T execute(TransactionCallback<T> action) throws TransactionException;

}

public interface InitializingBean {

	void afterPropertiesSet() throws Exception;

}

如上图,TransactionOperations这个接口用来执行事务的回调方法,InitializingBean这个是典型的spring bean初始化流程中的预留接口,专用用来在bean属性加载完毕时执行的方法。

回到正题,TransactionCallback和TransactionCallbackWithoutResult做了什么

@FunctionalInterface
public interface TransactionCallback<T> {

	@Nullable
	T doInTransaction(TransactionStatus status);

}

public abstract class TransactionCallbackWithoutResult implements TransactionCallback<Object> {

	@Override
	@Nullable
	public final Object doInTransaction(TransactionStatus status) {
		doInTransactionWithoutResult(status);
		return null;
	}

	protected abstract void doInTransactionWithoutResult(TransactionStatus status);

}

可见TransactionCallbackWithResult实现了TransactionCallback接口,重写了doIntransaction方法,在内部调用了doInTransactionWithoutResult方法,帮我们返回了null,所以,我们就不需要再指定返回值了。

TransactionTemplate的2个接口的impl方法做了什么?

@Override
    public void afterPropertiesSet() {
        if (this.transactionManager == null) {
            throw new IllegalArgumentException("Property 'transactionManager' is required");
        }
    }

    @Override
    public <T> T execute(TransactionCallback<T> action) throws TransactionException {       // 内部封装好的事务管理器
        if (this.transactionManager instanceof CallbackPreferringPlatformTransactionManager) {
            return ((CallbackPreferringPlatformTransactionManager) this.transactionManager).execute(this, action);
        }// 需要手动获取事务,执行方法,提交事务的管理器
        else {// 1.获取事务状态
            TransactionStatus status = this.transactionManager.getTransaction(this);
            T result;
            try {// 2.执行业务逻辑
                result = action.doInTransaction(status);
            }
            catch (RuntimeException ex) {
                // 应用运行时异常 -> 回滚
                rollbackOnException(status, ex);
                throw ex;
            }
            catch (Error err) {
                // Error异常 -> 回滚
                rollbackOnException(status, err);
                throw err;
            }
            catch (Throwable ex) {
                // 未知异常 -> 回滚
                rollbackOnException(status, ex);
                throw new UndeclaredThrowableException(ex, "TransactionCallback threw undeclared checked exception");
            }// 3.事务提交
            this.transactionManager.commit(status);
            return result;
        }
    }

如上图所示,实际上afterPropertiesSet只是校验了事务管理器不为空,execute()才是核心方法,execute主要步骤:

1.getTransaction()获取事务

2.doInTransaction()执行业务逻辑,这里就是用户自定义的业务代码。如果是没有返回值的,就是doInTransactionWithoutResult()。

3.commit()事务提交:调用AbstractPlatformTransactionManager的commit,rollbackOnException()异常回滚:调用AbstractPlatformTransactionManager的rollback(),事务提交回滚。源码见后续文章

三、编程式事务示例

public class SpringTransactionExample {

    private static String url = "jdbc:mysql://localhost:3306/spring_transaction?useSSL=false&characterEncoding=utf-8&autoReconnect=true";
    private static String user = "root";
    private static String password = "root";

    public static void main(String[] args) {
        // 获取数据源
        final DataSource 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 transactionStatus) {
                Connection conn = DataSourceUtils.getConnection(ds);
                Object savePoint = null;
                try {
                    {
                        // 插入
                        PreparedStatement prepare = conn.prepareStatement("insert into person(id, name) values (?, ?)");
                        prepare.setString(1, "1");
                        prepare.setString(2, "1111");
                        prepare.executeUpdate();
                    }

                    // 设置保存点,回滚的化,不会回滚保存点之前的操作
                    savePoint = transactionStatus.createSavepoint();
                    {
                        // 插入
                        PreparedStatement prepare = conn.prepareStatement("insert into person(id, name) values (?, ?)");
                        prepare.setString(1, "2");
                        prepare.setString(2, "222");
                        prepare.executeUpdate();
                    }

                    {
                        // 更新
                        PreparedStatement prepare = conn.prepareStatement("update person set name = ? where id = ?");
                        prepare.setString(1, "jak");
                        prepare.setInt(2, 6);
                        prepare.executeUpdate();

                        // 模拟异常
//                        int i = 1 / 0;
                    }
                } catch (SQLException e) {
                    e.printStackTrace();
                } catch (Exception e) {
                    System.out.println("更新失败");
                    if (savePoint != null) {
                        // 回滚到保存点
                        transactionStatus.rollbackToSavepoint(savePoint);
                    } else {
                        transactionStatus.setRollbackOnly();
                    }
                }
                return null;
            }
        });
    }
}

四、TransactionCallback

编程式事务带返回值

public class TransactionCallBackTest {
    private static String url = "jdbc:mysql://localhost:3306/spring_transaction?useSSL=false&characterEncoding=utf-8&autoReconnect=true";
    private static String user = "root";
    private static String password = "root";

    public static void main(String[] args) {
        // 获取数据源
        final DataSource ds = new DriverManagerDataSource(url, user, password);
        // 编程式事务
        final TransactionTemplate template = new TransactionTemplate();
        // 设置事务管理器
        template.setTransactionManager(new DataSourceTransactionManager(ds));
        Connection connection = DataSourceUtils.getConnection(ds);
        test1(template, connection);
        test2(template, connection);
    }

    // 方式一: 匿名内部类
    @SuppressWarnings("all")
    public static void test1(TransactionTemplate template,  Connection connection) {
        // TransactionCallback有返回值
        template.execute(new TransactionCallback<Object>() {
            @Override
            public Object doInTransaction(TransactionStatus status) {
                try {
                    // 插入
                    PreparedStatement prepare = connection.prepareStatement("insert into person(id, name) values (?, ?)");
                    prepare.setInt(1, 1);
                    prepare.setString(2, "jak");
                    prepare.executeUpdate();
                    // 模拟异常
                    // int i = 1 / 0;
                    System.out.println("数据已插入");
                } catch (SQLException e) {
                    e.printStackTrace();
                } catch (Exception e) {
                    System.out.println("更新失败");
                    status.setRollbackOnly();
                }
                return null;
            }
        });
    }

    // 方式二:lamda表达式
    @SuppressWarnings("all")
    public static void test2(TransactionTemplate template,  Connection connection) {
        template.execute((status) -> {
            try {
                // 插入
                PreparedStatement prepare = connection.prepareStatement("insert into person(id, name) values (?, ?)");
                prepare.setInt(1, 2);
                prepare.setString(2, "hyd");
                prepare.executeUpdate();
                // 模拟异常
                // int i = 1 / 0;
                System.out.println("数据已插入");
            } catch (SQLException e) {
                e.printStackTrace();
            } catch (Exception e) {
                System.out.println("更新失败");
                status.setRollbackOnly();
            }
            return null;
        });
    }

}

五、TransactionCallbackWithoutResult

编程式事务不带返回值

public class TransactionCallbackWithoutResultTest {

    private static String url = "jdbc:mysql://localhost:3306/spring_transaction?useSSL=false&characterEncoding=utf-8&autoReconnect=true";
    private static String user = "root";
    private static String password = "root";

    @SuppressWarnings("all")
    public static void test(TransactionTemplate template, Connection connection) {
        template.execute(new TransactionCallbackWithoutResult() {
            // doInTransactionWithoutResult无返回值
            @Override
            public void doInTransactionWithoutResult(TransactionStatus status) {
                try {
                    // 插入
                    PreparedStatement prepare = connection.prepareStatement("insert into person(id, name) values (?, ?)");
                    prepare.setInt(1, 1);
                    prepare.setString(2, "jak");
                    prepare.executeUpdate();
                    // 模拟异常
                    // int i = 1 / 0;
                    System.out.println("数据已插入");
                } catch (SQLException e) {
                    e.printStackTrace();
                } catch (Exception e) {
                    System.out.println("更新失败");
                    status.setRollbackOnly();
                }
            }
        });
    }

    public static void main(String[] args) {
        // 获取数据源
        final DataSource ds = new DriverManagerDataSource(url, user, password);
        // 编程式事务
        final TransactionTemplate template = new TransactionTemplate();
        // 设置事务管理器
        template.setTransactionManager(new DataSourceTransactionManager(ds));
        Connection connection = DataSourceUtils.getConnection(ds);
        test(template, connection);
    }
}

踩坑指南,上述方式 不知道为啥,事务一直不回滚,改为jdbcTemplate方式,可以正常回滚,不知道什么原因

public class jdbcTemplateTest {

    private static String url = "jdbc:mysql://localhost:3306/spring_transaction?useSSL=false&characterEncoding=utf-8&autoReconnect=true";
    private static String user = "root";
    private static String password = "root";

    @SuppressWarnings("all")
    public static void test(TransactionTemplate template,  JdbcTemplate jdbcTemplate) {
        template.execute(new TransactionCallbackWithoutResult() {
            // doInTransactionWithoutResult无返回值
            @SneakyThrows
            @Override
            public void doInTransactionWithoutResult(TransactionStatus status) {
                try {
                    // 插入
                    jdbcTemplate.execute("insert into person(id, name) values (2, 'jak')");
                    // 模拟异常
                    int i = 1 / 0;
                    System.out.println("数据已插入");
                } catch (Exception e) {
                    // 标记事务回滚
                    status.setRollbackOnly();
                }
            }
        });
    }

    public static void main(String[] args) {
        // 获取数据源
        final DataSource ds = new DriverManagerDataSource(url, user, password);
        // 编程式事务
        final TransactionTemplate template = new TransactionTemplate();
        // jdbcTemplate
        final JdbcTemplate jdbcTemplate = new JdbcTemplate();
        // 设置事务管理器
        template.setTransactionManager(new DataSourceTransactionManager(ds));
        // 配置数据源
        jdbcTemplate.setDataSource(ds);
        test(template,  jdbcTemplate);
    }
}

参考文章、参考文章

到此这篇关于Spring源码解析之编程式事务的文章就介绍到这了,更多相关Spring编程式事务内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Spring源码解析之事务传播特性

    一.使用方式 可以采用Transactional,配置propagation即可. 打开org.springframework.transaction.annotation.Transactional可见默认传播特性是REQUIRED. /** * The transaction propagation type. * <p>Defaults to {@link Propagation#REQUIRED}. * @see org.springframework.transaction.inte

  • Spring编程式和声明式事务实例讲解小结

    Spring事务管理 Spring支持两种方式的事务管理: 编程式事务管理: 通过Transaction Template手动管理事务,实际应用中很少使用, 使用XML配置声明式事务: 推荐使用(代码侵入性最小),实际是通过AOP实现 实现声明式事务的四种方式: 基于 TransactionInterceptor 的声明式事务: Spring 声明式事务的基础,通常也不建议使用这种方式,但是与前面一样,了解这种方式对理解 Spring 声明式事务有很大作用. 基于 TransactionProx

  • 带大家深入了解Spring事务

    一.数据库事务简介 构成单一逻辑工作单元的操作集合称作事务(transaction).即使有故障,数据库系统也必须保证事务的正确执行--要么执行整个事务,要么属于该事务的操作一个也不执行.以资金转账为例,应该保证支票账户支出金额的操作和储蓄账户的存入金额的操作在同一个逻辑工作单元内完成.简言之,事务是访问并可能更新各种数据项的一个程序执行单元(unit). 二.事务的特性 数据库需要维护事务的以下四个性质: 1.原子性(Atomicity)事务是一个原子操作,由一系列动作组成.事务的原子性确保这

  • Spring的编程式事务和声明式事务详解

    入口(了解一些基本概念) Spring事务属性(事务的属性有哪些?) 我们都知道事务有开始,保存点,提交,回滚,隔离级别等属性.那么Spring对于事务属性定义有哪些呢?通过TransactionDefinition接口我们可以了解到: public interface TransactionDefinition{ int getIsolationLevel(); int getPropagationBehavior(); int getTimeout(); boolean isReadOnly

  • Spring中的事务控制知识总结

    一.环境准备 为了演示 Spring 中的事务控制,我们创建一个空项目,项目目录如下: 导入依赖: <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.2.RELEASE</version> </dependency&g

  • 详解Spring学习之编程式事务管理

    前言 在前面的内容,基本已经学习了事务的基本概念以及事务隔离级别等,接下来的几个小节,将学习怎么使用Spring进行事务管理,在Spring中,对事务进行管理有多种方法,主要分别编程式和声明式,本小节主要学习编程式事务管理,后面讲学习Spring的声明式事务管理 编程式事务管理 所谓的编程式事务管理,其实就是通过编写代码的方式来进行事务管理,也就是通过将事务管理的代码硬编码在代码中从而达到事务管理的作用,不过Spring的事务管理不同于JDBC原始的事务管理,在JDBC中,对事务进行管理首先要关

  • Spring源码解析之编程式事务

    一.前言 在Spring中,事务有两种实现方式: 编程式事务管理: 编程式事务管理使用TransactionTemplate可实现更细粒度的事务控制.声明式事务管理: 基于Spring AOP实现.其本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加入一个事务,在执行完目标方法之后根据执行情况提交或者回滚事务. 声明式事务管理不需要入侵代码,通过@Transactional就可以进行事务操作,更快捷而且简单(尤其是配合spring boot自动配置,可以说是精简至极!),且大部分业务都可

  • 从Spring源码解析事务失效的原因

    目录 一.前言 二.方法不是 public 的 三.内部方法间调用导致事务失效 四.异常类型是否配置正确 五.异常被catch住 一.前言 1.Bean是否是代理对象 2.入口函数是否是public的 3.数据库是否支持事务(Mysql的Mvlsam不支持事务),行锁才支持事务 4.切点是否配置正确 5.内部方法间调用导致事务失效 因为this不是代理对象,可以配置 expose-proxy="true",就可以通过AopContext.currentProxy()获取到当前类的代理对

  • Spring源码解析之Configuration

    一.@Configuration 1.1 未加@Configuration <!--logback-test.xml,配置不打印日志--> <?xml version="1.0" encoding="UTF-8"?> <configuration> <include resource="org/springframework/boot/logging/logback/base.xml" /> <

  • Spring源码解析之BeanPostProcessor知识总结

    一.简介 BeanPostProcessor是Spring IOC容器给我们提供的一个扩展接口. 实例化Bean做前置处理.后置处理 二.接口定义 @Component public class BeanPost implements BeanPostProcessor { /** * 在每个bean创建之后的初始化方法之前调用 * @param bean 当前实例化的bean * @param beanName bean的名称 * @return 返回实例化的bean或者可以对对象进行再封装返

  • Spring源码解析之推断构造方法

    Spring推断构造方法 贴个测试代码直接开干,这只是个样例,其他情况自行分析 @Component public class OrderService { public OrderService() { System.out.println("无参构造方法"); } @Autowired(required = false) public OrderService(UserService userService) { System.out.println("一个参数的构造方法

  • Spring源码解析之Bean的生命周期

    一.Bean的实例化概述 前一篇分析了BeanDefinition的封装过程,最终将beanName与BeanDefinition以一对一映射关系放到beanDefinitionMap容器中,这一篇重点分析如何利用bean的定义信息BeanDefinition实例化bean. 二.流程概览 其实bean的实例化过程比较复杂,中间细节很多,为了抓住重点,先将核心流程梳理出来,主要包含以下几个流程: step1: 通过反射创建实例: step2:给实例属性赋初始值: step3:如果Bean类实现B

  • Spring源码解析容器初始化构造方法

    目录 前言 构造方法 前言 Spring框架被广泛应用于我们的日常工作中,但是很长时间以来我都是只会使用,不懂它的作用原理.通过最近一段时间的阅读源码,个人发现通过阅读源码,能够帮助我们了解Spring的设计理念,并且对Java编程中的一些设计模式更加熟悉,所以记录一下自己对Spring源码的理解. 在开始进行源码学习前,首先再回顾一下三种Spring编程风格: 基于Schema,即通过xml标签的配置方式 基于Annotation的注解技术,使用@Component等注解配置bean 基于Ja

  • Spring源码解析 Bean的实例化

    目录 前言 准备工作 实例化bean 1.AbstractBeanFactory 的 doGetBean方法 2.AbstractAutowireCapableBeanFactory 的 createBean方法 3.AbstractAutowireCapableBeanFactory 的 doCreateBean方法 4.AbstractAutowireCapableBeanFactory 的 createBeanInstance方法 5.AbstractAutowireCapableBean

  • Spring源码解析后置处理器梳理总结

    目录 前言 1.InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation()方法 2.SmartInstantiationAwareBeanPostProcessor的determineCandidateConstructors()方法 3.MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition()方法 4.SmartInstantiationA

随机推荐