Epoch-Elysian
Epoch-Elysian

分布式事务框架（seata1.5.0）源码分析-TCC模式

目录

TCC模式

Seata整体架构

事务控制相关概念

空回滚

幂等

防悬挂

GlobalTransactionScanner切面扫描

全局事务处理流程（GlobalTransactionalInterceptor）

全局事务注册

全局事务提交

全局事务回滚

一阶段分支事务Try处理流程（TccActionInterceptor）

分支注册&&上下文参数处理

tcc_fence_log

tcc_fence_log表结构

Try阶段插入tcc_fence_log表

二阶段处理流程

Commit处理流程

Rollback处理流程

TCC幂等&&空回滚&&防悬挂控制总结

TCC模式

整体是 两阶段提交 的模型。全局事务是由若干分支事务组成的，分支事务要满足 两阶段提交 的模型要求，即需要每个分支事务都具备3个方法：

  • Try：资源的检测和预留
  • Confirm：执行的业务操作提交；要求 Try 成功 Confirm 一定要能成功；
  • Cancel：预留资源释放

在一阶段执行 Try 方式，在二阶段提交执行 Confirm 方法，二阶段回滚执行 Cancel 方法。

Seata整体架构

Seata由核心三大模块组成：TM、RM 和 TC，其中TM和RM集成在我们的业务系统作为seata的客户端，而TC作为Seata的server端独立部署。

分布式事务框架（seata1.5.0）源码分析-TCC模式_第1张图片

  • TC (Transaction Coordinator) - 事务协调者：维护全局和分支事务的状态，与客户端TM、RM通信，驱动全局事务提交或回滚。

  • TM (Transaction Manager) - 事务管理器：与服务端TC通信，开启全局事务、提交或回滚全局事务。

  • RM (Resource Manager) - 资源管理器：管理分支事务处理的资源，与TC通信以注册分支事务和报告分支事务的状态，并驱动分支事务提交或回滚。

Seata中，一次事务的执行流程大体如下：

  1. 客户端TM开启一个全局事务，其实就是TM要向TC注册全局事务记录
  2. 按照业务的执行流程，客户端RM向TC注册分支事务，执行分支事务一阶段业务逻辑处理。
  3. 各分支事务一阶段完成，客户端TM 通知 TC 提交/回滚分布式事务
  4. Server端TC汇总所有的分支事务状态，决定事务分支是提交还是回滚
  5. Server端TC 通知所有 RM 提交/回滚 资源，事务二阶段结束

异常场景的处理：

  • TM发起注册全局事务：若注册失败或TC响应超时则抛出异常，流程结束
  • RM发起注册分支事务：若注册失败或TC响应超时则抛出异常，流程结束
  • 业务逻辑执行：若业务处理超时，即TM迟迟未向TC发起全局事务提交/回滚请求，TC检测到全局事务超时后，将禁止分支事务的注册，并发起全局事务回滚
  • TM发起全局事务回滚请求：若请求超时，这个时候可以直接忽略此超时异常。如果TC收到了回滚请求，那么正常回滚。如果TC没收到回滚请求，那么TC在检测到全局事务超时后，一样会发起全局回滚。
  • TM发起全局事务提交请求：若请求超时，如果TC没收到提交请求，那么TC在检测到全局事务超时后，会发起全局回滚，这时与业务代码的异常状态，事务是一致的。如果TC收到了提交请求，那么就可能出现事务不一致的状况。这个时候需要我们做定制化开发，比如说把这种全局事务提交超时的异常登记起来，并且server端提供一个查询接口供客户端回查全局事务的最终状态。

事务控制相关概念

空回滚

空回滚就是对于一个分布式事务，在没有调用 TCC 资源 Try 方法的情况下，调用了二阶段的 Cancel 方法，Cancel 方法需要识别出这是一个空回滚，然后直接返回成功。

出现原因：

  • Try超时（丢包）>> 分布式事务回滚触发cancel >> 未收到try、收到cancel

幂等

幂等就是对于同一个分布式事务的同一个分支事务，重复去调用该分支事务的第二阶段接口，因此，要求 TCC 的二阶段 Confirm 和 Cancel 接口保证幂等，不会重复使用或者释放资源。如果幂等控制没有做好，很有可能导致资损等严重问题。

出现原因：

  • 网络异常

防悬挂

Cancel 比 Try 接口先执行，出现的原因是 Try 由于网络拥堵而超时，事务管理器生成回滚，触发 Cancel 接口，而最终又收到了 Try 接口调用，但是 Cancel 比 Try 先到。按照前面允许空回滚的逻辑，回滚会返回成功，事务管理器认为事务已回滚成功，则此时的 Try 接口不应该执行，否则会产生数据不一致

出现原因：

  • Try超时（拥堵）>> 分布式事务回滚触发cancel >> Try到达

本文重点在于源码分析，不过多介绍分布式事务相关原理和概念，下面进入正题

GlobalTransactionScanner切面扫描

Seata全局事务发起、提交/回滚依赖于SpringAop，GlobalTransactionScanner则是aop的入口类，此类继承于AbstractAutoProxyCreator，重写了wrapIfNecessary方法，懂aop都知道，此方法通过添加interceptor到SpringAop的拦截器链中，生成代理对象来完成代理逻辑的处理。


public class GlobalTransactionScanner extends AbstractAutoProxyCreator
        implements ConfigurationChangeListener, InitializingBean, ApplicationContextAware, DisposableBean {

    @Override
    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        // do checkers
        if (!doCheckers(bean, beanName)) {
            return bean;
        }

        try {
            synchronized (PROXYED_SET) {
                if (PROXYED_SET.contains(beanName)) {
                    return bean;
                }
                interceptor = null;
                // tcc代理bean
                // 判断接口上是否有@LocalTCC && 接口方法上有@TwoPhaseBusinessAction 注解
                // 同时将@TwoPhaseBusinessAction注解内容解析成tccResource，注册到缓存中，key值为TwoPhaseBusinessAction#name属性。
                // 以供全局2阶段从缓存中获取tccResource
                if (TCCBeanParserUtils.isTccAutoProxy(bean, beanName, applicationContext)) {
                    // // 若开启了tcc 幂等、空回滚、防悬挂控制（TwoPhaseBusinessAction#useTCCFence为true），定时清理客户端的tcc_fence_log表记录
                    TCCBeanParserUtils.initTccFenceCleanTask(TCCBeanParserUtils.getRemotingDesc(beanName), applicationContext);
                    //设置tcc代理拦截器
                    interceptor = new TccActionInterceptor(TCCBeanParserUtils.getRemotingDesc(beanName));
                    ConfigurationCache.addConfigListener(ConfigurationKeys.DISABLE_GLOBAL_TRANSACTION,
                            (ConfigurationChangeListener)interceptor);
                } else {
                    // 非tcc模式bean
                    Class serviceInterface = SpringProxyUtils.findTargetClass(bean);
                    Class[] interfacesIfJdk = SpringProxyUtils.findInterfaces(bean);
                    // 查找类和方法上是否有全局事务@GlobalTransactional注解
                    if (!existsAnnotation(new Class[]{serviceInterface})
                        && !existsAnnotation(interfacesIfJdk)) {
                        return bean;
                    }
                    // 设置全局事务代理拦截器。说明@GlobalTransactional和tcc相关注解不能标准在同一类上
                    if (globalTransactionalInterceptor == null) {
                        globalTransactionalInterceptor = new GlobalTransactionalInterceptor(failureHandlerHook);
                        ConfigurationCache.addConfigListener(
                                ConfigurationKeys.DISABLE_GLOBAL_TRANSACTION,
                                (ConfigurationChangeListener)globalTransactionalInterceptor);
                    }
                    interceptor = globalTransactionalInterceptor;
                }

                LOGGER.info("Bean[{}] with name [{}] would use interceptor [{}]", bean.getClass().getName(), beanName, interceptor.getClass().getName());
                // 如果当前bean不是代理对象，调用父类wrapIfNecessary生产代理对象
                if (!AopUtils.isAopProxy(bean)) {
                    bean = super.wrapIfNecessary(bean, beanName, cacheKey);
                } else {
                    AdvisedSupport advised = SpringProxyUtils.getAdvisedSupport(bean);
                    // 拦截器转换成Advisor
                    Advisor[] advisor = buildAdvisors(beanName, getAdvicesAndAdvisorsForBean(null, null, null));
                    int pos;
                    // 按照拦截器的order值，添加拦截器到合适的位置。主要是为了指定该拦截在 spring本地事务拦截器TransactionInterceptor的前面/后面
                    // 像@GlobalTransactionalInterceptor就指定了必须包裹住spring本地事务
                    for (Advisor avr : advisor) {
                        // Find the position based on the advisor's order, and add to advisors by pos
                        pos = findAddSeataAdvisorPosition(advised, avr);
                        advised.addAdvisor(pos, avr);
                    }
                }
                PROXYED_SET.add(beanName);
                return bean;
            }
        } catch (Exception exx) {
            throw new RuntimeException(exx);
        }
    }

    /**
     * 重写getAdvicesAndAdvisorsForBean，返回设置好的拦截器
     * @param beanClass
     * @param beanName
     * @param customTargetSource
     * @return
     * @throws BeansException
     */
    @Override
    protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass, String beanName, TargetSource customTargetSource)
            throws BeansException {
        // 全局事务拦截器/tcc拦截器
        return new Object[]{interceptor};
    }

}

