--- theme: awesome-green highlight: a11y-dark --- 这是我参与更文挑战的第14天，活动详情查看： [更文挑战](https://juejin.cn/post/6967194882926444557?utm_campaign=30day&utm_medium=Ccenter&utm_source=20210528) > **首先分享之前的所有文章 , 欢迎点赞收藏转发三连下次一定 >>>>** 😜😜😜
> **文章合集 :** 🎁 https://juejin.cn/post/6941642435189538824
> **Github :** 👉 https://github.com/black-ant ## 一 .前言之前分别介绍了 Seata 的启动和配置 , **这一篇来看一下 Client 端的启动过程** : [盘点 Seata : Seata Server 启动流程](https://juejin.cn/post/6974048246561767438) [盘点 Seata : Seata Server 配置流程](https://juejin.cn/post/6974418769087037476) [盘点 Seata : Client 端配置流程](https://juejin.cn/post/6976258849791541278) Seata 的事务发起其实可以分为2个阶段 , 第一阶段是 Client 发起 Request , 第二阶段是 Server 端对 Request 进行处理 , 以及创建 TX 对象等 , 这一篇先来看一下 Seata Client 端发起流程 , 下面来详细看一下 : ### 1.1 Seata AT 模式的主流程梳理 ![seata-solution.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f286da4836884942880c2f739dd22200~tplv-k3u1fbpfcp-watermark.image) Seata 中存在三个角色 : ```java // TC (Transaction Coordinator) - 事务协调者维护全局和分支事务的状态，驱动全局事务提交或回滚。 // TM (Transaction Manager) - 事务管理器定义全局事务的范围：开始全局事务、提交或回滚全局事务。 // RM (Resource Manager) - 资源管理器管理分支事务处理的资源，与TC交谈以注册分支事务和报告分支事务的状态，并驱动分支事务提交或回滚。 ``` ### 1.2 主要流程梳理不说废话 , 流程图就在这 , 能看懂 , 就可以不看下文了(**PS : 还不是很详细 , 后面再完整的补充**) : ![seata-template-导图分布式事务.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e7ad084c35f34d1d852199446f9eb0fe~tplv-k3u1fbpfcp-watermark.image) 以下流程主要参考[官方文档](https://seata.io/zh-cn/docs/dev/mode/at-mode.html) , 只做个总结 , 整个流程分为2个阶段 : **针对语句** : `update product set name = 'GTS' where name = 'TXC';` > 一阶段 1. 解析 SQL：得到 SQL 的类型（UPDATE），表（product），条件（where name = 'TXC'）等相关的信息。 2. **查询前镜像** : 根据解析得到的条件信息，生成查询语句，定位数据。 3. 执行业务 SQL：更新这条记录的 name 为 'GTS'。 4. **查询后镜像**：根据前镜像的结果，通过主键定位数据。 5. 插入回滚日志：把前后镜像数据以及业务 SQL 相关的信息组成一条回滚日志记录，插入到 UNDO_LOG 表中。 6. 提交前，向 TC 注册分支：申请 product 表中，主键值等于 1 的记录的全局锁。 7. **本地事务提交**：业务数据的更新和前面步骤中生成的 UNDO LOG 一并提交。 8. 将本地事务提交的结果上报给 TC。 > 二阶段 : 提交 1. 收到 TC 的分支提交请求，把请求放入一个异步任务的队列中，马上返回提交成功的结果给 TC。 2. 异步任务阶段的分支提交请求将异步和批量地删除相应 UNDO LOG 记录。 ### 1.3 GlobalLock 介绍声明事务只在单个本地RM中执行，但是事务需要确保要更新(或选择更新)的记录不在全局事务的中间阶段 ```java public @interface GlobalLock { /** * 自定义全局锁重试间隔(单位:ms) */ int lockRetryInternal() default 0; /** * 自定义的全局锁重试次数 */ int lockRetryTimes() default -1; } ``` ### 1.4 GlobalTransactional 介绍 ```java @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD,ElementType.TYPE}) @Inherited public @interface GlobalTransactional { /** * 全局事务超时mills(毫秒) */ int timeoutMills() default DefaultValues.DEFAULT_GLOBAL_TRANSACTION_TIMEOUT; /** * 全局事务实例的给定名称 */ String name() default ""; /** * 回滚到指定class */ Class[] rollbackFor() default {}; /** * 回滚的 Class 类名 */ String[] rollbackForClassName() default {}; /** * 不回滚的指定类 */ Class[] noRollbackFor() default {}; /** * 不回滚的指定类名 */ String[] noRollbackForClassName() default {}; /** * 全局事务的传播 */ Propagation propagation() default Propagation.REQUIRED; /** * 自定义全局锁重试间隔(单位:ms) */ int lockRetryInternal() default 0; /** * 自定义的全局锁重试时间 */ int lockRetryTimes() default -1; } ``` ## 二 . Client 事务的发起事务的发起是有 TM 开始 , 然后由 RM 完成事务分支 , 看一下主要的流程 : 整个流程这一次只说前面2步 : - **Interceptor 对操作进行拦截** - **TransactionalTemplate 处理事务整体流程** > 看一下类流程 : ```java // TM 流程一：注解处理阶段 , 此阶段方法上标注注解 , 将创建一个新的事务 GlobalTransactionalInterceptor # invoke : 拦截器拦截被代理的方法 GlobalTransactionalInterceptor # handleGlobalTransaction : 注解处理详情 TransactionalTemplate # execute : 事务处理主流程 TransactionalTemplate # beginTransaction : 开启事务主流程 DefaultGlobalTransaction # begin : 调用 API 流程 DefaultTransactionManager # begin : 调用 API 实际流程 // App A RM 流程一 : 此方法中创建 Proxy 的 Statement 类 PreparedStatementHandler # instantiateStatement PreparedStatementProxy # PreparedStatementProxy() : 构造器构建 StatementProxy // App A RM 流程二 : 代理执行方案 ExecuteTemplate # execute BaseTransactionalExecutor # execute(Object... args) AbstractDMLBaseExecutor # doExecute(Object... args) AbstractDMLBaseExecutor # executeAutoCommitTrue(Object[] args) AbstractDMLBaseExecutor # executeAutoCommitFalse(Object[] args) ConnectionProxy # doCommit() ConnectionProxy # processGlobalTransactionCommit() // App A RM 流程三 : 调用实际Connect执行 DruidPooledConnection # commit() : 因为使用的 Druid 连接池 , 此处为 DruidPooledConnection ?- 此处将会提交 commit ``` ### 2.1 注解的入口 ```java // 注解的扫描方式 : @GlobalTransactional(timeoutMills = 300000, name = "dubbo-gts-seata-example") // Step 1 : 核心扫描类 GlobalTransactionScanner // 先看一下该类的继承体系 C01- GlobalTransactionScanner E- AbstractAutoProxyCreator : Aop 代理 -> PS:C01_001 I- ConfigurationChangeListener : -> PS:C01_002 I- InitializingBean : 意味着会初始化运行 I- ApplicationContextAware : ApplicationContext 运行时被通知 I- DisposableBean : 销毁 Bean 时会处理 ``` > PS:C01_001 AbstractAutoProxyCreator 作用简单点说 , 就是为这个类做了代理 . 使用AOP代理包装每个合格bean的BeanPostProcessor实现，在调用bean本身之前将委托给指定的拦截器。 > GlobalTransactionScanner 详情详见 Client 配置 >>>> [Client端配置流程](https://juejin.cn/post/6976258849791541278) ### 2.2 注解的拦截通常方法上标注注解来实现某种功能 , 其最终原理都是代理 , 不论是Java 原生得 Proxy 类创建的 , 还是 Aop 实现的 , 其核心是一致的. > Step 1 : 代理的方式此处使用的代理是 CglibAopProxy > Step 2 : 调用的流程第一个调用的对象为 GlobalTransactionalInterceptor , 由其 invoke 方法完成了相关的代理操作 **PS : 我原本以为框架会优先扫描所有的标注了 @GlobalTransactional 的方法 , 并且通过相关的Manager 进行管理 , 但是单独看这一处的代码 , 采用的是代理后直接获取的方式** > GlobalTransactionalInterceptor # invoke 主流程 ```java // 先来纵观一下 invoke 方法主流程 C50- GlobalTransactionalInterceptor I- MethodInterceptor M50_01- invoke(final MethodInvocation methodInvocation) - 通过 MethodInvocation 解析目标 class - 通过 ClassUtils 解析目标 Method - 通过 findBridgedMethod 找到原始方法 -> PS:M50_01_01 - 获得原始方法的 GlobalTransactional 注解 - 获得原始方法的 GlobalLock 注解 - 如果GlobalTransactional 注解存在 , 则执行 globalTransactionalAnnotation - 如果 GlobalLock 存在且 GlobalTransactional 不存在 , 则执行 handleGlobalLock ?- 注意 , 这里优先执行了 globalTransactionalAnnotation ``` > GlobalTransactionalInterceptor 其他主要方法 ```java // PS : 此处随便来看一下其他的方法 M- initDefaultGlobalTransactionTimeout M- 支持配置 Configuration 变动加载 public void onChangeEvent(ConfigurationChangeEvent event) { if (ConfigurationKeys.DISABLE_GLOBAL_TRANSACTION.equals(event.getDataId())) { disable = Boolean.parseBoolean(event.getNewValue().trim()); } else if (ConfigurationKeys.CLIENT_DEGRADE_CHECK.equals(event.getDataId())) { degradeCheck = Boolean.parseBoolean(event.getNewValue()); if (!degradeCheck) { degradeNum = 0; } } } M- handleGlobalLock M- handleGlobalTransaction // 注意 , 该方法中就会调用 transactionalTemplate 完成主要逻辑 Object handleGlobalTransaction(final MethodInvocation methodInvocation, final GlobalTransactional globalTrxAnno) throws Throwable { boolean succeed = true; try { // 核心 , 调用 Template , 同时构建了一个 TransactionalExecutor 传入 // TransactionalExecutor 为 template 中具体执行的方法 , 即 executor 的对象 return transactionalTemplate.execute(new TransactionalExecutor() { @Override public Object execute() throws Throwable { // 此处是对应的方法代理 , 用于执行具体的对象 -> PRO22001 return methodInvocation.proceed(); } public String name() { String name = globalTrxAnno.name(); if (!StringUtils.isNullOrEmpty(name)) { return name; } return formatMethod(methodInvocation.getMethod()); } // 该方法用于tempalte 中调用事务信息 @Override public TransactionInfo getTransactionInfo() { // reset the value of timeout int timeout = globalTrxAnno.timeoutMills(); if (timeout <= 0 || timeout == DEFAULT_GLOBAL_TRANSACTION_TIMEOUT) { timeout = defaultGlobalTransactionTimeout; } // 构建了当前的事务信息 TransactionInfo transactionInfo = new TransactionInfo(); transactionInfo.setTimeOut(timeout); transactionInfo.setName(name()); transactionInfo.setPropagation(globalTrxAnno.propagation()); transactionInfo.setLockRetryInternal(globalTrxAnno.lockRetryInternal()); transactionInfo.setLockRetryTimes(globalTrxAnno.lockRetryTimes()); Set rollbackRules = new LinkedHashSet<>(); // 构建了回退的方法以及无需回退的方法 for (Class rbRule : globalTrxAnno.rollbackFor()) { rollbackRules.add(new RollbackRule(rbRule)); } for (String rbRule : globalTrxAnno.rollbackForClassName()) { rollbackRules.add(new RollbackRule(rbRule)); } for (Class rbRule : globalTrxAnno.noRollbackFor()) { rollbackRules.add(new NoRollbackRule(rbRule)); } for (String rbRule : globalTrxAnno.noRollbackForClassName()) { rollbackRules.add(new NoRollbackRule(rbRule)); } transactionInfo.setRollbackRules(rollbackRules); return transactionInfo; } }); } catch (TransactionalExecutor.ExecutionException e) { TransactionalExecutor.Code code = e.getCode(); // 通过 Failure 类型调用failureHandler不同的处理方法 switch (code) { case RollbackDone: throw e.getOriginalException(); case BeginFailure: succeed = false; failureHandler.onBeginFailure(e.getTransaction(), e.getCause()); throw e.getCause(); case CommitFailure: succeed = false; failureHandler.onCommitFailure(e.getTransaction(), e.getCause()); throw e.getCause(); case RollbackFailure: failureHandler.onRollbackFailure(e.getTransaction(), e.getOriginalException()); throw e.getOriginalException(); case RollbackRetrying: failureHandler.onRollbackRetrying(e.getTransaction(), e.getOriginalException()); throw e.getOriginalException(); default: throw new ShouldNeverHappenException(String.format("Unknown TransactionalExecutor.Code: %s", code)); } } finally { if (degradeCheck) { EVENT_BUS.post(new DegradeCheckEvent(succeed)); } } } ``` > **[PRO22001]** : methodInvocation 详情 ![seata_invoke.jpg](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/84155b7704f6482d85fd1ad798ecc614~tplv-k3u1fbpfcp-watermark.image) > **[PRO22002]** : TransactionInfo 详情 **总结 :** 从此处可以看到 , 在GlobalTransactionalInterceptor 拦截器中 , 首先调用了 template 方法 , **同时把 executor 需要执行的具体方法传入 , 而 method 通过 invoke 代理调用** **另外 , 处理异常是在拦截器中执行 ,而不是 Template 的模板类型** ## 三 . Client 事务的逻辑处理 Client 的事务处理为 TransactionalTemplate 模板方法来完成 , 来看一下 **TransactionalTemplate** 的功能 ![seata_template_001.jpg](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ea46bad8531a4a6292790abf8095a19e~tplv-k3u1fbpfcp-watermark.image) **上一步当拦截器拦截完成后 , 就会来到 template 处理环节** , 该环节最核心的类为 : TransactionalTemplate , 这一步是模板方法设计模式 , 这一步中会调用 TransactionalExecutor 执行最终的逻辑 ```java C51- TransactionalTemplate M51_01- execute // 注释已经很清楚了, 就喜欢这种源码 , 清清楚楚 , 直译一下就知道流程了 public Object execute(TransactionalExecutor business) throws Throwable { // 1. 获取 transactionInfo TransactionInfo txInfo = business.getTransactionInfo(); if (txInfo == null) { throw new ShouldNeverHappenException("transactionInfo does not exist"); } // 1.1 获取当前 transaction, 如果不为空，tx role 为 'GlobalTransactionRole.Participant'. GlobalTransaction tx = GlobalTransactionContext.getCurrent(); // 1.2 事务传播处理 -> PS:M51_01_01 Propagation propagation = txInfo.getPropagation(); SuspendedResourcesHolder suspendedResourcesHolder = null; try { switch (propagation) { case NOT_SUPPORTED: // 如果事务存在，则暂停它. if (existingTransaction(tx)) { suspendedResourcesHolder = tx.suspend(); } // 在没有事务的情况下执行并返回. return business.execute(); case REQUIRES_NEW: // 如果事务存在，暂停它，然后开始新的事务. if (existingTransaction(tx)) { suspendedResourcesHolder = tx.suspend(); tx = GlobalTransactionContext.createNew(); } // 继续并使用新事务执行 break; case SUPPORTS: // 如果事务不存在，则不执行事务. if (notExistingTransaction(tx)) { return business.execute(); } // 继续并使用新事务执行 break; case REQUIRED: // 如果当前事务存在，则使用当前事务执行，否则继续并使用新事务执行 break; case NEVER: // 如果事务存在，抛出异常. if (existingTransaction(tx)) { throw new TransactionException( String.format("Existing transaction found for transaction marked with propagation 'never', xid = %s" , tx.getXid())); } else { // 在没有事务的情况下执行并返回. return business.execute(); } case MANDATORY: // 如果事务不存在，抛出异常. if (notExistingTransaction(tx)) { throw new TransactionException("No existing transaction found for transaction marked with propagation 'mandatory'"); } // 继续并执行当前事务. break; default: throw new TransactionException("Not Supported Propagation:" + propagation); } // 1.3 如果当前 GlobalTransaction 为 null , 使用 role 'GlobalTransactionRole.Launcher' 创建一个新的 Transaction. if (tx == null) { tx = GlobalTransactionContext.createNew(); } // 设置当前tx配置为holder GlobalLockConfig previousConfig = replaceGlobalLockConfig(txInfo); try { // 2. 如果当前 tx(GlobalTransaction) role 为 'GlobalTransactionRole.Launcher', 发送beginTransaction的请求到TC, // 否则不做任何事. 不过 , hooks 始终会被触发. beginTransaction(txInfo, tx); Object rs; try { // 执行业务 rs = business.execute(); } catch (Throwable ex) { // 3. 回滚所需的业务异常. completeTransactionAfterThrowing(txInfo, tx, ex); throw ex; } // 4. 一切正常后 , 提交事务. commitTransaction(tx); return rs; } finally { //5. 清空事件 resumeGlobalLockConfig(previousConfig); triggerAfterCompletion(); cleanUp(); } } finally { // 如果事务挂起，则恢复它. if (suspendedResourcesHolder != null) { tx.resume(suspendedResourcesHolder); } } } // PS:M51_01_01 Propagation 是什么对象 , 有什么作用 ? ``` **可以看到 , 这个中已经把整个事务处理的主流程完成了** 接上一小结 , 当执行 `business.execute()` 后出现异常 , 会在 execute 中处理 , 而 Template 中 , 主要是对事务的管理和回退等操作 , **这也是使用模板方法设计模式的核心 , 只涉及统一的逻辑** ## 总结这一篇我们看到了 Seata 逻辑的发起流程 ,可以看到 ,通过以下几个步骤发起了事务的处理 : - beginTransaction(txInfo, tx) - business.execute() - completeTransactionAfterThrowing(txInfo, tx, ex) - commitTransaction(tx) **后面一篇我们来看一下后面这几个步骤做了什么>>> 👉** ## 附录 . 补充点读隔离和写隔离可以参考官方文档 👉 [Seata 隔离策略](https://seata.io/zh-cn/docs/dev/mode/at-mode.html) ### 4.1 读隔离详情 Seata（AT 模式）的默认全局隔离级别是读未提交（Read Uncommitted） , 其通过 **SELECT FOR UPDATE** 实现 > 流程详情 - SELECT FOR UPDATE 语句的执行会申请全局锁 - 如果 **全局锁** 被其他事务持有，则释放本地锁（回滚 SELECT FOR UPDATE 语句的本地执行）并重试 (意味着会一直等待正在的全局提交完成) 这个过程中，查询是被 **block** 住的，直到 **全局锁** 拿到，即读取的相关数据是 **已提交** 的，才返回 **PS : 这里产生了疑问 , 如果插入比较多的情况 , 会导致全局锁一直被占用或者频繁占用 , 所以这里还是要做读写分离** ### 4.2 写隔离详情写隔离是保证事务统一的关键 , 其中涉及到全局锁和本地锁的特性 , 为了保证准确 , 使用如下模式 : **1,2 分别代表2个事务 :** > 一阶段提交流程 1. 开启本地事务 , 拿到**本地锁** ,再拿到 **全局锁** , 提交本地事务 , 释放**本地锁** **(PS :此时始终持有全局锁)** 2. **其他事务提交** , 开启本地事务 , 拿到**本地锁** ,等待全局锁 **(PS :此时上一个事务持有全局锁)** ------------ > 二阶段成功提交流程 1. 全局处理完成 , 释放**全局锁** 2. **其他事务** 拿到**全局锁** , 按照原流程处理 > 二阶段回退流程 (如果出现异常导致 1 事务回退) 1 . 发生异常 , 尝试回退 , 等待**本地锁** **(PS : 因为本地锁被其他事务持有)**
2 . 始终无法拿到**全局锁** , 本地事务回退 , 释放**本地锁**
1 . 拿到 **本地锁** ,完成回退