Spring源码解析之编程式事务

更新时间：2021年06月10日 16:58:54 作者：星夜孤帆

今天给大家带来的是关于Java Spring的相关知识,文章围绕着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编程式事务内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

利用Java快速查找21位花朵数示例代码
这篇文章主要给大家介绍了关于利用Java快速查找21位花朵数的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习，需要的朋友们下面随着小编来一起学习学习吧。
2017-10-10
教你怎么用Java开发扫雷游戏
我们那时候上机经常玩扫雷,试想如果我当年可以用 java 写个扫雷出来,那场面不用我多说了吧,大家让开,我要开始装逼了,之前用JavaScript写过了一个扫雷,这次我用java再写了一遍,权当是复习咯.文中有非常详细的代码示例,需要的朋友可以参考下
2021-05-05
基于Zookeeper实现服务注册和服务发现功能
无论是采用SOA还是微服务架构,都需要使用服务注册和服务发现组件,本文将基于 Zookeeper 实现服务注册和服务发现功能,如果跟我一样有同样的困惑,希望可以通过本文了解其他组件如何使用 Zookeeper 作为注册中心的工作原理
2023-09-09
Swing拆分窗格控件JSplitPane使用详解
这篇文章主要为大家详细介绍了Swing拆分窗格控件JSplitPane的使用方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2017-11-11
Java反射(JDK)与动态代理(CGLIB)详解
下面小编就为大家带来一篇浅谈Java反射与动态代理。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2021-08-08
SpringBoot项目启动错误:找不到或无法加载主类的几种解决方法
本文主要介绍了SpringBoot项目启动错误:找不到或无法加载主类的几种解决方法,具有一定的参考价值,感兴趣的可以了解一下
2025-03-03
Spring MVC @GetMapping和@PostMapping注解的使用方式
这篇文章主要介绍了Spring MVC @GetMapping和@PostMapping注解的使用方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2024-05-05
Java多线程揭秘之synchronized工作原理
synchronized算是多线程中非常常用的加锁方式了，但很多人都不太理解其底层的工作原理。本篇文章博主用尽可能通俗易懂的方式来带大家去看看synchronized究竟是怎么加锁的
2021-10-10
Java实现FIFO、LRU、LFU、OPT页面置换算法
本文主要介绍了Java实现FIFO、LRU、LFU、OPT页面置换算法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2023-02-02
Mybatis-Plus中的@TableName 和 table-prefix使用
table-prefix 是一个全局配置,它会自动在所有表名前添加指定的前缀,这个配置对于那些使用一致命名约定的数据库表非常有用,这篇文章主要介绍了Mybatis-Plus中的@TableName 和 table-prefix使用,需要的朋友可以参考下
2024-08-08