通过GlobalTransactionScanner添加了全局事务和tcc分支事务的代理拦截，具体拦截逻辑分别在GlobalTransactionalInterceptor和TccActionInterceptor中。

全局事务处理流程（GlobalTransactionalInterceptor）

当代码执行到标注有@GlobalTransactional注解的类或者方法时，进入GlobalTransactionalInterceptor拦截处理。


public class GlobalTransactionalInterceptor implements ConfigurationChangeListener, MethodInterceptor, SeataInterceptor {
    @Override
    public Object invoke(final MethodInvocation methodInvocation) throws Throwable {
        Class targetClass =
            methodInvocation.getThis() != null ? AopUtils.getTargetClass(methodInvocation.getThis()) : null;
        Method specificMethod = ClassUtils.getMostSpecificMethod(methodInvocation.getMethod(), targetClass);
        if (specificMethod != null && !specificMethod.getDeclaringClass().equals(Object.class)) {
            final Method method = BridgeMethodResolver.findBridgedMethod(specificMethod);
            // 查找类||方法上的全局事务注解
            final GlobalTransactional globalTransactionalAnnotation =
                getAnnotation(method, targetClass, GlobalTransactional.class);
            // 代理方法增加@GlobalLock+@Transactional  或者 @GlobalTransaction 防止脏读
            final GlobalLock globalLockAnnotation = getAnnotation(method, targetClass, GlobalLock.class);
            boolean localDisable = disable || (degradeCheck && degradeNum >= degradeCheckAllowTimes);
            if (!localDisable) {
                if (globalTransactionalAnnotation != null || this.aspectTransactional != null) {
                    AspectTransactional transactional;
                    if (globalTransactionalAnnotation != null) {
                        transactional = new AspectTransactional(globalTransactionalAnnotation.timeoutMills(),
                            globalTransactionalAnnotation.name(), globalTransactionalAnnotation.rollbackFor(),
                            globalTransactionalAnnotation.noRollbackForClassName(),
                            globalTransactionalAnnotation.noRollbackFor(),
                            globalTransactionalAnnotation.noRollbackForClassName(),
                            globalTransactionalAnnotation.propagation(),
                            globalTransactionalAnnotation.lockRetryInterval(),
                            globalTransactionalAnnotation.lockRetryTimes());
                    } else {
                        transactional = this.aspectTransactional;
                    }
                    //执行全局事务处理逻辑
                    return handleGlobalTransaction(methodInvocation, transactional);
                } else if (globalLockAnnotation != null) {
                    return handleGlobalLock(methodInvocation, globalLockAnnotation);
                }
            }
        }
        return methodInvocation.proceed();
    }


    Object handleGlobalTransaction(final MethodInvocation methodInvocation,
        final AspectTransactional aspectTransactional) throws Throwable {
        boolean succeed = true;
        try {
            return transactionalTemplate.execute(new TransactionalExecutor() {
                @Override
                public Object execute() throws Throwable {
                    return methodInvocation.proceed();
                }

                public String name() {
                    String name = aspectTransactional.getName();
                    if (!StringUtils.isNullOrEmpty(name)) {
                        return name;
                    }
                    // 默认使用 方法名+参数类型名称
                    return formatMethod(methodInvocation.getMethod());
                }

                /**
                 * 组装事务信息
                 * @return
                 */
                @Override
                public TransactionInfo getTransactionInfo() {
                    // reset the value of timeout
                    int timeout = aspectTransactional.getTimeoutMills();
                    if (timeout <= 0 || timeout == DEFAULT_GLOBAL_TRANSACTION_TIMEOUT) {
                        timeout = defaultGlobalTransactionTimeout;
                    }

                    TransactionInfo transactionInfo = new TransactionInfo();
                    transactionInfo.setTimeOut(timeout);
                    transactionInfo.setName(name());
                    transactionInfo.setPropagation(aspectTransactional.getPropagation());
                    transactionInfo.setLockRetryInterval(aspectTransactional.getLockRetryInterval());
                    transactionInfo.setLockRetryTimes(aspectTransactional.getLockRetryTimes());
                    Set rollbackRules = new LinkedHashSet<>();
                    for (Class rbRule : aspectTransactional.getRollbackFor()) {
                        rollbackRules.add(new RollbackRule(rbRule));
                    }
                    for (String rbRule : aspectTransactional.getRollbackForClassName()) {
                        rollbackRules.add(new RollbackRule(rbRule));
                    }
                    for (Class rbRule : aspectTransactional.getNoRollbackFor()) {
                        rollbackRules.add(new NoRollbackRule(rbRule));
                    }
                    for (String rbRule : aspectTransactional.getNoRollbackForClassName()) {
                        rollbackRules.add(new NoRollbackRule(rbRule));
                    }
                    transactionInfo.setRollbackRules(rollbackRules);
                    return transactionInfo;
                }
            });
        } catch (TransactionalExecutor.ExecutionException e) {
            TransactionalExecutor.Code code = e.getCode();
            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));
            }
        }
    }



}

这里使用transactionalTemplate模板封装全局事务的处理，来看看它的execute方法

public Object execute(TransactionalExecutor business) throws Throwable {
	// 1. Get transactionInfo
	TransactionInfo txInfo = business.getTransactionInfo();
	if (txInfo == null) {
		throw new ShouldNeverHappenException("transactionInfo does not exist");
	}
	// 1.1 Get current transaction, if not null, the tx role is 'GlobalTransactionRole.Participant'.
	// 这里会获取线程上下文中的全局事务xid，如果xid不为null，说明此xid是通过rpc传递过来的
	// 那当前应用就是作为此次全局事务的参与方，创建DefaultGlobalTransaction对象。否则，tx为null
	GlobalTransaction tx = GlobalTransactionContext.getCurrent();

	// 1.2 Handle the transaction propagation.
	// 全局事务的传播行为，默认REQUIRED，即继承事务
	Propagation propagation = txInfo.getPropagation();
	SuspendedResourcesHolder suspendedResourcesHolder = null;
	try {
		switch (propagation) {
			case NOT_SUPPORTED:
				// If transaction is existing, suspend it.
				if (existingTransaction(tx)) {
					suspendedResourcesHolder = tx.suspend();
				}
				// Execute without transaction and return.
				return business.execute();
			case REQUIRES_NEW:
				// If transaction is existing, suspend it, and then begin new transaction.
				if (existingTransaction(tx)) {
					suspendedResourcesHolder = tx.suspend();
					tx = GlobalTransactionContext.createNew();
				}
				// Continue and execute with new transaction
				break;
			case SUPPORTS:
				// If transaction is not existing, execute without transaction.
				if (notExistingTransaction(tx)) {
					return business.execute();
				}
				// Continue and execute with new transaction
				break;
			case REQUIRED:
				// If current transaction is existing, execute with current transaction,
				// else continue and execute with new transaction.
				break;
			case NEVER:
				// If transaction is existing, throw exception.
				if (existingTransaction(tx)) {
					throw new TransactionException(
						String.format("Existing transaction found for transaction marked with propagation 'never', xid = %s"
								, tx.getXid()));
				} else {
					// Execute without transaction and return.
					return business.execute();
				}
			case MANDATORY:
				// If transaction is not existing, throw exception.
				if (notExistingTransaction(tx)) {
					throw new TransactionException("No existing transaction found for transaction marked with propagation 'mandatory'");
				}
				// Continue and execute with current transaction.
				break;
			default:
				throw new TransactionException("Not Supported Propagation:" + propagation);
		}

		// 1.3 If null, create new transaction with role 'GlobalTransactionRole.Launcher'.
		if (tx == null) {
			// xid为null，说明是全局事务的发起方。
			tx = GlobalTransactionContext.createNew();
		}

		// set current tx config to holder
		GlobalLockConfig previousConfig = replaceGlobalLockConfig(txInfo);

		try {
			// 2. If the tx role is 'GlobalTransactionRole.Launcher', send the request of beginTransaction to TC,
			//    else do nothing. Of course, the hooks will still be triggered.
			// 如果是全局事务的发起方，通知TC服务端注册一个全局事务
			beginTransaction(txInfo, tx);

			Object rs;
			try {
				// Do Your Business
				// 执行业务方法逻辑
				rs = business.execute();
			} catch (Throwable ex) {
				// 3. The needed business exception to rollback.
				// 全局事务回滚处理
				completeTransactionAfterThrowing(txInfo, tx, ex);
				throw ex;
			}

			// 4. everything is fine, commit.
			// 全局事务提交
			commitTransaction(tx);

			return rs;
		} finally {
			//5. clear
			resumeGlobalLockConfig(previousConfig);
			triggerAfterCompletion();
			cleanUp();
		}
	} finally {
		// If the transaction is suspended, resume it.
		if (suspendedResourcesHolder != null) {
			tx.resume(suspendedResourcesHolder);
		}
	}
}

