optimized compatibility issues

apache · Feb 20, 2024 · 20514e1 · 20514e1
1 parent c08345e
commit 20514e1
Show file tree

Hide file tree

Showing 7 changed files with 103 additions and 98 deletions.
diff --git a/...o/seata/integration/tx/api/interceptor/handler/GlobalTransactionalInterceptorHandler.java b/...o/seata/integration/tx/api/interceptor/handler/GlobalTransactionalInterceptorHandler.java
@@ -16,14 +16,11 @@
  */
 package io.seata.integration.tx.api.interceptor.handler;
 
-import io.seata.spring.annotation.GlobalLock;
-import io.seata.spring.annotation.GlobalTransactional;
-import io.seata.tm.api.FailureHandler;
 import org.apache.seata.core.model.GlobalLockConfig;
 import org.apache.seata.integration.tx.api.annotation.AspectTransactional;
-import org.apache.seata.integration.tx.api.interceptor.InvocationWrapper;
-import org.apache.seata.integration.tx.api.util.ClassUtils;
-import org.apache.seata.rm.GlobalLockExecutor;
+import org.apache.seata.spring.annotation.GlobalLock;
+import org.apache.seata.spring.annotation.GlobalTransactional;
+import org.apache.seata.tm.api.FailureHandler;
 
 import java.lang.reflect.Method;
 import java.util.Set;
@@ -33,63 +30,38 @@
  */
 public class GlobalTransactionalInterceptorHandler extends org.apache.seata.integration.tx.api.interceptor.handler.GlobalTransactionalInterceptorHandler {
 
-
     public GlobalTransactionalInterceptorHandler(FailureHandler failureHandler, Set<String> methodsToProxy) {
         super(failureHandler, methodsToProxy);
     }
 
-    public GlobalTransactionalInterceptorHandler(FailureHandler failureHandler, Set<String> methodsToProxy, AspectTransactional aspectTransactional) {
+    public GlobalTransactionalInterceptorHandler(FailureHandler failureHandler, Set<String> methodsToProxy,
+        AspectTransactional aspectTransactional) {
         super(failureHandler, methodsToProxy, aspectTransactional);
     }
 
     @Override
-    protected Object doInvoke(InvocationWrapper invocation) throws Throwable {
-        Class<?> targetClass = invocation.getTarget().getClass();
-        Method specificMethod = ClassUtils.getMostSpecificMethod(invocation.getMethod(), targetClass);
-        if (specificMethod != null && !specificMethod.getDeclaringClass().equals(Object.class)) {
-            final GlobalTransactional globalTransactionalAnnotation = getAnnotation(specificMethod, targetClass, GlobalTransactional.class);
-            final GlobalLock globalLockAnnotation = getAnnotation(specificMethod, targetClass, GlobalLock.class);
-            boolean localDisable = disable || (ATOMIC_DEGRADE_CHECK.get() && 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.rollbackForClassName(),
-                                globalTransactionalAnnotation.noRollbackFor(),
-                                globalTransactionalAnnotation.noRollbackForClassName(),
-                                org.apache.seata.tm.api.transaction.Propagation.valueOf(globalTransactionalAnnotation.propagation().name()),
-                                globalTransactionalAnnotation.lockRetryInterval(),
-                                globalTransactionalAnnotation.lockRetryTimes(),
-                                org.apache.seata.common.LockStrategyMode.valueOf(globalTransactionalAnnotation.lockStrategyMode().name()));
-                    } else {
-                        transactional = this.aspectTransactional;
-                    }
-                    return handleGlobalTransaction(invocation, transactional);
-                } else if (globalLockAnnotation != null) {
-                    return handleGlobalLock(invocation, globalLockAnnotation);
-                }
-            }
+    public GlobalLockConfig getGlobalLockConfig(Method method, Class<?> targetClass) {
+        final GlobalLock globalLockAnno = getAnnotation(method, targetClass, GlobalLock.class);
+        if (globalLockAnno != null) {
+            GlobalLockConfig config = new GlobalLockConfig();
+            config.setLockRetryInterval(globalLockAnno.lockRetryInterval());
+            config.setLockRetryTimes(globalLockAnno.lockRetryTimes());
+            return config;
+        } else {
+            return null;
         }
-        return invocation.proceed();
     }
 
-
-    private Object handleGlobalLock(final InvocationWrapper methodInvocation, final GlobalLock globalLockAnno) throws Throwable {
-        return globalLockTemplate.execute(new GlobalLockExecutor() {
-            @Override
-            public Object execute() throws Throwable {
-                return methodInvocation.proceed();
-            }
-
-            @Override
-            public GlobalLockConfig getGlobalLockConfig() {
-                GlobalLockConfig config = new GlobalLockConfig();
-                config.setLockRetryInterval(globalLockAnno.lockRetryInterval());
-                config.setLockRetryTimes(globalLockAnno.lockRetryTimes());
-                return config;
-            }
-        });
+    @Override
+    public AspectTransactional getAspectTransactional(Method method, Class<?> targetClass) {
+        final GlobalTransactional globalTransactionalAnnotation =
+            getAnnotation(method, targetClass, GlobalTransactional.class);
+        return globalTransactionalAnnotation != null ? new AspectTransactional(
+            globalTransactionalAnnotation.timeoutMills(), globalTransactionalAnnotation.name(),
+            globalTransactionalAnnotation.rollbackFor(), globalTransactionalAnnotation.rollbackForClassName(),
+            globalTransactionalAnnotation.noRollbackFor(), globalTransactionalAnnotation.noRollbackForClassName(),
+            globalTransactionalAnnotation.propagation(), globalTransactionalAnnotation.lockRetryInterval(),
+            globalTransactionalAnnotation.lockRetryTimes(), globalTransactionalAnnotation.lockStrategyMode()) : null;
     }
-}
+
+}
diff --git a/.../io/seata/integration/tx/api/interceptor/parser/GlobalTransactionalInterceptorParser.java b/.../io/seata/integration/tx/api/interceptor/parser/GlobalTransactionalInterceptorParser.java
@@ -16,9 +16,12 @@
  */
 package io.seata.integration.tx.api.interceptor.parser;
 
