Seata尝试及源码解读
官网
https://seata.io/zh-cn/docs/overview/what-is-seata.html
seata建表语句
https://gitee.com/dhb414/seata/blob/master/script/server/db/mysql.sql
undo_log https://gitee.com/dhb414/seata/blob/master/script/client/at/db/mysql.sql
配置:
#阿里分布式事务配置
seata:
service:
vgroup-mapping:
#这里的组名my_test_tx_group就是上面已经配置过的
# seata-server 对应的就是register.conf里的application选项的内容
my_test_tx_group1: seata-server
grouplist:
#这里对应的就是上面的seata-server,后面的蚕食seata服务的IP地址和端口号
seata-server: l27.0.0.1:9091
enable-degrade: false
disable-global-transaction: false
Demo模型
排坑
mysql-connector-java不能用5.1.47,这个版本有bug,以前不会触发,使用seata后会触发
undo_log滞留的问题
AT模式自测用例
异步调用的4种情况:
1、主事务调用分支事务之前;2、主事务和分支事务均未结束;3、分支事务结束而主事务没结束;4、主事务结束而分支事务没结束;
异步调用出问题的两种情况:
1、主事务成功,分支事务失败;
2、主事务失败,分支事务成功;
一TM一RM,Feign方式(同步)
同步调用的3个阶段:
1、主事务调用分支事务之前;
2、分支事务结束并返回之前;
3、分支事务提交后,且主事务提交前
同步调用出问题的情况:
1、主事务成功,分支事务失败
2、主事务失败,分支事务成功
正常执行
观察每个阶段的undo_log和TC的记录
阶段一:只有TC全局事务注册
阶段二:只有TC的全局事务表有记录
阶段二(主事务没有使用@Transactional(rollbackFor = Exception.class)):主事务提交,主事务undo存在;分支事务啥都没有;TC全局事务有,锁了主事务,分支事务表注册了主事务
阶段二附加:接阶段二,分支一直断点,主事务会超时而失败,此时TC的全局事务也没有了。等到分支断点放开,分支提交也会因为没有全局事务而失败
阶段二附加(主事务没有使用@Transactional(rollbackFor = Exception.class)):主事务超时失败了,并且发生回滚,全局事务也会回滚,但此时分支事务处于断点,放开断点后分支事务提交时,发现没有全局事务,分支事务也会回滚
阶段三:主事务已提交有undolog;分支事务已提交有undolog;TC全局事务一个,全局锁两个,分支事务注册两个
观察最终结果是否正确
全部符合预期
主事务成功,分支事务失败(主事务捕获掉异常)
观察每个阶段的undo_log和TC的记录
观察最终效果是否正确
seata认为,主事务捕获异常代表不关心分支事务,所以主事务正常提交
分支事务由于发生异常,没有正常提交
主事务失败,分支事务成功
观察每个阶段的undo_log和TC的记录
处于阶段三时:跟正常执行的阶段三相同
观察最终效果是否正确
所有分支均回滚
源码解读
Seata 中有三大模块,分别是 TM、RM 和 TC。其中 TM 和 RM 是作为 Seata 的客户端与业务系统集成在一起,TC 作为 Seata 的服务端独立部署。
角色划分:
TM: 事务管理,开启、提交、回滚分布式事务
RM: 资源管理,注册、汇报、执资源,负责接收TC发过来的提交、回滚消息,并作出提交,回滚操作
TC: 事务管理器服务功能,存储事务日志、补偿异常事务等、集中管理事务全局锁(全局行锁)
事务执行整体流程:
• TM 开启分布式事务(TM 向 TC 注册全局事务记录);
• 按业务场景,编排数据库、服务等事务内资源(RM 向 TC 汇报资源准备状态 );
• TM 结束分布式事务,事务一阶段结束(TM 通知 TC 提交/回滚分布式事务);
• TC 汇总事务信息,决定分布式事务是提交还是回滚;
• TC 通知所有 RM 提交/回滚 资源,事务二阶段结束;
1、springboot-starter 启动
SeataAutoConfiguration
1 @Bean 2 @DependsOn({"springUtils"}) 3 @ConditionalOnMissingBean(GlobalTransactionScanner.class) //在容器加载它作用的bean时,检查容器中是否存在目标类型的bean,如果存在这跳过原始bean的BeanDefinition加载动作。 4 public GlobalTransactionScanner globalTransactionScanner() { 5 if (LOGGER.isInfoEnabled()) { 6 LOGGER.info("Automatically configure Seata"); 7 } 8 return new GlobalTransactionScanner(seataProperties.getApplicationId(), seataProperties.getTxServiceGroup()); 9 }
2、初始化
1、、通过Spring的InitializingBean初始化
1 public class GlobalTransactionScanner extends AbstractAutoProxyCreator 2 implements InitializingBean, ApplicationContextAware, 3 DisposableBean{ 4 5 //InitializingBean实现方法,spring自动调用 6 @Override 7 public void afterPropertiesSet() { 8 if (disableGlobalTransaction) { 9 return; 10 } 11 //初始化 12 initClient(); 13 } 14 15 private void initClient() { 16 //init TM register TM success 17 TMClient.init(applicationId, txServiceGroup); 18 //init RM register RM success 19 RMClient.init(applicationId, txServiceGroup); 20 //注册钩子事件,封装销毁操作 21 registerSpringShutdownHook(); 22 } 23 }
2.1 Rm netty Channel 启动
1)启动ScheduledExecutorService定时执行器,每5秒尝试进行一次重连TC
2)重连时,先从file.conf中根据分组名称(service_group)找到集群名称(cluster_name)
3)再根据集群名称找到fescar-server集群ip端口列表
4)从ip列表中选择一个用netty进行连接
public abstract class AbstractRpcRemotingClient extends AbstractRpcRemoting implements RegisterMsgListener, ClientMessageSender { @Override public void init() { clientBootstrap.start(); //启动ScheduledExecutorService定时执行器,每5秒尝试进行一次重连TC timerExecutor.scheduleAtFixedRate(new Runnable() { @Override public void run() { clientChannelManager.reconnect(getTransactionServiceGroup()); } }, SCHEDULE_INTERVAL_MILLS, SCHEDULE_INTERVAL_MILLS, TimeUnit.SECONDS); if (NettyClientConfig.isEnableClientBatchSendRequest()) { //用于多数据合并,减少通信次数 mergeSendExecutorService = new ThreadPoolExecutor(MAX_MERGE_SEND_THREAD, MAX_MERGE_SEND_THREAD, KEEP_ALIVE_TIME, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(), new NamedThreadFactory(getThreadPrefix(), MAX_MERGE_SEND_THREAD)); mergeSendExecutorService.submit(new MergedSendRunnable()); } super.init(); } }
2.2 Tm netty Channel 启动
1 public class RMClient { 2 3 public static void init(String applicationId, String transactionServiceGroup) { 4 RmRpcClient rmRpcClient = RmRpcClient.getInstance(applicationId, transactionServiceGroup); 5 //资源管理器ResourceManager 6 rmRpcClient.setResourceManager(DefaultResourceManager.get()); 7 //消息回调监听器,rmHandler用于接收TC在二阶段发出的提交或者回滚请求 8 rmRpcClient.setClientMessageListener(new RmMessageListener(DefaultRMHandler.get())); 9 rmRpcClient.init(); 10 } 11 }
注:此处用到了Java Spi拓展机制,可插拔
1 public class DefaultResourceManager implements ResourceManager { 2 protected void initResourceManagers() { 3 //init all resource managers 4 List<ResourceManager> allResourceManagers = EnhancedServiceLoader.loadAll(ResourceManager.class); 5 if (CollectionUtils.isNotEmpty(allResourceManagers)) { 6 for (ResourceManager rm : allResourceManagers) { 7 resourceManagers.put(rm.getBranchType(), rm); 8 } 9 } 10 } 11 }
2.3
根据注解开启 aop切面
根据@GlobalTransactional注释的方法,通过GlobalTransactionalInterceptor过滤器加入cglib切面,并new TransactionalTemplate开启事务
1 //BeanPostProcessor后置处理器 2 @Override 3 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 4 if (bean instanceof DataSource && !(bean instanceof DataSourceProxy) && ConfigurationFactory.getInstance().getBoolean(DATASOURCE_AUTOPROXY, false)) { 5 DataSourceProxy dataSourceProxy = DataSourceProxyHolder.get().putDataSource((DataSource) bean); 6 Class<?>[] interfaces = SpringProxyUtils.getAllInterfaces(bean); 7 return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), interfaces, new InvocationHandler() { 8 @Override 9 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 10 Method m = BeanUtils.findDeclaredMethod(DataSourceProxy.class, method.getName(), method.getParameterTypes()); 11 if (null != m) { 12 return m.invoke(dataSourceProxy, args); 13 } else { 14 boolean oldAccessible = method.isAccessible(); 15 try { 16 method.setAccessible(true); 17 return method.invoke(bean, args); 18 } finally { 19 //recover the original accessible for security reason 20 method.setAccessible(oldAccessible); 21 } 22 } 23 } 24 }); 25 } 26 return super.postProcessAfterInitialization(bean, beanName); 27 }
3、事务一阶段
3.1拦截器
1 public class GlobalTransactionalInterceptor implements ConfigurationChangeListener,MethodInterceptor { 2 3 @Override 4 public Object invoke(final MethodInvocation methodInvocation) throws Throwable { 5 Class<?> targetClass = methodInvocation.getThis() != null ? AopUtils.getTargetClass(methodInvocation.getThis()) 6 : null; 7 Method specificMethod = ClassUtils.getMostSpecificMethod(methodInvocation.getMethod(), targetClass); 8 final Method method = BridgeMethodResolver.findBridgedMethod(specificMethod); 9 10 final GlobalTransactional globalTransactionalAnnotation = getAnnotation(method, GlobalTransactional.class); 11 final GlobalLock globalLockAnnotation = getAnnotation(method, GlobalLock.class); 12 if (!disable && globalTransactionalAnnotation != null) { 13 //全局事务开始 14 return handleGlobalTransaction(methodInvocation, globalTransactionalAnnotation); 15 } else if (!disable && globalLockAnnotation != null) { 16 //全局锁 17 return handleGlobalLock(methodInvocation); 18 } else { 19 return methodInvocation.proceed(); 20 } 21 }
3.2开始事务
TransactionalTemplate
1 public Object execute(TransactionalExecutor business) throws Throwable { 2 3 // 1. 根据xid判断是否新建事务 4 GlobalTransaction tx = GlobalTransactionContext.getCurrentOrCreate(); 5 6 // 1.1 get transactionInfo 7 TransactionInfo txInfo = business.getTransactionInfo(); 8 if (txInfo == null) { 9 throw new ShouldNeverHappenException("transactionInfo does not exist"); 10 } 11 try { 12 13 // 2. begin transaction 14 try { 15 //暂时无用 16 triggerBeforeBegin(); 17 //开启事务 18 tx.begin(txInfo.getTimeOut(), txInfo.getName()); 19 //暂时无用 20 triggerAfterBegin(); 21 } catch (TransactionException txe) { 22 throw new TransactionalExecutor.ExecutionException(tx, txe, 23 TransactionalExecutor.Code.BeginFailure); 24 25 } 26 27 Object rs = null; 28 try { 29 30 // Do Your Business 31 rs = business.execute(); 32 33 } catch (Throwable ex) { 34 35 // 3.the needed business exception to rollback. 36 completeTransactionAfterThrowing(txInfo,tx,ex); 37 throw ex; 38 } 39 40 // 4. everything is fine, commit. 41 commitTransaction(tx); 42 43 return rs; 44 } finally { 45 //5. clear 46 triggerAfterCompletion(); 47 cleanUp(); 48 } 49 }
真正执行事务开始的地方
1 public class DefaultGlobalTransaction implements GlobalTransaction { 2 3 @Override 4 public void begin(int timeout, String name) throws TransactionException { 5 //此处的角色判断有关键的作用 6 //表明当前是全局事务的发起者(Launcher)还是参与者(Participant) 7 //如果在分布式事务的下游系统方法中也加上GlobalTransactional注解 8 //那么它的角色就是Participant,即会忽略后面的begin就退出了 9 //而判断是发起者(Launcher)还是参与者(Participant)是根据当前上下文是否已存在XID来判断 10 //没有XID的就是Launcher,已经存在XID的就是Participant 11 if (role != GlobalTransactionRole.Launcher) { 12 check(); 13 if (LOGGER.isDebugEnabled()) { 14 LOGGER.debug("Ignore Begin(): just involved in global transaction [" + xid + "]"); 15 } 16 return; 17 } 18 if (xid != null) { 19 throw new IllegalStateException(); 20 } 21 if (RootContext.getXID() != null) { 22 throw new IllegalStateException(); 23 } 24 //具体开启事务的方法,获取TC返回的XID,具体由DefaultTransactionManager操作 25 xid = transactionManager.begin(null, null, name, timeout); 26 status = GlobalStatus.Begin; 27 RootContext.bind(xid); 28 if (LOGGER.isDebugEnabled()) { 29 LOGGER.debug("Begin a NEW global transaction [" + xid + "]"); 30 } 31 } 32 }
3.3 数据源代理
1 public class StatementProxy<T extends Statement> extends AbstractStatementProxy<T> { 2 3 @Override 4 public boolean execute(String sql) throws SQLException { 5 this.targetSQL = sql; 6 return ExecuteTemplate.execute(this, new StatementCallback<Boolean, T>() { 7 @Override 8 public Boolean execute(T statement, Object... args) throws SQLException { 9 return statement.execute((String) args[0]); 10 } 11 }, sql); 12 } 13 } 14 15 public class ExecuteTemplate{ 16 17 public static <T, S extends Statement> T execute(SQLRecognizer sqlRecognizer, 18 StatementProxy<S> statementProxy, 19 StatementCallback<T, S> statementCallback, 20 Object... args) throws SQLException { 21 if (!RootContext.inGlobalTransaction() && !RootContext.requireGlobalLock()) { 22 // 未开启全局事务时,正常执行 23 return statementCallback.execute(statementProxy.getTargetStatement(), args); 24 } 25 //解析SQL 26 if (sqlRecognizer == null) { 27 sqlRecognizer = SQLVisitorFactory.get( 28 statementProxy.getTargetSQL(), 29 statementProxy.getConnectionProxy().getDbType()); 30 } 31 Executor<T> executor = null; 32 if (sqlRecognizer == null) { 33 executor = new PlainExecutor<T, S>(statementProxy, statementCallback); 34 } else { 35 //对不同的SQL类型特殊处理 36 switch (sqlRecognizer.getSQLType()) { 37 case INSERT: 38 executor = new InsertExecutor<T, S>(statementProxy, statementCallback, sqlRecognizer); 39 break; 40 case UPDATE: 41 executor = new UpdateExecutor<T, S>(statementProxy, statementCallback, sqlRecognizer); 42 break; 43 case DELETE: 44 executor = new DeleteExecutor<T, S>(statementProxy, statementCallback, sqlRecognizer); 45 break; 46 case SELECT_FOR_UPDATE: 47 executor = new SelectForUpdateExecutor<T, S>(statementProxy, statementCallback, sqlRecognizer); 48 break; 49 default: 50 executor = new PlainExecutor<T, S>(statementProxy, statementCallback); 51 break; 52 } 53 } 54 T rs = null; 55 try { 56 //真正执行业务逻辑 57 rs = executor.execute(args); 58 } catch (Throwable ex) { 59 if (!(ex instanceof SQLException)) { 60 // Turn other exception into SQLException 61 ex = new SQLException(ex); 62 } 63 throw (SQLException)ex; 64 } 65 return rs; 66 } 67 } 68 69 70 public abstract class AbstractDMLBaseExecutor<T, S extends Statement> extends BaseTransactionalExecutor<T, S> { 71 72 //接下来执行到这里 73 @Override 74 public T doExecute(Object... args) throws Throwable { 75 AbstractConnectionProxy connectionProxy = statementProxy.getConnectionProxy(); 76 if (connectionProxy.getAutoCommit()) { 77 return executeAutoCommitTrue(args); 78 } else { 79 return executeAutoCommitFalse(args); 80 } 81 } 82 83 protected T executeAutoCommitFalse(Object[] args) throws Exception { 84 //业务SQL执行前快照 85 TableRecords beforeImage = beforeImage(); 86 //真正执行业务SQL 87 T result = statementCallback.execute(statementProxy.getTargetStatement(), args); 88 //业务SQL执行后快照 89 TableRecords afterImage = afterImage(beforeImage); 90 //准备快照 91 prepareUndoLog(beforeImage, afterImage); 92 return result; 93 } 94 95 96 protected void prepareUndoLog(TableRecords beforeImage, TableRecords afterImage) throws SQLException { 97 if (beforeImage.getRows().size() == 0 && afterImage.getRows().size() == 0) { 98 return; 99 } 100 ConnectionProxy connectionProxy = statementProxy.getConnectionProxy(); 101 TableRecords lockKeyRecords = sqlRecognizer.getSQLType() == SQLType.DELETE ? beforeImage : afterImage; 102 String lockKeys = buildLockKey(lockKeyRecords); 103 connectionProxy.appendLockKey(lockKeys); 104 SQLUndoLog sqlUndoLog = buildUndoItem(beforeImage, afterImage); 105 connectionProxy.appendUndoLog(sqlUndoLog); 106 } 107 }
3.4 分支事务注册与事务提交
1 public class ConnectionProxy extends AbstractConnectionProxy { 2 3 private void doCommit() throws SQLException { 4 //全局事务提交 5 if (context.inGlobalTransaction()) { 6 processGlobalTransactionCommit(); 7 //全局锁提交 8 } else if (context.isGlobalLockRequire()) { 9 processLocalCommitWithGlobalLocks(); 10 //正常提交 11 } else { 12 targetConnection.commit(); 13 } 14 } 15 16 //全局事务提交 17 private void processGlobalTransactionCommit() throws SQLException { 18 try { 19 //注册branchId,并保存到上下文 20 register(); 21 } catch (TransactionException e) { 22 recognizeLockKeyConflictException(e, context.buildLockKeys()); 23 } 24 try { 25 if (context.hasUndoLog()) { 26 //如果包含undolog,则将之前绑定到上下文中的undolog进行入库 27 UndoLogManagerFactory.getUndoLogManager(this.getDbType()).flushUndoLogs(this); 28 } 29 //本地事务提交 30 targetConnection.commit(); 31 } catch (Throwable ex) { 32 LOGGER.error("process connectionProxy commit error: {}", ex.getMessage(), ex); 33 //通过RMClient汇报TC结果 34 report(false); 35 throw new SQLException(ex); 36 } 37 if (IS_REPORT_SUCCESS_ENABLE) { 38 //通过RmRpcClient汇报TC结果 39 report(true); 40 } 41 context.reset(); 42 } 43 //注册branchId,并保存到上下文 44 private void register() throws TransactionException { 45 Long branchId = DefaultResourceManager.get().branchRegister(BranchType.AT, getDataSourceProxy().getResourceId(), 46 null, context.getXid(), null, context.buildLockKeys()); 47 context.setBranchId(branchId); 48 } 49 }
至此一阶段事务完成
4、事务二阶段
在RMClient初始化时,启动了RMHandlerAT接收TC在二阶段发出的提交或者回滚请求
1 public abstract class AbstractRMHandler extends AbstractExceptionHandler 2 implements RMInboundHandler, TransactionMessageHandler { 3 4 private static final Logger LOGGER = LoggerFactory.getLogger(AbstractRMHandler.class); 5 6 @Override 7 public BranchCommitResponse handle(BranchCommitRequest request) { 8 BranchCommitResponse response = new BranchCommitResponse(); 9 exceptionHandleTemplate(new AbstractCallback<BranchCommitRequest, BranchCommitResponse>() { 10 @Override 11 public void execute(BranchCommitRequest request, BranchCommitResponse response) 12 throws TransactionException { 13 doBranchCommit(request, response); 14 } 15 }, request, response); 16 return response; 17 } 18 19 @Override 20 public BranchRollbackResponse handle(BranchRollbackRequest request) { 21 BranchRollbackResponse response = new BranchRollbackResponse(); 22 exceptionHandleTemplate(new AbstractCallback<BranchRollbackRequest, BranchRollbackResponse>() { 23 @Override 24 public void execute(BranchRollbackRequest request, BranchRollbackResponse response) 25 throws TransactionException { 26 doBranchRollback(request, response); 27 } 28 }, request, response); 29 return response; 30 } 31 }
全局提交
交时,RM只需删除Undo_log表
1 //AT模式下,最终是由AsyncWorker执行提交 2 public class AsyncWorker implements ResourceManagerInbound { 3 @Override 4 public BranchStatus branchCommit(BranchType branchType, String xid, long branchId, String resourceId, 5 String applicationData) throws TransactionException { 6 //加入BlockingQueue 7 if (!ASYNC_COMMIT_BUFFER.offer(new Phase2Context(branchType, xid, branchId, resourceId, applicationData))) { 8 LOGGER.warn("Async commit buffer is FULL. Rejected branch [" + branchId + "/" + xid 9 + "] will be handled by housekeeping later."); 10 } 11 return BranchStatus.PhaseTwo_Committed; 12 } 13 14 public synchronized void init() { 15 LOGGER.info("Async Commit Buffer Limit: " + ASYNC_COMMIT_BUFFER_LIMIT); 16 timerExecutor = new ScheduledThreadPoolExecutor(1, new NamedThreadFactory("AsyncWorker", 1, true)); 17 //每秒执行 18 timerExecutor.scheduleAtFixedRate(new Runnable() { 19 @Override 20 public void run() { 21 try { 22 //提交 23 doBranchCommits(); 24 } catch (Throwable e) { 25 LOGGER.info("Failed at async committing ... " + e.getMessage()); 26 27 } 28 } 29 }, 10, 1000 * 1, TimeUnit.MILLISECONDS); 30 } 31 32 private void doBranchCommits() { 33 if (ASYNC_COMMIT_BUFFER.size() == 0) { 34 return; 35 } 36 Map<String, List<Phase2Context>> mappedContexts = new HashMap<>(DEFAULT_RESOURCE_SIZE); 37 while (!ASYNC_COMMIT_BUFFER.isEmpty()) { 38 Phase2Context commitContext = ASYNC_COMMIT_BUFFER.poll(); 39 List<Phase2Context> contextsGroupedByResourceId = mappedContexts.get(commitContext.resourceId); 40 //根据resourceId分组 41 if (contextsGroupedByResourceId == null) { 42 contextsGroupedByResourceId = new ArrayList<>(); 43 mappedContexts.put(commitContext.resourceId, contextsGroupedByResourceId); 44 } 45 contextsGroupedByResourceId.add(commitContext); 46 } 47 for (Map.Entry<String, List<Phase2Context>> entry : mappedContexts.entrySet()) { 48 Connection conn = null; 49 DataSourceProxy dataSourceProxy; 50 try { 51 try { 52 DataSourceManager resourceManager = (DataSourceManager)DefaultResourceManager.get() 53 .getResourceManager(BranchType.AT); 54 //根据resourceId查找对应dataSourceProxy 55 dataSourceProxy = resourceManager.get(entry.getKey()); 56 if (dataSourceProxy == null) { 57 throw new ShouldNeverHappenException("Failed to find resource on " + entry.getKey()); 58 } 59 conn = dataSourceProxy.getPlainConnection(); 60 } catch (SQLException sqle) { 61 LOGGER.warn("Failed to get connection for async committing on " + entry.getKey(), sqle); 62 continue; 63 } 64 List<Phase2Context> contextsGroupedByResourceId = entry.getValue(); 65 Set<String> xids = new LinkedHashSet<>(UNDOLOG_DELETE_LIMIT_SIZE); 66 Set<Long> branchIds = new LinkedHashSet<>(UNDOLOG_DELETE_LIMIT_SIZE); 67 for (Phase2Context commitContext : contextsGroupedByResourceId) { 68 xids.add(commitContext.xid); 69 branchIds.add(commitContext.branchId); 70 int maxSize = xids.size() > branchIds.size() ? xids.size() : branchIds.size(); 71 //1000个一起执行 72 if (maxSize == UNDOLOG_DELETE_LIMIT_SIZE) { 73 try { 74 //删除undo_log 75 UndoLogManagerFactory.getUndoLogManager(dataSourceProxy.getDbType()).batchDeleteUndoLog( 76 xids, branchIds, conn); 77 } catch (Exception ex) { 78 LOGGER.warn("Failed to batch delete undo log [" + branchIds + "/" + xids + "]", ex); 79 } 80 xids.clear(); 81 branchIds.clear(); 82 } 83 } 84 if (CollectionUtils.isEmpty(xids) || CollectionUtils.isEmpty(branchIds)) { 85 return; 86 } 87 //剩余未满1000的,在执行一次 88 try { 89 //删除undo_log 90 UndoLogManagerFactory.getUndoLogManager(dataSourceProxy.getDbType()).batchDeleteUndoLog(xids, 91 branchIds, conn); 92 } catch (Exception ex) { 93 LOGGER.warn("Failed to batch delete undo log [" + branchIds + "/" + xids + "]", ex); 94 } 95 } finally { 96 if (conn != null) { 97 try { 98 conn.close(); 99 } catch (SQLException closeEx) { 100 LOGGER.warn("Failed to close JDBC resource while deleting undo_log ", closeEx); 101 } 102 } 103 } 104 } 105 } 106 }
4.2 全局回滚
全局回滚时,根据undo_log回滚
public abstract class AbstractUndoLogManager implements UndoLogManager { protected static final String SELECT_UNDO_LOG_SQL = "SELECT * FROM " + UNDO_LOG_TABLE_NAME + " WHERE " + ClientTableColumnsName.UNDO_LOG_BRANCH_XID + " = ? AND " + ClientTableColumnsName.UNDO_LOG_XID + " = ? FOR UPDATE"; @Override public void undo(DataSourceProxy dataSourceProxy, String xid, long branchId) throws TransactionException { Connection conn = null; ResultSet rs = null; PreparedStatement selectPST = null; boolean originalAutoCommit = true; for (; ; ) { try { conn = dataSourceProxy.getPlainConnection(); // The entire undo process should run in a local transaction. if (originalAutoCommit = conn.getAutoCommit()) { conn.setAutoCommit(false); } //根据Xid查询出数据 selectPST = conn.prepareStatement(SELECT_UNDO_LOG_SQL); selectPST.setLong(1, branchId); selectPST.setString(2, xid); rs = selectPST.executeQuery(); boolean exists = false; while (rs.next()) { exists = true; //防重复提交 int state = rs.getInt(ClientTableColumnsName.UNDO_LOG_LOG_STATUS); if (!canUndo(state)) { if (LOGGER.isInfoEnabled()) { LOGGER.info("xid {} branch {}, ignore {} undo_log", xid, branchId, state); } return; } String contextString = rs.getString(ClientTableColumnsName.UNDO_LOG_CONTEXT); Map<String, String> context = parseContext(contextString); Blob b = rs.getBlob(ClientTableColumnsName.UNDO_LOG_ROLLBACK_INFO); byte[] rollbackInfo = BlobUtils.blob2Bytes(b); String serializer = context == null ? null : context.get(UndoLogConstants.SERIALIZER_KEY); UndoLogParser parser = serializer == null ? UndoLogParserFactory.getInstance() : UndoLogParserFactory.getInstance(serializer); BranchUndoLog branchUndoLog = parser.decode(rollbackInfo); try { // put serializer name to local setCurrentSerializer(parser.getName()); List<SQLUndoLog> sqlUndoLogs = branchUndoLog.getSqlUndoLogs(); if (sqlUndoLogs.size() > 1) { Collections.reverse(sqlUndoLogs); } //反解析出回滚SQL并执行 for (SQLUndoLog sqlUndoLog : sqlUndoLogs) { TableMeta tableMeta = TableMetaCacheFactory.getTableMetaCache(dataSourceProxy).getTableMeta( conn, sqlUndoLog.getTableName(),dataSourceProxy.getResourceId()); sqlUndoLog.setTableMeta(tableMeta); AbstractUndoExecutor undoExecutor = UndoExecutorFactory.getUndoExecutor( dataSourceProxy.getDbType(), sqlUndoLog); undoExecutor.executeOn(conn); } } finally { // remove serializer name removeCurrentSerializer(); } } .... }
知识点:
BeanPostProcessor的作用 https://www.jianshu.com/p/6a48675ef7a3
Bean初始化执行顺序 https://www.cnblogs.com/twelve-eleven/p/8080038.html
JAVA虚拟机关闭钩子 https://www.jianshu.com/p/7de5ee9418f8
JAVA中的SPI机制 https://www.jianshu.com/p/46b42f7f593c