这里的逻辑十分清晰吗，对于全局事务的发起方，一个分三步

  1. 开启一个全局事务，绑定xid。
  2. 执行业务代码逻辑
  3. 执行全局事务提交/回滚逻辑

全局事务注册


public class DefaultGlobalTransaction implements GlobalTransaction {
    @Override
    public void begin(int timeout, String name) throws TransactionException {
        // 非全局事务的发起方，do nothing
        if (role != GlobalTransactionRole.Launcher) {
            assertXIDNotNull();
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Ignore Begin(): just involved in global transaction [{}]", xid);
            }
            return;
        }
        assertXIDNull();
        // 作为全局事务的发起方，这个时候全局事务还未注册。RooRootContext上下文中的xid理应为null
        String currentXid = RootContext.getXID();
        if (currentXid != null) {
            throw new IllegalStateException("Global transaction already exists," +
                " can't begin a new global transaction, currentXid = " + currentXid);
        }
        // TM向TC注册全局事务，绑定tc返回的全局事务id
        xid = transactionManager.begin(null, null, name, timeout);
        status = GlobalStatus.Begin;
        RootContext.bind(xid);
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Begin new global transaction [{}]", xid);
        }
    }

}

这里的TransactionManager是通过spi加载的，一般的框架中都会有自己的spi机制。

public class TransactionManagerHolder {

    private static final Logger LOGGER = LoggerFactory.getLogger(TransactionManagerHolder.class);

    private static class SingletonHolder {

        private static TransactionManager INSTANCE = null;

        static {
            try {
                INSTANCE = EnhancedServiceLoader.load(TransactionManager.class);
                LOGGER.info("TransactionManager Singleton {}", INSTANCE);
            } catch (Throwable anyEx) {
                LOGGER.error("Failed to load TransactionManager Singleton! ", anyEx);
            }
        }
    }

    /**
     * Get transaction manager.
     *
     * @return the transaction manager
     */
    public static TransactionManager get() {
        if (SingletonHolder.INSTANCE == null) {
            throw new ShouldNeverHappenException("TransactionManager is NOT ready!");
        }
        return SingletonHolder.INSTANCE;
    }

    /**
     * Set a TM instance.
     *
     * @param mock commonly used for test mocking
     */
    public static void set(TransactionManager mock) {
        SingletonHolder.INSTANCE = mock;
    }

    private TransactionManagerHolder() {

    }
}

分布式事务框架（seata1.5.0）源码分析-TCC模式_第2张图片

可以看到TransactionManager默认为DefaultTransactionManager

public class DefaultTransactionManager implements TransactionManager {
    @Override
    public String begin(String applicationId, String transactionServiceGroup, String name, int timeout)
        throws TransactionException {
        GlobalBeginRequest request = new GlobalBeginRequest();
        request.setTransactionName(name);
        request.setTimeout(timeout);
        // 请求TC开启全局事务
        GlobalBeginResponse response = (GlobalBeginResponse) syncCall(request);
        if (response.getResultCode() == ResultCode.Failed) {
            throw new TmTransactionException(TransactionExceptionCode.BeginFailed, response.getMsg());
        }
        return response.getXid();
    }
    private AbstractTransactionResponse syncCall(AbstractTransactionRequest request) throws TransactionException {
        try {
            // TM通过netty发送全局事务开始请求给TC
            return (AbstractTransactionResponse) TmNettyRemotingClient.getInstance().sendSyncRequest(request);
        } catch (TimeoutException toe) {
            throw new TmTransactionException(TransactionExceptionCode.IO, "RPC timeout", toe);
        }
    }
}

全局事务提交

public class DefaultGlobalTransaction implements GlobalTransaction {

    @SuppressWarnings("lgtm[java/constant-comparison]")
    @Override
    public void commit() throws TransactionException {
        // 全局事务的参与方，do nothing
        if (role == GlobalTransactionRole.Participant) {
            // Participant has no responsibility of committing
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Ignore Commit(): just involved in global transaction [{}]", xid);
            }
            return;
        }
        assertXIDNotNull();
        // 重试提交次数，默认5
        int retry = COMMIT_RETRY_COUNT <= 0 ? DEFAULT_TM_COMMIT_RETRY_COUNT : COMMIT_RETRY_COUNT;
        try {
            while (retry > 0) {
                try {
                    retry--;
                    // TM向TC发送全局事务提交请求，返回全局事务状态
                    status = transactionManager.commit(xid);
                    break;
                } catch (Throwable ex) {
                    LOGGER.error("Failed to report global commit [{}],Retry Countdown: {}, reason: {}", this.getXid(), retry, ex.getMessage());
                    if (retry == 0) {
                        throw new TransactionException("Failed to report global commit", ex);
                    }
                }
            }
        } finally {
            // xid解绑
            if (xid.equals(RootContext.getXID())) {
                suspend();
            }
        }
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("[{}] commit status: {}", xid, status);
        }
    }


}

public class DefaultTransactionManager implements TransactionManager {
    @Override
    public GlobalStatus commit(String xid) throws TransactionException {
        GlobalCommitRequest globalCommit = new GlobalCommitRequest();
        globalCommit.setXid(xid);
        // 请求TC提交全局事务
        GlobalCommitResponse response = (GlobalCommitResponse) syncCall(globalCommit);
        return response.getGlobalStatus();
    }
    private AbstractTransactionResponse syncCall(AbstractTransactionRequest request) throws TransactionException {
        try {
            // TM通过netty发送全局事务请求给TC
            return (AbstractTransactionResponse) TmNettyRemotingClient.getInstance().sendSyncRequest(request);
        } catch (TimeoutException toe) {
            throw new TmTransactionException(TransactionExceptionCode.IO, "RPC timeout", toe);
        }
    }
}

全局事务回滚

public class DefaultGlobalTransaction implements GlobalTransaction {
    @SuppressWarnings("lgtm[java/constant-comparison]")
    @Override
    public void rollback() throws TransactionException {
        // 全局事务的参与方，do nothing
        if (role == GlobalTransactionRole.Participant) {
            // Participant has no responsibility of rollback
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Ignore Rollback(): just involved in global transaction [{}]", xid);
            }
            return;
        }
        assertXIDNotNull();
        // 重试回滚次数，默认5
        int retry = ROLLBACK_RETRY_COUNT <= 0 ? DEFAULT_TM_ROLLBACK_RETRY_COUNT : ROLLBACK_RETRY_COUNT;
        try {
            while (retry > 0) {
                try {
                    retry--;
                    // TM向TC发送全局事务回滚请求，返回全局事务状态
                    status = transactionManager.rollback(xid);
                    break;
                } catch (Throwable ex) {
                    LOGGER.error("Failed to report global rollback [{}],Retry Countdown: {}, reason: {}", this.getXid(), retry, ex.getMessage());
                    if (retry == 0) {
                        throw new TransactionException("Failed to report global rollback", ex);
                    }
                }
            }
        } finally {
            // 解绑xid
            if (xid.equals(RootContext.getXID())) {
                suspend();
            }
        }
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("[{}] rollback status: {}", xid, status);
        }
    }
}

public class DefaultTransactionManager implements TransactionManager {
    @Override
    public GlobalStatus rollback(String xid) throws TransactionException {
        GlobalRollbackRequest globalRollback = new GlobalRollbackRequest();
        globalRollback.setXid(xid);
        // 请求TC回滚全局事务
        GlobalRollbackResponse response = (GlobalRollbackResponse) syncCall(globalRollback);
        return response.getGlobalStatus();
    }
    private AbstractTransactionResponse syncCall(AbstractTransactionRequest request) throws TransactionException {
        try {
            // TM通过netty发送全局事务请求给TC
            return (AbstractTransactionResponse) TmNettyRemotingClient.getInstance().sendSyncRequest(request);
        } catch (TimeoutException toe) {
            throw new TmTransactionException(TransactionExceptionCode.IO, "RPC timeout", toe);
        }
    }
}

一阶段分支事务Try处理流程（TccActionInterceptor）

再来看看业务代码中tcc分支事务的流程，即TccActionInterceptor拦截处理

