optimize: branch register resource only at RM server end

tcc/src/main/java/io/seata/rm/tcc/interceptor/TccActionInterceptorHandler.java

@@ -32,7 +32,6 @@
 import io.seata.integration.tx.api.interceptor.SeataInterceptorPosition;
 import io.seata.integration.tx.api.interceptor.TwoPhaseBusinessActionParam;
 import io.seata.integration.tx.api.interceptor.handler.AbstractProxyInvocationHandler;
-import io.seata.integration.tx.api.remoting.RemotingDesc;
 import io.seata.rm.tcc.api.TwoPhaseBusinessAction;
 import org.slf4j.MDC;
 
@@ -49,12 +48,12 @@ public class TccActionInterceptorHandler extends AbstractProxyInvocationHandler
     private ActionInterceptorHandler actionInterceptorHandler = new ActionInterceptorHandler();
 
     private Set<String> methodsToProxy;
-    private RemotingDesc remotingDesc;
+    private Object targetBean;
 
     private Map<Method, TwoPhaseBusinessAction> parseAnnotationCache = new ConcurrentHashMap<>();
 
-    public TccActionInterceptorHandler(RemotingDesc remotingDesc, Set<String> methodsToProxy) {
-        this.remotingDesc = remotingDesc;
+    public TccActionInterceptorHandler(Object targetBean, Set<String> methodsToProxy) {
+        this.targetBean = targetBean;
         this.methodsToProxy = methodsToProxy;
     }
 
@@ -110,8 +109,8 @@ protected Object doInvoke(InvocationWrapper invocation) throws Throwable {
     private TwoPhaseBusinessAction parseAnnotation(Method methodKey) throws NoSuchMethodException {
         TwoPhaseBusinessAction result = parseAnnotationCache.computeIfAbsent(methodKey, method -> {
             TwoPhaseBusinessAction businessAction = method.getAnnotation(TwoPhaseBusinessAction.class);
-            if (businessAction == null && remotingDesc.getServiceClass() != null) {
-                Set<Class<?>> interfaceClasses = ReflectionUtil.getInterfaces(remotingDesc.getServiceClass());
+            if (businessAction == null && targetBean.getClass() != null) {
+                Set<Class<?>> interfaceClasses = ReflectionUtil.getInterfaces(targetBean.getClass());
                 if (interfaceClasses != null) {
                     for (Class<?> interClass : interfaceClasses) {
                         try {

tcc/src/main/java/io/seata/rm/tcc/interceptor/parser/TccActionInterceptorParser.java

@@ -15,21 +15,21 @@
  */
 package io.seata.rm.tcc.interceptor.parser;
 
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
 import io.seata.common.util.ReflectionUtil;
-import io.seata.integration.tx.api.interceptor.TxBeanParserUtils;
 import io.seata.integration.tx.api.interceptor.handler.ProxyInvocationHandler;
 import io.seata.integration.tx.api.interceptor.parser.DefaultResourceRegisterParser;
 import io.seata.integration.tx.api.interceptor.parser.InterfaceParser;
-import io.seata.integration.tx.api.remoting.RemotingDesc;
-import io.seata.integration.tx.api.remoting.parser.DefaultRemotingParser;
 import io.seata.rm.tcc.api.TwoPhaseBusinessAction;
 import io.seata.rm.tcc.interceptor.TccActionInterceptorHandler;
-
-import java.lang.reflect.Method;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
+import org.springframework.aop.support.AopUtils;
 
 /**
  * @author leezongjie
@@ -38,39 +38,46 @@ public class TccActionInterceptorParser implements InterfaceParser {
 
     @Override
     public ProxyInvocationHandler parserInterfaceToProxy(Object target) {
-        boolean isTxRemotingBean = TxBeanParserUtils.isTxRemotingBean(target, target.toString());
-        if (isTxRemotingBean) {
-            RemotingDesc remotingDesc = DefaultRemotingParser.get().getRemotingBeanDesc(target);
-            if (remotingDesc != null) {
-                if (remotingDesc.isService()) {
-                    DefaultResourceRegisterParser.get().registerResource(target);
-                }
-                if (remotingDesc.isReference()) {
-                    //if it is a tcc remote reference
-                    Set<String> methodsToProxy = tccProxyTargetMethod(remotingDesc);
-                    if (remotingDesc != null && !methodsToProxy.isEmpty()) {
-                        ProxyInvocationHandler proxyInvocationHandler = new TccActionInterceptorHandler(remotingDesc, methodsToProxy);
-                        return proxyInvocationHandler;
-                    }
-                }
+
+        // below only enhance the native business bean.
+        // eliminate without two phase annotation bean.
+        Set<String> methodsToProxy = this.tccProxyTargetMethod(target);
+        if (methodsToProxy.isEmpty()) {
+            return null;
+        }
+
+        // eliminate aop proxy.
+        if (AopUtils.isAopProxy(target)) {
+            return null;
+        }
+
+        // eliminate dubbo etc proxy bean.
+        Field[] fields = ReflectionUtil.getAllFields(target.getClass());
+        for (Field field : fields) {
+            if (field.getGenericType().equals(InvocationHandler.class)) {
+                return null;
             }
         }
-        return null;
+
+        // register resource and enhance with interceptor
+        DefaultResourceRegisterParser.get().registerResource(target);
+        return new TccActionInterceptorHandler(target, methodsToProxy);
     }
 
     /**
      * is TCC proxy-bean/target-bean: LocalTCC , the proxy bean of sofa:reference/dubbo:reference
      *
-     * @param remotingDesc the remoting desc
+     * @param target the target bean
      * @return boolean boolean
      */
-    private Set<String> tccProxyTargetMethod(RemotingDesc remotingDesc) {
-        if (!remotingDesc.isReference() || remotingDesc == null) {
+
+    private Set<String> tccProxyTargetMethod(Object target) {
+        if (target == null) {
             return Collections.emptySet();
         }
         Set<String> methodsToProxy = new HashSet<>();
         //check if it is TCC bean
-        Class<?> tccServiceClazz = remotingDesc.getServiceClass();
+        Class<?> tccServiceClazz = target.getClass();
         Set<Method> methods = new HashSet<>(Arrays.asList(tccServiceClazz.getMethods()));
         Set<Class<?>> interfaceClasses = ReflectionUtil.getInterfaces(tccServiceClazz);
         if (interfaceClasses != null) {

tcc/src/main/java/io/seata/rm/tcc/resource/parser/TccRegisterResourceParser.java

@@ -15,77 +15,66 @@
  */
 package io.seata.rm.tcc.resource.parser;
 
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
 import io.seata.common.exception.FrameworkException;
 import io.seata.common.util.ReflectionUtil;
 import io.seata.integration.tx.api.interceptor.ActionContextUtil;
-import io.seata.integration.tx.api.interceptor.TxBeanParserUtils;
 import io.seata.integration.tx.api.interceptor.parser.RegisterResourceParser;
-import io.seata.integration.tx.api.remoting.RemotingDesc;
-import io.seata.integration.tx.api.remoting.parser.DefaultRemotingParser;
 import io.seata.rm.DefaultResourceManager;
 import io.seata.rm.tcc.TCCResource;
 import io.seata.rm.tcc.api.BusinessActionContext;
 import io.seata.rm.tcc.api.BusinessActionContextParameter;
 import io.seata.rm.tcc.api.TwoPhaseBusinessAction;
 
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Method;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
-
 /**
  * @author leezongjie
  */
 public class TccRegisterResourceParser implements RegisterResourceParser {
 
     @Override
     public void registerResource(Object target) {
-        boolean isTxRemotingBean = TxBeanParserUtils.isTxRemotingBean(target, target.toString());
-        if (isTxRemotingBean) {
-            RemotingDesc remotingDesc = DefaultRemotingParser.get().getRemotingBeanDesc(target);
-            if (remotingDesc != null) {
-                if (remotingDesc.isService()) {
-                    try {
-                        //service bean, registry resource
-                        Class<?> serviceClass = remotingDesc.getServiceClass();
-                        Set<Method> methods = new HashSet<>(Arrays.asList(serviceClass.getMethods()));
-                        Set<Class<?>> interfaceClasses = ReflectionUtil.getInterfaces(serviceClass);
-                        if (interfaceClasses != null) {
-                            for (Class<?> interClass : interfaceClasses) {
-                                methods.addAll(Arrays.asList(interClass.getMethods()));
-                            }
-                        }
-                        Object targetBean = remotingDesc.getTargetBean();
-                        for (Method m : methods) {
-                            TwoPhaseBusinessAction twoPhaseBusinessAction = m.getAnnotation(TwoPhaseBusinessAction.class);
-                            if (twoPhaseBusinessAction != null) {
-                                TCCResource tccResource = new TCCResource();
-                                tccResource.setActionName(twoPhaseBusinessAction.name());
-                                tccResource.setTargetBean(targetBean);
-                                tccResource.setPrepareMethod(m);
-                                tccResource.setCommitMethodName(twoPhaseBusinessAction.commitMethod());
-                                tccResource.setCommitMethod(serviceClass.getMethod(twoPhaseBusinessAction.commitMethod(),
-                                        twoPhaseBusinessAction.commitArgsClasses()));
-                                tccResource.setRollbackMethodName(twoPhaseBusinessAction.rollbackMethod());
-                                tccResource.setRollbackMethod(serviceClass.getMethod(twoPhaseBusinessAction.rollbackMethod(),
-                                        twoPhaseBusinessAction.rollbackArgsClasses()));
-                                // set argsClasses
-                                tccResource.setCommitArgsClasses(twoPhaseBusinessAction.commitArgsClasses());
-                                tccResource.setRollbackArgsClasses(twoPhaseBusinessAction.rollbackArgsClasses());
-                                // set phase two method's keys
-                                tccResource.setPhaseTwoCommitKeys(this.getTwoPhaseArgs(tccResource.getCommitMethod(),
-                                        twoPhaseBusinessAction.commitArgsClasses()));
-                                tccResource.setPhaseTwoRollbackKeys(this.getTwoPhaseArgs(tccResource.getRollbackMethod(),
-                                        twoPhaseBusinessAction.rollbackArgsClasses()));
-                                //registry tcc resource
-                                DefaultResourceManager.get().registerResource(tccResource);
-                            }
-                        }
-                    } catch (Throwable t) {
-                        throw new FrameworkException(t, "parser remoting service error");
-                    }
-                }
+        try {
+            //service bean, registry resource
+            Class<?> serviceClass = target.getClass();
+            this.executeRegisterResource(target, new HashSet<>(Arrays.asList(serviceClass.getMethods())), target.getClass());
+            Set<Class<?>> interfaceClasses = ReflectionUtil.getInterfaces(serviceClass);
+            for (Class<?> interClass : interfaceClasses) {
+                this.executeRegisterResource(target, new HashSet<>(Arrays.asList(interClass.getMethods())), interClass);
+            }
+        } catch (Throwable t) {
+            throw new FrameworkException(t, "parser remoting service error");
+        }
+    }
+
+    private void executeRegisterResource(Object target, Set<Method> methods, Class<?> targetServiceClass) throws NoSuchMethodException {
+        for (Method m : methods) {
+            TwoPhaseBusinessAction twoPhaseBusinessAction = m.getAnnotation(TwoPhaseBusinessAction.class);
+            if (twoPhaseBusinessAction != null) {
+                TCCResource tccResource = new TCCResource();
+                tccResource.setActionName(twoPhaseBusinessAction.name());
+                tccResource.setTargetBean(target);
+                tccResource.setPrepareMethod(m);
+                tccResource.setCommitMethodName(twoPhaseBusinessAction.commitMethod());
+                tccResource.setCommitMethod(targetServiceClass.getMethod(twoPhaseBusinessAction.commitMethod(),
+                        twoPhaseBusinessAction.commitArgsClasses()));
+                tccResource.setRollbackMethodName(twoPhaseBusinessAction.rollbackMethod());
+                tccResource.setRollbackMethod(targetServiceClass.getMethod(twoPhaseBusinessAction.rollbackMethod(),
+                        twoPhaseBusinessAction.rollbackArgsClasses()));
+                // set argsClasses
+                tccResource.setCommitArgsClasses(twoPhaseBusinessAction.commitArgsClasses());
+                tccResource.setRollbackArgsClasses(twoPhaseBusinessAction.rollbackArgsClasses());
+                // set phase two method's keys
+                tccResource.setPhaseTwoCommitKeys(this.getTwoPhaseArgs(tccResource.getCommitMethod(),
+                        twoPhaseBusinessAction.commitArgsClasses()));
+                tccResource.setPhaseTwoRollbackKeys(this.getTwoPhaseArgs(tccResource.getRollbackMethod(),
+                        twoPhaseBusinessAction.rollbackArgsClasses()));
+                //registry tcc resource
+                DefaultResourceManager.get().registerResource(tccResource);
             }
         }
     }