+import io.seata.integration.tx.api.interceptor.handler.GlobalTransactionalInterceptorHandler;
 import io.seata.spring.annotation.GlobalLock;
 import io.seata.spring.annotation.GlobalTransactional;
 import org.apache.seata.common.util.CollectionUtils;
+import org.apache.seata.integration.tx.api.interceptor.handler.ProxyInvocationHandler;
+import org.apache.seata.tm.api.FailureHandlerHolder;
 
 import java.lang.reflect.Method;
 
@@ -33,24 +36,21 @@ protected boolean existsAnnotation(Class<?>... classes) {
                     continue;
                 }
                 GlobalTransactional trxAnnoOld = clazz.getAnnotation(GlobalTransactional.class);
-                org.apache.seata.spring.annotation.GlobalTransactional trxAnnoNew = clazz.getAnnotation(org.apache.seata.spring.annotation.GlobalTransactional.class);
 
-                if (trxAnnoOld != null || trxAnnoNew != null) {
+                if (trxAnnoOld != null) {
                     return true;
                 }
                 Method[] methods = clazz.getMethods();
                 for (Method method : methods) {
                     trxAnnoOld = method.getAnnotation(GlobalTransactional.class);
-                    trxAnnoNew = method.getAnnotation(org.apache.seata.spring.annotation.GlobalTransactional.class);
-                    if (trxAnnoOld != null || trxAnnoNew != null) {
+                    if (trxAnnoOld != null) {
                         methodsToProxy.add(method.getName());
                         result = true;
                     }
 
                     GlobalLock lockAnnoOld = method.getAnnotation(GlobalLock.class);
-                    org.apache.seata.spring.annotation.GlobalLock lockAnnoNew = method.getAnnotation(org.apache.seata.spring.annotation.GlobalLock.class);
 
-                    if (lockAnnoOld != null || lockAnnoNew != null) {
+                    if (lockAnnoOld != null) {
                         methodsToProxy.add(method.getName());
                         result = true;
                     }
@@ -59,4 +59,10 @@ protected boolean existsAnnotation(Class<?>... classes) {
         }
         return result;
     }
+
+    @Override
+    public ProxyInvocationHandler createProxyInvocationHandler(){
+        return new GlobalTransactionalInterceptorHandler(FailureHandlerHolder.getFailureHandler(), methodsToProxy);
+    }
+
 }
diff --git a/.../META-INF/services/org.apache.seata.integration.tx.api.interceptor.parser.InterfaceParser b/.../META-INF/services/org.apache.seata.integration.tx.api.interceptor.parser.InterfaceParser
@@ -0,0 +1 @@
+io.seata.integration.tx.api.interceptor.parser.GlobalTransactionalInterceptorParser
diff --git a/...g/apache/seata/integration/tx/api/interceptor/handler/AbstractProxyInvocationHandler.java b/...g/apache/seata/integration/tx/api/interceptor/handler/AbstractProxyInvocationHandler.java
@@ -16,14 +16,25 @@
  */
 package org.apache.seata.integration.tx.api.interceptor.handler;
 
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.Optional;
 import org.apache.seata.common.util.CollectionUtils;
+import org.apache.seata.core.model.GlobalLockConfig;
+import org.apache.seata.integration.tx.api.annotation.AspectTransactional;
 import org.apache.seata.integration.tx.api.interceptor.InvocationWrapper;
 
 
 public abstract class AbstractProxyInvocationHandler implements ProxyInvocationHandler {
 
     protected abstract Object doInvoke(InvocationWrapper invocation) throws Throwable;
 
+    protected abstract AspectTransactional getAspectTransactional(Method method, Class<?> targetClass);
+
+
+    protected abstract GlobalLockConfig getGlobalLockConfig(Method method, Class<?> targetClass);
+
+
     protected int order = Integer.MAX_VALUE;
 
     @Override
@@ -34,6 +45,11 @@ public Object invoke(InvocationWrapper invocation) throws Throwable {
         return doInvoke(invocation);
     }
 
+    protected <T extends Annotation> T getAnnotation(Method method, Class<?> targetClass, Class<T> annotationClass) {
+        return Optional.ofNullable(method).map(m -> m.getAnnotation(annotationClass))
+            .orElse(Optional.ofNullable(targetClass).map(t -> t.getAnnotation(annotationClass)).orElse(null));
+    }
+
     @Override
     public void setOrder(int order) {
         this.order = order;

diff --git a/...e/seata/integration/tx/api/interceptor/handler/GlobalTransactionalInterceptorHandler.java b/...e/seata/integration/tx/api/interceptor/handler/GlobalTransactionalInterceptorHandler.java
@@ -17,6 +17,14 @@
 package org.apache.seata.integration.tx.api.interceptor.handler;
 
 import com.google.common.eventbus.Subscribe;
+import org.apache.seata.tm.api.GlobalTransaction;
+import java.lang.reflect.Method;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
 import org.apache.seata.common.exception.ShouldNeverHappenException;
 import org.apache.seata.common.thread.NamedThreadFactory;
 import org.apache.seata.common.util.StringUtils;
@@ -42,7 +50,6 @@
 import org.apache.seata.tm.TransactionManagerHolder;
 import org.apache.seata.tm.api.FailureHandler;
 import org.apache.seata.tm.api.FailureHandlerHolder;
-import org.apache.seata.tm.api.GlobalTransaction;
 import org.apache.seata.tm.api.TransactionalExecutor;
 import org.apache.seata.tm.api.TransactionalTemplate;
 import org.apache.seata.tm.api.transaction.NoRollbackRule;
@@ -51,15 +58,6 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Method;
-import java.util.LinkedHashSet;
-import java.util.Optional;
-import java.util.Set;
-import java.util.concurrent.ScheduledThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-
 import static org.apache.seata.common.DefaultValues.DEFAULT_DISABLE_GLOBAL_TRANSACTION;
 import static org.apache.seata.common.DefaultValues.DEFAULT_GLOBAL_TRANSACTION_TIMEOUT;
 import static org.apache.seata.common.DefaultValues.DEFAULT_TM_DEGRADE_CHECK;
@@ -76,15 +74,15 @@ public class GlobalTransactionalInterceptorHandler extends AbstractProxyInvocati
     private static final Logger LOGGER = LoggerFactory.getLogger(GlobalTransactionalInterceptorHandler.class);
 
     private final TransactionalTemplate transactionalTemplate = new TransactionalTemplate();
-    protected final GlobalLockTemplate globalLockTemplate = new GlobalLockTemplate();
+    private final GlobalLockTemplate globalLockTemplate = new GlobalLockTemplate();
 
     private Set<String> methodsToProxy;
 
-    protected volatile boolean disable;
-    protected static final AtomicBoolean ATOMIC_DEGRADE_CHECK = new AtomicBoolean(false);
-    protected static volatile Integer degradeNum = 0;
+    private volatile boolean disable;
+    private static final AtomicBoolean ATOMIC_DEGRADE_CHECK = new AtomicBoolean(false);
+    private static volatile Integer degradeNum = 0;
     private static volatile Integer reachNum = 0;
-    protected static int degradeCheckAllowTimes;
+    private static int degradeCheckAllowTimes;
     protected AspectTransactional aspectTransactional;
     private static int degradeCheckPeriod;
 
@@ -144,22 +142,14 @@ protected Object doInvoke(InvocationWrapper invocation) throws Throwable {
         Class<?> targetClass = invocation.getTarget().getClass();
         Method specificMethod = ClassUtils.getMostSpecificMethod(invocation.getMethod(), targetClass);
         if (specificMethod != null && !specificMethod.getDeclaringClass().equals(Object.class)) {
-            final GlobalTransactional globalTransactionalAnnotation = getAnnotation(specificMethod, targetClass, GlobalTransactional.class);
-            final GlobalLock globalLockAnnotation = getAnnotation(specificMethod, targetClass, GlobalLock.class);
+            final AspectTransactional globalTransactionalAnnotation = getAspectTransactional(specificMethod, targetClass);
+            final GlobalLockConfig globalLockAnnotation = getGlobalLockConfig(specificMethod, targetClass);
             boolean localDisable = disable || (ATOMIC_DEGRADE_CHECK.get() && 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.rollbackForClassName(),
-                                globalTransactionalAnnotation.noRollbackFor(),
-                                globalTransactionalAnnotation.noRollbackForClassName(),
-                                globalTransactionalAnnotation.propagation(),
-                                globalTransactionalAnnotation.lockRetryInterval(),
-                                globalTransactionalAnnotation.lockRetryTimes(),
-                                globalTransactionalAnnotation.lockStrategyMode());
+                        transactional = globalTransactionalAnnotation;
                     } else {
                         transactional = this.aspectTransactional;
                     }
@@ -173,7 +163,7 @@ protected Object doInvoke(InvocationWrapper invocation) throws Throwable {
     }
 
 
-    protected Object handleGlobalLock(final InvocationWrapper methodInvocation, final GlobalLock globalLockAnno) throws Throwable {
+    private Object handleGlobalLock(final InvocationWrapper methodInvocation, final GlobalLockConfig globalLockAnno) throws Throwable {
         return globalLockTemplate.execute(new GlobalLockExecutor() {
             @Override
             public Object execute() throws Throwable {
@@ -182,16 +172,13 @@ public Object execute() throws Throwable {
 
             @Override
             public GlobalLockConfig getGlobalLockConfig() {
-                GlobalLockConfig config = new GlobalLockConfig();
-                config.setLockRetryInterval(globalLockAnno.lockRetryInterval());
-                config.setLockRetryTimes(globalLockAnno.lockRetryTimes());
-                return config;
+                return globalLockAnno;
             }
         });
     }
 
-    protected Object handleGlobalTransaction(final InvocationWrapper methodInvocation,
-                                             final AspectTransactional aspectTransactional) throws Throwable {
+    Object handleGlobalTransaction(final InvocationWrapper methodInvocation,
+                                   final AspectTransactional aspectTransactional) throws Throwable {
         boolean succeed = true;
         try {
             return transactionalTemplate.execute(new TransactionalExecutor() {
@@ -286,10 +273,30 @@ public TransactionInfo getTransactionInfo() {
         }
     }
 
+    @Override
+    public GlobalLockConfig getGlobalLockConfig(Method method, Class<?> targetClass) {
+        final GlobalLock globalLockAnno = getAnnotation(method, targetClass, GlobalLock.class);
+        if (globalLockAnno != null) {
+            GlobalLockConfig config = new GlobalLockConfig();
+            config.setLockRetryInterval(globalLockAnno.lockRetryInterval());
+            config.setLockRetryTimes(globalLockAnno.lockRetryTimes());
+            return config;
+        } else {
+            return null;
+        }
+    }
 
-    public <T extends Annotation> T getAnnotation(Method method, Class<?> targetClass, Class<T> annotationClass) {
-        return Optional.ofNullable(method).map(m -> m.getAnnotation(annotationClass))
-                .orElse(Optional.ofNullable(targetClass).map(t -> t.getAnnotation(annotationClass)).orElse(null));
+    @Override
+    public AspectTransactional getAspectTransactional(Method method, Class<?> targetClass) {
+        final GlobalTransactional globalTransactionalAnnotation =
+            getAnnotation(method, targetClass, GlobalTransactional.class);
+        return globalTransactionalAnnotation != null ?
+            new AspectTransactional(globalTransactionalAnnotation.timeoutMills(), globalTransactionalAnnotation.name(),
+                globalTransactionalAnnotation.rollbackFor(), globalTransactionalAnnotation.rollbackForClassName(),
+                globalTransactionalAnnotation.noRollbackFor(), globalTransactionalAnnotation.noRollbackForClassName(),
+                globalTransactionalAnnotation.propagation(), globalTransactionalAnnotation.lockRetryInterval(),
+                globalTransactionalAnnotation.lockRetryTimes(), globalTransactionalAnnotation.lockStrategyMode()) :
+            null;
     }
 
     private String formatMethod(Method method) {

diff --git a/...che/seata/integration/tx/api/interceptor/parser/GlobalTransactionalInterceptorParser.java b/...che/seata/integration/tx/api/interceptor/parser/GlobalTransactionalInterceptorParser.java
@@ -51,14 +51,18 @@ public ProxyInvocationHandler parserInterfaceToProxy(Object target, String objec
         Class<?>[] interfacesIfJdk = DefaultTargetClassParser.get().findInterfaces(target);
 
         if (existsAnnotation(serviceInterface) || existsAnnotation(interfacesIfJdk)) {
-            ProxyInvocationHandler proxyInvocationHandler = new GlobalTransactionalInterceptorHandler(FailureHandlerHolder.getFailureHandler(), methodsToProxy);
+            ProxyInvocationHandler proxyInvocationHandler = createProxyInvocationHandler();
             ConfigurationCache.addConfigListener(ConfigurationKeys.DISABLE_GLOBAL_TRANSACTION, (ConfigurationChangeListener) proxyInvocationHandler);
             return proxyInvocationHandler;
         }
 
         return null;
     }
 
+    protected ProxyInvocationHandler createProxyInvocationHandler(){
+        return new GlobalTransactionalInterceptorHandler(FailureHandlerHolder.getFailureHandler(), methodsToProxy);
+    }
+
     @Override
     public IfNeedEnhanceBean parseIfNeedEnhancement(Class<?> beanClass) {
         Set<Class<?>> interfaceClasses = ReflectionUtil.getInterfaces(beanClass);

diff --git a/...src/main/java/org/apache/seata/integration/tx/api/interceptor/parser/InterfaceParser.java b/...src/main/java/org/apache/seata/integration/tx/api/interceptor/parser/InterfaceParser.java
@@ -25,5 +25,4 @@ public interface InterfaceParser {
 
     IfNeedEnhanceBean parseIfNeedEnhancement(Class<?> beanClass);
 
-
 }
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		io.seata.integration.tx.api.interceptor.parser.GlobalTransactionalInterceptorParser
Original file line number	Diff line number	Diff line change
Expand Up		@@ -25,5 +25,4 @@ public interface InterfaceParser {

		IfNeedEnhanceBean parseIfNeedEnhancement(Class<?> beanClass);


		}