public class TccActionInterceptor implements MethodInterceptor, ConfigurationChangeListener, Ordered {
    @Override
    public Object invoke(final MethodInvocation invocation) throws Throwable {
        // 不处于全局事务||禁用||saga模式，直接执行业务逻辑
        if (!RootContext.inGlobalTransaction() || disable || RootContext.inSagaBranch()) {
            //not in transaction, or this interceptor is disabled
            return invocation.proceed();
        }
        // 获取方法上的TwoPhaseBusinessAction注解
        Method method = getActionInterfaceMethod(invocation);
        TwoPhaseBusinessAction businessAction = method.getAnnotation(TwoPhaseBusinessAction.class);
        //try method
        // 有businessAction注解执行TCC切面逻辑
        if (businessAction != null) {
            //save the xid
            String xid = RootContext.getXID();
            //save the previous branchType
            BranchType previousBranchType = RootContext.getBranchType();
            //if not TCC, bind TCC branchType
            //绑定tcc分支类型
            if (BranchType.TCC != previousBranchType) {
                RootContext.bindBranchType(BranchType.TCC);
            }
            try {
                //Handler the TCC Aspect, and return the business result
                // 重点在这里，ActionInterceptorHandler处理
                return actionInterceptorHandler.proceed(method, invocation.getArguments(), xid, businessAction,
                        invocation::proceed);
            } finally {
                //if not TCC, unbind branchType
                if (BranchType.TCC != previousBranchType) {
                    RootContext.unbindBranchType();
                }
                //MDC remove branchId
                MDC.remove(RootContext.MDC_KEY_BRANCH_ID);
            }
        }

        //not TCC try method
        return invocation.proceed();
    }
}

分支注册&&上下文参数处理

public class ActionInterceptorHandler {
    public Object proceed(Method method, Object[] arguments, String xid, TwoPhaseBusinessAction businessAction,
                                       Callback targetCallback) throws Throwable {
        //Get action context from arguments, or create a new one and then reset to arguments
        //如果方法入参中含有BusinessActionContext类型的参数，则直接获取方法传入的BusinessActionContext，否则，new BusinessActionContext()
        //BusinessActionContext用来保存全局事务2阶段需要的数据，也就是说可以自己指定传入一个BusinessActionContext，没有也会创建一个
        BusinessActionContext actionContext = getOrCreateActionContextAndResetToArguments(method.getParameterTypes(), arguments);

        //Set the xid
        actionContext.setXid(xid);
        //Set the action name
        String actionName = businessAction.name();
        actionContext.setActionName(actionName);
        //Set the delay report
        actionContext.setDelayReport(businessAction.isDelayReport());

        //Creating Branch Record
        //组装@BusinessActionContextParameter参数注解中的内容到BusinessActionContext中
        //向TC注册tcc分支事务，BusinessActionContext以json格式传到TC服务端，获取TC返回的分支id
        String branchId = doTccActionLogStore(method, arguments, businessAction, actionContext);
        actionContext.setBranchId(branchId);
        //MDC put branchId
        MDC.put(RootContext.MDC_KEY_BRANCH_ID, branchId);

        // save the previous action context
        // BusinessActionContextUtil这个工具，用于获取/设置分支上下文中的业务参数。
        BusinessActionContext previousActionContext = BusinessActionContextUtil.getContext();
        try {
            //share actionContext implicitly
            //这里设置BusinessActionContext到线程上下文中后（分支内有效），我们可以在业务代码中调用BusinessActionContextUtil#addContext添加参数，供tcc2阶段使用
            BusinessActionContextUtil.setContext(actionContext);
            //判断是否开启Tcc 幂等、空回滚、防悬挂控制。建议开启，否则需要自己业务代码做响应的处理
            if (businessAction.useTCCFence()) {
                try {
                    // Use TCC Fence, and return the business result
                    // 重点还要看一下这里的处理，TCC 幂等、空回滚、防悬挂控制
                    return TCCFenceHandler.prepareFence(xid, Long.valueOf(branchId), actionName, targetCallback);
                } catch (SkipCallbackWrapperException | UndeclaredThrowableException e) {
                    Throwable originException = e.getCause();
                    if (originException instanceof FrameworkException) {
                        LOGGER.error("[{}] prepare TCC fence error: {}", xid, originException.getMessage());
                    }
                    throw originException;
                }
            } else {
                //Execute business, and return the business result
                //执行业务逻辑处理
                return targetCallback.execute();
            }
        } finally {
            try {
                //to report business action context finally if the actionContext.getUpdated() is true
                //这里的目前是请求TC，更新server端的BusinessActionContext内容。前面注册TCC分支的时候BusinessActionContext就以json字符串格式传递到了server端
                //tcc 而在try方法中业务逻辑中，我们可以添加参数到BusinessActionContext中。所以需要更新
                BusinessActionContextUtil.reportContext(actionContext);
            } finally {
                if (previousActionContext != null) {
                    // 恢复前一个分支上下文，主要是考虑到分支嵌套，上下文传播问题
                    // recovery the previous action context
                    BusinessActionContextUtil.setContext(previousActionContext);
                } else {
                    // clear the action context
                    BusinessActionContextUtil.clear();
                }
            }
        }
    }
    protected String doTccActionLogStore(Method method, Object[] arguments, TwoPhaseBusinessAction businessAction,
                                         BusinessActionContext actionContext) {
        String actionName = actionContext.getActionName();
        String xid = actionContext.getXid();

        //region fetch context and init action context
        //解析方法入参的BusinessActionContextParameter注解，以key-value形式存储到map中
        Map context = fetchActionRequestContext(method, arguments);
        context.put(Constants.ACTION_START_TIME, System.currentTimeMillis());

        //Init business context
        //组装businessAction、方法名到context中
        initBusinessContext(context, method, businessAction);
        //Init running environment context
        initFrameworkContext(context);
        //将context中的内容合并到BusinessActionContext中
        Map originContext = actionContext.getActionContext();
        if (CollectionUtils.isNotEmpty(originContext)) {
            //Merge context and origin context if it exists.
            //@since: above 1.4.2
            originContext.putAll(context);
            context = originContext;
        } else {
            actionContext.setActionContext(context);
        }

        //endregion

        //Init applicationData
        //最后将BusinessActionContext内容转换成json字符串，key值为actionContext
        Map applicationContext = Collections.singletonMap(Constants.TCC_ACTION_CONTEXT, context);
        String applicationContextStr = JSON.toJSONString(applicationContext);
        try {
            //registry branch record
            //在这里RM向TC注册TCC分支事务，获取TC返回的分支id
            Long branchId = DefaultResourceManager.get().branchRegister(BranchType.TCC, actionName, null, xid,
                    applicationContextStr, null);
            return String.valueOf(branchId);
        } catch (Throwable t) {
            String msg = String.format("TCC branch Register error, xid: %s", xid);
            LOGGER.error(msg, t);
            throw new FrameworkException(t, msg);
        }
    }
}
 
  
在分支注册的时候，会将分支上下文中供TCC2阶段使用的业务参数序列化成json字符串一同发送到TC服务端，执行完业务方法后，还需要再请求一次TC更新业务参数，也是整个json字符串传递过去的。而在我们真实的业务场景中，要传递给2阶段执行的参数可能是非常多的，一旦事务分支较多，这会给网络IO带来很大的开销。所以其实这里我们是可以优化的，上下文中的参数信息完全可以保存到客户端的数据库中（存储在tcc_fence_log中就挺合适的），一次数据库操作就可以完整的保存下来。而发送给TC的数据只需要包含基本的分支信息就可以了，也不用再多请求一次TC来更新参数内容。
 
  
TCC模式通过客户端的tcc_fence_log表来完成幂等、空回滚、防悬挂的控制。下面就具体来看下TCCFenceHandler的逻辑
 
  
tcc_fence_log
 
  
tcc_fence_log表结构
 
  
CREATE TABLE IF NOT EXISTS `tcc_fence_log`
(
    `xid`           VARCHAR(128)  NOT NULL COMMENT 'global id',
    `branch_id`     BIGINT        NOT NULL COMMENT 'branch id',
    `action_name`   VARCHAR(64)   NOT NULL COMMENT 'action name',
    `status`        TINYINT       NOT NULL COMMENT 'status(tried:1;committed:2;rollbacked:3;suspended:4)',
    `gmt_create`    DATETIME(3)   NOT NULL COMMENT 'create time',
    `gmt_modified`  DATETIME(3)   NOT NULL COMMENT 'update time',
    PRIMARY KEY (`xid`, `branch_id`),
    KEY `idx_gmt_modified` (`gmt_modified`),
    KEY `idx_status` (`status`)
) ENGINE = InnoDB
DEFAULT CHARSET = utf8mb4;
 
  
可以看到这个表的核心字段就三个：xid-全局事务id，branch_id-分支事务id，action_name-分支名称，主键为（xid，branch_id）
 
  
Try阶段插入tcc_fence_log表
 
  
public class TCCFenceHandler {
    public static Object prepareFence(String xid, Long branchId, String actionName, Callback targetCallback) {
        // 这里使用spring的TransactionTemplate手工开启事务以确保业务代码和tcc_fence_log表insert处于同一事务中
        return transactionTemplate.execute(status -> {
            try {
                //从数据源获取连接
                Connection conn = DataSourceUtils.getConnection(dataSource);
                //insert记录到tcc_fence_log表中
                boolean result = insertTCCFenceLog(conn, xid, branchId, actionName, TCCFenceConstant.STATUS_TRIED);
                LOGGER.info("TCC fence prepare result: {}. xid: {}, branchId: {}", result, xid, branchId);
                if (result) {
                    //执行业务代码处理
                    return targetCallback.execute();
                } else {
                    throw new TCCFenceException(String.format("Insert tcc fence record error, prepare fence failed. xid= %s, branchId= %s", xid, branchId),
                            FrameworkErrorCode.InsertRecordError);
                }
            } catch (TCCFenceException e) {
                //这里如果抛出duplikey异常，说明已经执行或者正在执行2阶段的cancel。
                //抛出异常以支持空回滚和悬挂
                if (e.getErrcode() == FrameworkErrorCode.DuplicateKeyException) {
                    LOGGER.error("Branch transaction has already rollbacked before,prepare fence failed. xid= {},branchId = {}", xid, branchId);
                    //定时清理掉这种记录
                    addToLogCleanQueue(xid, branchId);
                }
                status.setRollbackOnly();
                throw new SkipCallbackWrapperException(e);
            } catch (Throwable t) {
                status.setRollbackOnly();
                throw new SkipCallbackWrapperException(t);
            }
        });
    }
}
 
  
对于try阶段而已，只需要检查第二阶段是否已经执行完成，如果已完成，则不再执行。这里通过往tcc_fence_log表中insert一条记录来保证此机制，如果出现duplikey异常，说明2阶段cancel比try先执行，2阶段cancel为了支持空回滚，也会往此表中insert一条记录，而2阶段commit则是需要检查表中是否有记录，并更新状态。
 
  
二阶段处理流程
 
  
首先要明确的是二阶段无论是commit还是rollback都是由TC服务端发起的请求，对于client端来说，一阶段事务结束，业务流程就已经结束了。2阶段处理已经处于处理tc请求的异步线程中了，而非业务线程中。分支提交/回滚请求是由RM来处理的，委托给DefaultRMHandler处理
 
  
public class DefaultRMHandler extends AbstractRMHandler {
    //通过spi加载所有的RMHandler放到map中，key值为BranchType，value为具体handler对象
    protected void initRMHandlers() {
        List allRMHandlers = EnhancedServiceLoader.loadAll(AbstractRMHandler.class);
        if (CollectionUtils.isNotEmpty(allRMHandlers)) {
            for (AbstractRMHandler rmHandler : allRMHandlers) {
                allRMHandlersMap.put(rmHandler.getBranchType(), rmHandler);
            }
        }
    }
    //处理分支commit请求，对应BranchCommitRequest
    //返回分支处理结果
    @Override
    public BranchCommitResponse handle(BranchCommitRequest request) {
        MDC.put(RootContext.MDC_KEY_XID, request.getXid());
        MDC.put(RootContext.MDC_KEY_BRANCH_ID, String.valueOf(request.getBranchId()));
		//调用具体的handler处理请求
        return getRMHandler(request.getBranchType()).handle(request);
    }
    //处理分支rollback请求，对应BranchRollbackRequest
    //返回分支处理结果
    @Override
    public BranchRollbackResponse handle(BranchRollbackRequest request) {
        MDC.put(RootContext.MDC_KEY_XID, request.getXid());
        MDC.put(RootContext.MDC_KEY_BRANCH_ID, String.valueOf(request.getBranchId()));
		//调用具体的handler处理请求
        return getRMHandler(request.getBranchType()).handle(request);
    }
    // 根据分支类型获取对应的Rmhandler
    protected AbstractRMHandler getRMHandler(BranchType branchType) {
        return allRMHandlersMap.get(branchType);
    }

}

 
  
