【源码剖析】Spring 事务详解

shadowLogo

在之前的博文中，本人讲解了 Spring IOC 和 Spring AOP 的 核心源码

在本人讲解 Spring的API使用 系列的博文中，本人也说过：

Spring Framework 框架 最核心的三个功能，就是 Spring IOC、Spring AOP 和 Spring 事务管理

那么，在本文中，本人就来讲解下 Spring 事务管理 的相关源码：

API 调用：

操作表：

account表
inventory

配置类：

package edu.youzg.tx.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@EnableTransactionManagement
@Configuration
@ComponentScan("edu.youzg.tx")
public class YouzgConfig {

    /**
     * 数据库连接 配置
     */
    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        dataSource.setUrl("jdbc:mysql://localhost:3306/explore_source?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=UTF-8");
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        return dataSource;
    }

    /**
     * 事务管理器 配置
     */
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    /**
     * jdbc模板 配置
     */
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

}

业务类：

package edu.youzg.tx.service;

import edu.youzg.tx.pojo.Account;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

/**
 * @Author: Youzg
 * @CreateTime: 2021-03-22 20:23
 * @Description: 带你深究Java的本质！
 */
@Service
public class AccountService {

    @Resource
    private JdbcTemplate jdbcTemplate;

    //public void add(Account account) {
    //    String sql = "insert into account(id, name, money) values (?, ?, ?)";
    //    int add = jdbcTemplate.update(sql, account.getId(), account.getName(), account.getMoney());
    //}
    //
    //public void save(Account account) {
    //    String sql = "update account set money=? where name=?";
    //    int update = jdbcTemplate.update(sql, account.getMoney(), account.getName());
    //}

    /**
     * 查询 货物价格
     *
     * @param goodsId 货物id
     */
    @Transactional(rollbackFor = Exception.class, readOnly = true)
    public Integer selectInventoryCost(Integer goodsId) {
        String selectSql = "select cost from inventory where id=?";
        Integer cost = jdbcTemplate.queryForObject(selectSql, new Object[] { goodsId }, Integer.class);
        return cost;
    }

    /**
     * 减少 库存
     *
     * @param goodsId 货物id
     */
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
    public void decriseInventoryCount(Integer goodsId) {
        String decriseSql = "update inventory set count=count-1 where id=?";
        jdbcTemplate.update(decriseSql, goodsId);
    }

    /**
     * 扣除 用户金额
     *
     * @param accountName 用户名
     * @param cost 开销
     */
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.SUPPORTS)
    public void deductAccountMoney(String accountName, Integer cost) {
        String decriseSql = "update account set money=account.money-? where name=?";
        jdbcTemplate.update(decriseSql, cost, accountName);
    }

    /**
     * 用户下单
     * @param goodsId 货物id
     * @param accountName 用户名
     */
    @Transactional(rollbackFor = Exception.class)
    public void sold(Integer goodsId, String accountName) {
        decriseInventoryCount(goodsId); // 修改 库存表
        Integer cost = selectInventoryCost(goodsId);
        System.out.println(1/0);    // “故意” 的异常
        deductAccountMoney(accountName, cost);  // 修改 账户表
        System.out.println("购买成功！");
    }

}

测试类：

package edu.youzg.tx.demo;

import edu.youzg.tx.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.sql.SQLException;

/**
 * @Author: Youzg
 * @CreateTime: 2021-03-21 18:33
 * @Description: 带你深究Java的本质！
 */
public class YouzgDemo {

    public static void main(String[] args) throws SQLException {
        ApplicationContext context = new AnnotationConfigApplicationContext("edu.youzg.tx");
        AccountService service = context.getBean("accountService", AccountService.class);
        service.sold(2, "youzg");
    }

}

运行结果：

故意的结果

account

inventory

首先，我们来看看 开启事务注解 —— @EnableTransactionManagement注解 的内容：

@EnableTransactionManagement注解：

@EnableTransactionManage注解
其实，读了这么久源码，我们也能知道：

Spring系列框架 中 @EnableXxx 注解 的核心，在于 该注解的@Import注解

那么，我们来看看导入的 TransactionManagementConfigurationSelector类，做了什么：

TransactionManagementConfigurationSelector 类：

TransactionManagementConfigurationSelector
我们能看到：

导入这个类，就相当于在 Spring容器 中，添加了 两个后置处理器：

AutoProxyRegistrar

ProxyTransactionManagementConfiguration

其实，Spring 事务 是依靠 Spring AOP 搭建起来的功能
但是，在上面的案例中，本人并没有明文标注 开启AOP，这是为什么呢？

我们来看下 AutoProxyRegistrar类 的源码：

AutoProxyRegistrar 类：

AutoProxyRegistrar

我们再来对比下 开启 Spring AOP 的注解，所导入的类：
AOP

我们可以看到：

AutoProxyRegistrar类 实现了 开启AOP注解所导入的类 的部分功能
(没完成的功能，只有 exposeProxy属性，
也就是说：如果我们 仅开启事务，不能使用 AOP 的当前线程Proxy)

既然在上文中，本人已经说明，Spring 事务 底层是通过 Spring AOP 实现的

那么，本人现在来讲解下，每一个标注了@Transactional注解 的 方法或类，是怎么被解析成 相应的advisor 的：

advisor转换：

在上文中，本人讲解了 @EnableTransactionManagement注解 的作用，就是导入 TransactionManagementConfigurationSelector后置处理器 和 ProxyTransactionManagementConfiguration类

但是，本人还未讲解 ProxyTransactionManagementConfiguration类

ProxyTransactionManagementConfiguration 类：

ProxyTransactionManagementConfiguration
我们可以看到：

ProxyTransactionManagementConfiguration类，本质上是一个 config类
并且，它的作用是：

向 Spring容器导入 BeanFactoryTransactionAttributeSourceAdvisor
并且给beanFactoryTransactionAttributeSourceAdvisor 设置了 transactionInterceptor 和 transactionAttributeSource

那么，现在本人来展示下 BeanFactoryTransactionAttributeSourceAdvisor类：