Seata-TCC mode principle

TCC mode is very simple to use. Here, only part of the code related to the implementation principle is selected, and the principle analysis is carried out with these codes. The example here is taken from Seata-sample on Github

TccActionOne
public interface TccActionOne {
    @TwoPhaseBusinessAction(name = "DubboTccActionOne" , commitMethod = "commit", rollbackMethod = "rollback")
    public boolean prepare(BusinessActionContext actionContext, @BusinessActionContextParameter(paramName = "a") int a);

    public boolean commit(BusinessActionContext actionContext);

    public boolean rollback(BusinessActionContext actionContext);
}

TccActionTwo
public interface TccActionTwo {
    @TwoPhaseBusinessAction(name = "DubboTccActionTwo" , commitMethod = "commit", rollbackMethod = "rollback")
    public boolean prepare(BusinessActionContext actionContext, @BusinessActionContextParameter(paramName = "b") String b, @BusinessActionContextParameter(paramName = "c",index = 1) List list);

    public boolean commit(BusinessActionContext actionContext);

    public boolean rollback(BusinessActionContext actionContext);

}
Copy the code

In terms of process, TCC mode is basically the same as AT mode in the whole process, as shown below:

In the process, the main differences between AT and TCC modes are:

• AT mode is to do the proxy in the DB data source layer, by intercepting SQL execution, register branch in the TC before SQL execution; TC mode is implemented via @TwophaseBusinessAction, which is a framework level scan of @TwophaseBusinessAction annotations to register Branch in TCS via interceptors.
• In the Branch COMMIT/ROLLBACK phase, data is rolled back based on undo log in AT mode. In TCC mode, you need to make your own COMMIT /rollback methods.

The sequence diagram of TCC mode is very similar to that of AT mode. On the whole, only the part marked with dotted lines is different from that of AT mode.

This step is exactly the same as in AT mode. After successful registration, the XID is bound to the context and passed to the individual microservices.

After finish the begin stage in GlobalTransactionalInterceptor blocker, will formally implement the business logic code in TM, namely in the sample:

@GlobalTransactional public String doTransactionCommit(){ boolean result = tccActionOne.prepare(null, 1); if(! result){ throw new RuntimeException("TccActionOne failed."); } List list = new ArrayList(); result = tccActionTwo.prepare(null, "two", list); if(! result){ throw new RuntimeException("TccActionTwo failed."); } return RootContext.getXID(); }Copy the code

When the service logic is executed, RPC calls the interfaces of other microservices (microservices B and C). RM enters the Register Branch phase during the service logic execution.

When the system starts up, it generates a proxy for classes using the @TwophaseBusinessAction annotation, which is handled by the TccActionInterceptor. The interceptor is very simple and does a few things:

• The binding BranchType is branchtype.tcc
• Get the context of the TCC method through annotations to find the corresponding method directly during the Confirm/Cancel phase.
• Register branch transactions with TCS. See the code below.

TccActionInterceptor#invoke public Object invoke(final MethodInvocation invocation) throws Throwable { if (! RootContext.inGlobalTransaction() || disable || RootContext.inSagaBranch()) { //not in transaction return invocation.proceed(); } Method method = getActionInterfaceMethod(invocation); TwoPhaseBusinessAction businessAction = method.getAnnotation(TwoPhaseBusinessAction.class); //try method if (businessAction ! = null) { //save the xid String xid = RootContext.getXID(); //save the previous branchType BranchType previousBranchType = RootContext.getBranchType(); //if not TCC, bind TCC branchType if (BranchType.TCC ! = previousBranchType) { RootContext.bindBranchType(BranchType.TCC); } try { Object[] methodArgs = invocation.getArguments(); //Handler the TCC Aspect Map<String, Object> ret = actionInterceptorHandler.proceed(method, methodArgs, xid, businessAction, invocation::proceed); //return the final result return ret.get(Constants.TCC_METHOD_RESULT); } finally { //if not TCC, unbind branchType if (BranchType.TCC ! = previousBranchType) { RootContext.unbindBranchType(); } //MDC remove branchId MDC.remove(RootContext.MDC_KEY_BRANCH_ID); } } return invocation.proceed(); } ActionInterceptorHandler#proceed public Map<String, Object> proceed(Method method, Object[] arguments, String xid, TwoPhaseBusinessAction businessAction, Callback<Object> targetCallback) throws Throwable { Map<String, Object> ret = new HashMap<>(4); //TCC name String actionName = businessAction.name(); BusinessActionContext actionContext = new BusinessActionContext(); actionContext.setXid(xid); //set action name actionContext.setActionName(actionName); //Creating Branch Record String branchId = doTccActionLogStore(method, arguments, businessAction, actionContext); actionContext.setBranchId(branchId); //MDC put branchId MDC.put(RootContext.MDC_KEY_BRANCH_ID, branchId); //set the parameter whose type is BusinessActionContext Class<? >[] types = method.getParameterTypes(); int argIndex = 0; for (Class<? > cls : types) { if (cls.getName().equals(BusinessActionContext.class.getName())) { arguments[argIndex] = actionContext; break; } argIndex++; } //the final parameters of the try method ret.put(Constants.TCC_METHOD_ARGUMENTS, arguments); //the final result ret.put(Constants.TCC_METHOD_RESULT, targetCallback.execute()); return ret; } protected String doTccActionLogStore(Method method, Object[] arguments, TwoPhaseBusinessAction businessAction, BusinessActionContext actionContext) { String actionName = actionContext.getActionName(); String xid = actionContext.getXid(); // Map<String, Object> context = fetchActionRequestContext(method, arguments); context.put(Constants.ACTION_START_TIME, System.currentTimeMillis()); //init business context initBusinessContext(context, method, businessAction); //Init running environment context initFrameworkContext(context); actionContext.setActionContext(context); //init applicationData Map<String, Object> applicationContext = new HashMap<>(4); applicationContext.put(Constants.TCC_ACTION_CONTEXT, context); String applicationContextStr = JSON.toJSONString(applicationContext); try { //registry branch record 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); } } protected void initBusinessContext(Map<String, Object> context, Method method, TwoPhaseBusinessAction businessAction) { if (method ! = null) { //the phase one method name context.put(Constants.PREPARE_METHOD, method.getName()); } if (businessAction ! = null) { //the phase two method name context.put(Constants.COMMIT_METHOD, businessAction.commitMethod()); context.put(Constants.ROLLBACK_METHOD, businessAction.rollbackMethod()); context.put(Constants.ACTION_NAME, businessAction.name()); }}Copy the code

Note that TCC saves commitMethod, rollbackMethod, and request context information at this stage.

This process is basically the same as the AT model and will not be covered for the moment.

The first half of this phase is basically the same as the AT pattern,

This section is for all TCC schemes.

In distributed development, any write operation requires idempotent control, as do TCC’s distributed transactions.



This graph comes from the network, rather lazy do not want to draw their own

Distributed transaction Seata and its three modes, rounding | Meetup# 3 review

TCC for flexible transaction solutions

Principle of Seata

Seata – AT mode

Seata – TCC mode

Seata – Saga mode

Seata – XA mode

TCC ws-transaction principle