不同的分支类型对应不同的RmHandler
 
  
分布式事务框架（seata1.5.0）源码分析-TCC模式_第3张图片
 
  
public abstract class AbstractRMHandler extends AbstractExceptionHandler
    implements RMInboundHandler, TransactionMessageHandler {
    @Override
    public BranchCommitResponse handle(BranchCommitRequest request) {
        //分支提交响应体
        BranchCommitResponse response = new BranchCommitResponse();
        //模板方法执行正常/异常情况响应赋值
        exceptionHandleTemplate(new AbstractCallback() {
            @Override
            public void execute(BranchCommitRequest request, BranchCommitResponse response)
                throws TransactionException {
                //分支提交
                doBranchCommit(request, response);
            }
        }, request, response);
        return response;
    }

    @Override
    public BranchRollbackResponse handle(BranchRollbackRequest request) {
        //分支回滚响应体
        BranchRollbackResponse response = new BranchRollbackResponse();
        //模板方法执行正常/异常情况响应赋值
        exceptionHandleTemplate(new AbstractCallback() {
            @Override
            public void execute(BranchRollbackRequest request, BranchRollbackResponse response)
                throws TransactionException {
                //分支回滚
                doBranchRollback(request, response);
            }
        }, request, response);
        return response;
    }

    protected void doBranchCommit(BranchCommitRequest request, BranchCommitResponse response)
        throws TransactionException {
        String xid = request.getXid();
        long branchId = request.getBranchId();
        String resourceId = request.getResourceId();
        //一阶段初始化好的上下文参数内容
        String applicationData = request.getApplicationData();
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Branch committing: " + xid + " " + branchId + " " + resourceId + " " + applicationData);
        }
        //委托给ResourceManager
        BranchStatus status = getResourceManager().branchCommit(request.getBranchType(), xid, branchId, resourceId,
            applicationData);
        response.setXid(xid);
        response.setBranchId(branchId);
        response.setBranchStatus(status);
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Branch commit result: " + status);
        }

    }

    protected void doBranchRollback(BranchRollbackRequest request, BranchRollbackResponse response)
        throws TransactionException {
        String xid = request.getXid();
        long branchId = request.getBranchId();
        String resourceId = request.getResourceId();
        //一阶段初始化好的上下文参数内容
        String applicationData = request.getApplicationData();
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Branch Rollbacking: " + xid + " " + branchId + " " + resourceId);
        }
        //委托给ResourceManager
        BranchStatus status = getResourceManager().branchRollback(request.getBranchType(), xid, branchId, resourceId,
            applicationData);
        response.setXid(xid);
        response.setBranchId(branchId);
        response.setBranchStatus(status);
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Branch Rollbacked result: " + status);
        }
    }


}

 
  
ResourceManager也是通过spi加载的，委托给DefaultResourceManager，最终定位到TCCResourceManager
 
  
Commit处理流程
 
  
public class TCCResourceManager extends AbstractResourceManager {

    @Override
    public BranchStatus branchCommit(BranchType branchType, String xid, long branchId, String resourceId,
                                     String applicationData) throws TransactionException {
        //通过resource名称获取到具体的TCCResource对象，
        //在客户端GlobalTransactionScanner扫描的时候就将各分支方法的@TwoPhaseBusinessAction解析成TCCResource注册到map中
        TCCResource tccResource = (TCCResource)tccResourceCache.get(resourceId);
        if (tccResource == null) {
            throw new ShouldNeverHappenException(String.format("TCC resource is not exist, resourceId: %s", resourceId));
        }
        //目标对象
        Object targetTCCBean = tccResource.getTargetBean();
        //指定的commit方法
        Method commitMethod = tccResource.getCommitMethod();
        if (targetTCCBean == null || commitMethod == null) {
            throw new ShouldNeverHappenException(String.format("TCC resource is not available, resourceId: %s", resourceId));
        }
        try {
            //BusinessActionContext
            //将TC server端返回的applicationData、xid等组装成BusinessActionContext对象，供2阶段commit方法使用
            BusinessActionContext businessActionContext = getBusinessActionContext(xid, branchId, resourceId,
                applicationData);
            //支持在try方法上的@TwoPhaseBusinessAction中commitArgsClasses + commit方法参数注解@BusinessActionContextParameter  自定义2阶段commmit方法入参
            //以@BusinessActionContextParameter的value属性作为key，从businessActionContext中获取到json string，再反序列为commitArgsClasses指定类型对象
            Object[] args = this.getTwoPhaseCommitArgs(tccResource, businessActionContext);
            Object ret;
            boolean result;
            // add idempotent and anti hanging
            // 幂等、空回滚、防悬挂处理
            if (Boolean.TRUE.equals(businessActionContext.getActionContext(Constants.USE_TCC_FENCE))) {
                try {
                    result = TCCFenceHandler.commitFence(commitMethod, targetTCCBean, xid, branchId, args);
                } catch (SkipCallbackWrapperException | UndeclaredThrowableException e) {
                    throw e.getCause();
                }
            } else {
                //直接执行commit方法
                ret = commitMethod.invoke(targetTCCBean, args);
                if (ret != null) {
                    if (ret instanceof TwoPhaseResult) {
                        result = ((TwoPhaseResult)ret).isSuccess();
                    } else {
                        result = (boolean)ret;
                    }
                } else {
                    result = true;
                }
            }
            LOGGER.info("TCC resource commit result : {}, xid: {}, branchId: {}, resourceId: {}", result, xid, branchId, resourceId);
            return result ? BranchStatus.PhaseTwo_Committed : BranchStatus.PhaseTwo_CommitFailed_Retryable;
        } catch (Throwable t) {
            String msg = String.format("commit TCC resource error, resourceId: %s, xid: %s.", resourceId, xid);
            LOGGER.error(msg, t);
            return BranchStatus.PhaseTwo_CommitFailed_Retryable;
        }
    }
}

 
  
TCCFenceHandler.commitFence
 
  
public class TCCFenceHandler {
    public static boolean commitFence(Method commitMethod, Object targetTCCBean,
                                      String xid, Long branchId, Object[] args) {
        //开启事务保证tcc_fence_log的操作和业务事务绑定再一起
        return transactionTemplate.execute(status -> {
            try {
                Connection conn = DataSourceUtils.getConnection(dataSource);
                //commit操作前，先查询一下有没有该分支一阶段执行记录
                TCCFenceDO tccFenceDO = TCC_FENCE_DAO.queryTCCFenceDO(conn, xid, branchId);
                //没有记录，说明一阶段都未执行，不能执行commit，直接报错。报错后，等待重试
                if (tccFenceDO == null) {
                    throw new TCCFenceException(String.format("TCC fence record not exists, commit fence method failed. xid= %s, branchId= %s", xid, branchId),
                            FrameworkErrorCode.RecordAlreadyExists);
                }
                //幂等控制：分支状态已提交，说明是重试执行，直接返回成功
                if (TCCFenceConstant.STATUS_COMMITTED == tccFenceDO.getStatus()) {
                    LOGGER.info("Branch transaction has already committed before. idempotency rejected. xid: {}, branchId: {}, status: {}", xid, branchId, tccFenceDO.getStatus());
                    return true;
                }
                //理论上讲，不会存在这种情况。会重试
                if (TCCFenceConstant.STATUS_ROLLBACKED == tccFenceDO.getStatus() || TCCFenceConstant.STATUS_SUSPENDED == tccFenceDO.getStatus()) {
                    if (LOGGER.isWarnEnabled()) {
                        LOGGER.warn("Branch transaction status is unexpected. xid: {}, branchId: {}, status: {}", xid, branchId, tccFenceDO.getStatus());
                    }
                    return false;
                }
                //分支记录存在且还是初始化状态，正常执行commmit中业务逻辑，更新分支记录的状态为COMMITTED
                return updateStatusAndInvokeTargetMethod(conn, commitMethod, targetTCCBean, xid, branchId, TCCFenceConstant.STATUS_COMMITTED, status, args);
            } catch (Throwable t) {
                status.setRollbackOnly();
                throw new SkipCallbackWrapperException(t);
            }
        });
    }
}

 
  
 
  
Rollback处理流程
 
  
public class TCCResourceManager extends AbstractResourceManager {
    @Override
    public BranchStatus branchRollback(BranchType branchType, String xid, long branchId, String resourceId,
                                       String applicationData) throws TransactionException {
        //通过resource名称获取到具体的TCCResource对象，
        //在客户端GlobalTransactionScanner扫描的时候就将各分支方法的@TwoPhaseBusinessAction解析成TCCResource注册到map中
        TCCResource tccResource = (TCCResource)tccResourceCache.get(resourceId);
        if (tccResource == null) {
            throw new ShouldNeverHappenException(String.format("TCC resource is not exist, resourceId: %s", resourceId));
        }
        //目标对象
        Object targetTCCBean = tccResource.getTargetBean();
        //指定的rollback方法
        Method rollbackMethod = tccResource.getRollbackMethod();
        if (targetTCCBean == null || rollbackMethod == null) {
            throw new ShouldNeverHappenException(String.format("TCC resource is not available, resourceId: %s", resourceId));
        }
        try {
            //BusinessActionContext
            //将TC server端返回的applicationData、xid等组装成BusinessActionContext对象，供2阶段rollback方法使用
            BusinessActionContext businessActionContext = getBusinessActionContext(xid, branchId, resourceId,
                applicationData);
            //支持在try方法上的@TwoPhaseBusinessAction中rollbackArgsClasses + rollback方法参数注解的@BusinessActionContextParameter  自定义2阶段rollback方法入参
            //以@BusinessActionContextParameter的value属性作为key，从businessActionContext中获取到json string，再反序列为rollbackArgsClasses指定类型对象
            Object[] args = this.getTwoPhaseRollbackArgs(tccResource, businessActionContext);
            Object ret;
            boolean result;
            // add idempotent and anti hanging
            // 幂等、空回滚、防悬挂处理
            if (Boolean.TRUE.equals(businessActionContext.getActionContext(Constants.USE_TCC_FENCE))) {
                try {
                    result = TCCFenceHandler.rollbackFence(rollbackMethod, targetTCCBean, xid, branchId,
                            args, tccResource.getActionName());
                } catch (SkipCallbackWrapperException | UndeclaredThrowableException e) {
                    throw e.getCause();
                }
            } else {
                //直接执行rollback方法
                ret = rollbackMethod.invoke(targetTCCBean, args);
                if (ret != null) {
                    if (ret instanceof TwoPhaseResult) {
                        result = ((TwoPhaseResult)ret).isSuccess();
                    } else {
                        result = (boolean)ret;
                    }
                } else {
                    result = true;
                }
            }
            LOGGER.info("TCC resource rollback result : {}, xid: {}, branchId: {}, resourceId: {}", result, xid, branchId, resourceId);
            return result ? BranchStatus.PhaseTwo_Rollbacked : BranchStatus.PhaseTwo_RollbackFailed_Retryable;
        } catch (Throwable t) {
            String msg = String.format("rollback TCC resource error, resourceId: %s, xid: %s.", resourceId, xid);
            LOGGER.error(msg, t);
            return BranchStatus.PhaseTwo_RollbackFailed_Retryable;
        }
    }
}

 
  
TCCFenceHandler.rollbackFence
 
  
public class TCCFenceHandler {
    public static boolean rollbackFence(Method rollbackMethod, Object targetTCCBean,
                                        String xid, Long branchId, Object[] args, String actionName) {
        //开启事务保证tcc_fence_log的操作和业务事务绑定再一起
        return transactionTemplate.execute(status -> {
            try {
                Connection conn = DataSourceUtils.getConnection(dataSource);
                //rollback操作前，先查询一下有没有该分支一阶段执行记录
                TCCFenceDO tccFenceDO = TCC_FENCE_DAO.queryTCCFenceDO(conn, xid, branchId);
                // non_rollback
                // 空回滚&&防悬挂：没有记录，说明一阶段try未执行，或者本地事务回滚。先insert一条分支记录，确保后到的try方法不会再执行
                // 如果insert成功，说明try还没有执行，空回滚成功
                // 如果insert失败，说明try正在执行，抛出异常，等待TC重试即可
                if (tccFenceDO == null) {
                    boolean result = insertTCCFenceLog(conn, xid, branchId, actionName, TCCFenceConstant.STATUS_SUSPENDED);
                    LOGGER.info("Insert tcc fence record result: {}. xid: {}, branchId: {}", result, xid, branchId);
                    if (!result) {
                        throw new TCCFenceException(String.format("Insert tcc fence record error, rollback fence method failed. xid= %s, branchId= %s", xid, branchId),
                                FrameworkErrorCode.InsertRecordError);
                    }
                    return true;
                } else {
                    // 幂等控制：如果已经rollback，直接返回成功
                    if (TCCFenceConstant.STATUS_ROLLBACKED == tccFenceDO.getStatus() || TCCFenceConstant.STATUS_SUSPENDED == tccFenceDO.getStatus()) {
                        LOGGER.info("Branch transaction had already rollbacked before, idempotency rejected. xid: {}, branchId: {}, status: {}", xid, branchId, tccFenceDO.getStatus());
                        return true;
                    }
                    // 理论上不会出现这种情况
                    if (TCCFenceConstant.STATUS_COMMITTED == tccFenceDO.getStatus()) {
                        if (LOGGER.isWarnEnabled()) {
                            LOGGER.warn("Branch transaction status is unexpected. xid: {}, branchId: {}, status: {}", xid, branchId, tccFenceDO.getStatus());
                        }
                        return false;
                    }
                }
                // 分支记录存在且还是初始化状态，正常执行rollback中业务逻辑，更新分支记录的状态为ROLLBACKED
                return updateStatusAndInvokeTargetMethod(conn, rollbackMethod, targetTCCBean, xid, branchId, TCCFenceConstant.STATUS_ROLLBACKED, status, args);
            } catch (Throwable t) {
                status.setRollbackOnly();
                throw new SkipCallbackWrapperException(t);
            }
        });
    }
}

 
  
TCC幂等&&空回滚&&防悬挂控制总结
 
  
     
   
  1. 一阶段try：执行前insert一条初始分支记录，如果插入成功，说明第二阶段还没有执行，可以继续执行第一阶段。如果插入失败，则说明第二阶段已经执行或正在执行，抛出异常
    2.  
   
  2. 二阶段commit：对于commit，一定要保证commit方法在 Try 方法之后执行。 
    
       
     
    1. 首先判断分支记录是否存在，如果不存在，直接抛出异常，等待重试
      2.  
     
    2. 如果记录存在且状态为已提交，说明是重复提交请求，直接返回成功
      3.  
     
    3. 如果记录存在且状态为初始化，执行commit方法逻辑，并更新分支记录状态为已提交
      4.  
    
    3.  
   
  3. 二阶段rollback：对于rollback，要支持空回滚，防止事务悬挂 
    
       
     
    1. 首先判断分支记录是否存在，如果不存在，则认为 Try 方法还没执行，即是空回滚，应该先插入一条事务记录，确保后续的 Try 方法不会再执行。
      2.  
     
    2. 如果insert成功，说明try未执行，空回滚成功
      3.  
     
    3. 如果insert失败，说明try正在执行，抛出异常，等待TC重试
      4.  
     
    4. 如果分支记录存在并且为已回滚状态，说明是重复rollback请求，直接返回成功
      5.  
     
    5. 如果分支记录存在并且为初始化状态，执行rollback方法逻辑，并更新分支记录状态为已回滚
      6.  
    
    4.  
  
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(源码解析,架构,工作原理,云原生,java)

        

            

                
    
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 腾讯云技术深度探索：构建高效云原生微服务架构
                        我的运维人生
云原生架构腾讯云运维开发技术共享
                        
    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
    
                    
    • 
                    
  • 关于提高复杂业务逻辑代码可读性的思考
                        编程经验分享
开发经验java数据库开发语言
                        
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • 18、架构-可观测性之聚合度量
                        大树~~
架构javapython后端架构
                        
    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • BART&BERT
                        Ambition_LAO
深度学习
                        
    BART和BERT都是基于Transformer架构的预训练语言模型。模型架构：BERT(BidirectionalEncoderRepresentationsfromTransformers)主要是一个编码器（Encoder）模型，它使用了Transformer的编码器部分来处理输入的文本，并生成文本的表示。BERT特别擅长理解语言的上下文，因为它在预训练阶段使用了掩码语言模型（MLM）任务，即
    
                    
    • 
                    
  • 系统架构设计师 需求分析篇二
                        AmHardy
软件架构设计师系统架构需求分析面向对象分析分析模型UML和SysML
                        
    面向对象分析方法1.用例模型构建用例模型一般需要经历4个阶段：识别参与者：识别与系统交互的所有事物。合并需求获得用例：将需求分配给予其相关的参与者。细化用例描述：详细描述每个用例的功能。调整用例模型：优化用例之间的关系和结构，前三个阶段是必需的。2.用例图的三元素参与者：使用系统的用户或其他外部系统和设备。用例：系统所提供的服务。通信关联：参与者和用例之间的关系，或用例与用例之间的关系。3.识别参
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • Armv8.3 体系结构扩展--原文版
                        代码改变世界ctw
ARM-TEE-Androidarmv8嵌入式arm架构安全架构芯片TrustzoneSecureboot
                        
    快速链接:.ARMv8/ARMv9架构入门到精通-[目录]付费专栏-付费课程【购买须知】:个人博客笔记导读目录(全部)TheArmv8.3architectureextensionTheArmv8.3architectureextensionisanextensiontoArmv8.2.Itaddsmandatoryandoptionalarchitecturalfeatures.Somefeat
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • 计算机木马详细编写思路
                        小熊同学哦
php开发语言木马木马思路
                        
    导语：计算机木马（ComputerTrojan）是一种恶意软件，通过欺骗用户从而获取系统控制权限，给黑客打开系统后门的一种手段。虽然木马的存在给用户和系统带来严重的安全风险，但是了解它的工作原理与编写思路，对于我们提高防范意识、构建更健壮的网络安全体系具有重要意义。本篇博客将深入剖析计算机木马的详细编写思路，以及如何复杂化挑战，以期提高读者对计算机木马的认识和对抗能力。计算机木马的基本原理计算机木
    
                    
    • 
                                
  • LeetCode[位运算] - #137 Single Number II
                                    Cwind
javaAlgorithmLeetCode题解位运算
                                    
    原题链接：#137 Single Number II  
要求： 
给定一个整型数组，其中除了一个元素之外，每个元素都出现三次。找出这个元素 
注意：算法的时间复杂度应为O(n)，最好不使用额外的内存空间 
  
难度：中等 
  
分析： 
与#136类似，都是考察位运算。不过出现两次的可以使用异或运算的特性 n XOR n = 0, n XOR 0 = n，即某一
    
                                
    • 
                                
  • 《JavaScript语言精粹》笔记
                                    aijuans
JavaScript
                                    
    0、JavaScript的简单数据类型包括数字、字符创、布尔值（true/false）、null和undefined值，其它值都是对象。 
1、JavaScript只有一个数字类型，它在内部被表示为64位的浮点数。没有分离出整数，所以1和1.0的值相同。 
2、NaN是一个数值，表示一个不能产生正常结果的运算结果。NaN不等于任何值，包括它本身。可以用函数isNaN(number)检测NaN,但是
    
                                
    • 
                                
  • 你应该更新的Java知识之常用程序库
                                    Kai_Ge
java
                                    
    在很多人眼中，Java 已经是一门垂垂老矣的语言，但并不妨碍 Java 世界依然在前进。如果你曾离开 Java，云游于其它世界，或是每日只在遗留代码中挣扎，或许是时候抬起头，看看老 Java 中的新东西。 
Guava 
Guava[gwɑ:və]，一句话，只要你做Java项目，就应该用Guava（Github）。 
guava 是 Google 出品的一套 Java 核心库，在我看来，它甚至应该
    
                                
    • 
                                
  • HttpClient
                                    120153216
httpclient
                                    
    /**
 * 可以传对象的请求转发，对象已流形式放入HTTP中
 */
public static Object doPost(Map<String,Object> parmMap,String url)
	{
		Object object = null;
		HttpClient hc = new HttpClient();
		
		String fullURL 
    
                                
    • 
                                
  • Django model字段类型清单
                                    2002wmj
django
                                    
    Django 通过 models 实现数据库的创建、修改、删除等操作，本文为模型中一般常用的类型的清单，便于查询和使用： AutoField：一个自动递增的整型字段，添加记录时它会自动增长。你通常不需要直接使用这个字段；如果你不指定主键的话，系统会自动添加一个主键字段到你的model。(参阅自动主键字段)  BooleanField：布尔字段,管理工具里会自动将其描述为checkbox。  Cha
    
                                
    • 
                                
  • 在SQLSERVER中查找消耗CPU最多的SQL
                                    357029540
SQL Server
                                    
    返回消耗CPU数目最多的10条语句 
 
SELECT TOP 10 
   total_worker_time/execution_count AS avg_cpu_cost, plan_handle, 
   execution_count, 
   (SELECT SUBSTRING(text, statement_start_of
    
                                
    • 
                                
  • Myeclipse项目无法部署，Undefined exploded archive location
                                    7454103
eclipseMyEclipse
                                    
    做个备忘！ 
 
错误信息为： 
      Undefined exploded archive location 
 
 
原因： 
          在工程转移过程中，导致工程的配置文件出错； 
 
 
解决方法： 
   
    
                                
    • 
                                
  • GMT时间格式转换
                                    adminjun
GMT时间转换
                                    
    普通的时间转换问题我这里就不再罗嗦了，我想大家应该都会那种低级的转换问题吧，现在我向大家总结一下如何转换GMT时间格式，这种格式的转换方法网上还不是很多，所以有必要总结一下，也算给有需要的朋友一个小小的帮助啦。 
1、可以使用 
SimpleDateFormat SimpleDateFormat    
EEE-三位星期 
d-天 
MMM-月 
yyyy-四位年 

    
                                
    • 
                                
  • Oracle数据库新装连接串问题
                                    aijuans
oracle数据库
                                    
    割接新装了数据库，客户端登陆无问题，apache/cgi-bin程序有问题，sqlnet.log日志如下： 
Fatal NI connect error 12170. 
  VERSION INFORMATION:         TNS for Linux: Version 10.2.0.4.0 - Product
    
                                
    • 
                                
  • 回顾java数组复制
                                    ayaoxinchao
java数组
                                    
    在写这篇文章之前，也看了一些别人写的，基本上都是大同小异。文章是对java数组复制基础知识的回顾，算是作为学习笔记，供以后自己翻阅。首先，简单想一下这个问题：为什么要复制数组？我的个人理解：在我们在利用一个数组时，在每一次使用，我们都希望它的值是初始值。这时我们就要对数组进行复制，以达到原始数组值的安全性。java数组复制大致分为3种方式：①for循环方式 ②clone方式 ③arrayCopy方
    
                                
    • 
                                
  • java web会话监听并使用spring注入
                                    bewithme
Java Web
                                    
      
      在java web应用中，当你想在建立会话或移除会话时，让系统做某些事情，比如说，统计在线用户，每当有用户登录时，或退出时，那么可以用下面这个监听器来监听。 
       
import java.util.ArrayList;
import java.ut
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(Redis的常用命令及高级应用)
                                    bijian1013
redis数据库NoSQL
                                    
    一 .Redis常用命令 
        Redis提供了丰富的命令对数据库和各种数据库类型进行操作，这些命令可以在Linux终端使用。 
        a.键值相关命令 
        b.服务器相关命令 
1.键值相关命令 
      &
    
                                
    • 
                                
  • java枚举序列化问题
                                    bingyingao
java枚举序列化
                                    
    对象在网络中传输离不开序列化和反序列化。而如果序列化的对象中有枚举值就要特别注意一些发布兼容问题: 
 
 
1.加一个枚举值 
新机器代码读分布式缓存中老对象，没有问题，不会抛异常。 
 
老机器代码读分布式缓存中新对像，反序列化会中断，所以在所有机器发布完成之前要避免出现新对象，或者提前让老机器拥有新增枚举的jar。 
 
 
 
  2.删一个枚举值 
新机器代码读分布式缓存中老对象，反序列
    
                                
    • 
                                
  • 【Spark七十八】Spark Kyro序列化
                                    bit1129
spark
                                    
    当使用SparkContext的saveAsObjectFile方法将对象序列化到文件，以及通过objectFile方法将对象从文件反序列出来的时候，Spark默认使用Java的序列化以及反序列化机制，通常情况下，这种序列化机制是很低效的，Spark支持使用Kyro作为对象的序列化和反序列化机制，序列化的速度比java更快，但是使用Kyro时要注意，Kyro目前还是有些bug。 
 
 Spark
    
                                
    • 
                                
  • Hybridizing OO and Functional Design
                                    bookjovi
erlanghaskell
                                    
      推荐博文：
Tell Above, and Ask Below - Hybridizing OO and Functional Design  
文章中把OO和FP讲的深入透彻，里面把smalltalk和haskell作为典型的两种编程范式代表语言，此点本人极为同意，smalltalk可以说是最能体现OO设计的面向对象语言，smalltalk的作者Alan kay也是OO的最早先驱，
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-HashMap
                                    BrokenDreams
Collections
                                    
            开发中常常会用到这样一种数据结构，根据一个关键字，找到所需的信息。这个过程有点像查字典，拿到一个key，去字典表中查找对应的value。Java1.0版本提供了这样的类java.util.Dictionary(抽象类)，基本上支持字典表的操作。后来引入了Map接口，更好的描述的这种数据结构。 
 &nb
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-职责链模式-Chain Of Responsibility
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 
 
 




/**
 * 业务逻辑：项目经理只能处理500以下的费用申请，部门经理是1000，总经理不设限。简单起见，只同意“Tom”的申请
 * bylijinnan
 */
abstract class Handler {
	/* 
    
                                
    • 
                                
  • Android中启动外部程序
                                    cherishLC
android
                                    
    1、启动外部程序 
引用自： 
http://blog.csdn.net/linxcool/article/details/7692374 
 
//方法一
Intent intent=new Intent();
//包名 包名+类名（全路径）
intent.setClassName("com.linxcool", "com.linxcool.PlaneActi
    
                                
    • 
                                
  • summary_keep_rate
                                    coollyj
SUM
                                    
    
BEGIN  
      /*DECLARE  minDate varchar(20) ;
      DECLARE  maxDate varchar(20) ;*/
      DECLARE  stkDate varchar(20) ;

      DECLARE done int default -1; 
			/* 游标中 注册服务器地址 */  
      DE
    
                                
    • 
                                
  • hadoop hdfs 添加数据目录出错
                                    daizj
hadoophdfs扩容
                                    
    由于原来配置的hadoop data目录快要用满了，故准备修改配置文件增加数据目录，以便扩容，但由于疏忽，把core-site.xml, hdfs-site.xml配置文件dfs.datanode.data.dir 配置项增加了配置目录，但未创建实际目录，重启datanode服务时，报如下错误： 
 
2014-11-18 08:51:39,128 WARN org.apache.hadoop.h
    
                                
    • 
                                
  • grep 目录级联查找
                                    dongwei_6688
grep
                                    
           在Mac或者Linux下使用grep进行文件内容查找时，如果给定的目标搜索路径是当前目录，那么它默认只搜索当前目录下的文件，而不会搜索其下面子目录中的文件内容，如果想级联搜索下级目录，需要使用一个“-r”参数： 
grep -n -r "GET" . 
  
上面的命令将会找出当前目录“.”及当前目录中所有下级目录
    
                                
    • 
                                
  • yii 修改模块使用的布局文件
                                    dcj3sjt126com
yiilayouts
                                    
    方法一：yii模块默认使用系统当前的主题布局文件，如果在主配置文件中配置了主题比如:  'theme'=>'mythm',   那么yii的模块就使用 protected/themes/mythm/views/layouts 下的布局文件；   如果未配置主题，那么 yii的模块就使用  protected/views/layouts 下的布局文件， 总之默认不是使用自身目录 pr
    
                                
    • 
                                
  • 设计模式之单例模式
                                    come_for_dream
设计模式单例模式懒汉式饿汉式双重检验锁失败无序写入
                                    
                    今天该来的面试还没来，这个店估计不会来电话了，安静下来写写博客也不错，没事翻了翻小易哥的博客甚至与大牛们之间的差距，基础知识不扎实建起来的楼再高也只能是危楼罢了，陈下心回归基础把以前学过的东西总结一下。 
  
*********************************
    
                                
    • 
                                
  • 8、数组
                                    豆豆咖啡
二维数组数组一维数组
                                    
      
一、概念 
  
    数组是同一种类型数据的集合。其实数组就是一个容器。 
  
二、好处 
  
    可以自动给数组中的元素从0开始编号，方便操作这些元素 
  
三、格式 
  
//一维数组
1,元素类型[] 变量名 = new 元素类型[元素的个数]
int[] arr =
    
                                
    • 
                                
  • Decode Ways
                                    hcx2013
decode
                                    
    A message containing letters from A-Z is being encoded to numbers using the following mapping: 
'A' -> 1
'B' -> 2
...
'Z' -> 26
 
Given an encoded message containing digits, det
    
                                
    • 
                                
  • Spring4.1新特性——异步调度和事件机制的异常处理
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • squid3(高命中率)缓存服务器配置
                                    liyonghui160com

                                    
      
  
系统:centos 5.x 
  需要的软件:squid-3.0.STABLE25.tar.gz 
1.下载squid 
wget http://www.squid-cache.org/Versions/v3/3.0/squid-3.0.STABLE25.tar.gz 
tar zxf squid-3.0.STABLE25.tar.gz &&
    
                                
    • 
                                
  • 避免Java应用中NullPointerException的技巧和最佳实践
                                    pda158
java
                                    
    1) 从已知的String对象中调用equals()和equalsIgnoreCase()方法，而非未知对象。   　　总是从已知的非空String对象中调用equals()方法。因为equals()方法是对称的，调用a.equals(b)和调用b.equals(a)是完全相同的，这也是为什么程序员对于对象a和b这么不上心。如果调用者是空指针，这种调用可能导致一个空指针异常 
Object unk
    
                                
    • 
                                
  • 如何在Swift语言中创建http请求
                                    shoothao
httpswift
                                    
      
 概述：本文通过实例从同步和异步两种方式上回答了”如何在Swift语言中创建http请求“的问题。  
   
如果你对Objective-C比较了解的话，对于如何创建http请求你一定驾轻就熟了，而新语言Swift与其相比只有语法上的区别。但是，对才接触到这个崭新平台的初学者来说，他们仍然想知道“如何在Swift语言中创建http请求？”。 
在这里,我将作出一些建议来回答上述问题。常见的
    
                                
    • 
                                
  • Spring事务的传播方式
                                    uule
spring事务
                                    
    传播方式：  
      新建事务 
      required 
      required_new   - 挂起当前 
  
      非事务方式运行 
      supports 
  &nbs
    
                                
    •