From 20514e130aa508f4c895ce4e8ee411619bc8e3be Mon Sep 17 00:00:00 2001 From: jianbin Date: Tue, 20 Feb 2024 18:21:50 +0800 Subject: [PATCH] optimized compatibility issues --- ...GlobalTransactionalInterceptorHandler.java | 80 ++++++------------- .../GlobalTransactionalInterceptorParser.java | 18 +++-- ....tx.api.interceptor.parser.InterfaceParser | 1 + .../AbstractProxyInvocationHandler.java | 16 ++++ ...GlobalTransactionalInterceptorHandler.java | 79 +++++++++--------- .../GlobalTransactionalInterceptorParser.java | 6 +- .../interceptor/parser/InterfaceParser.java | 1 - 7 files changed, 103 insertions(+), 98 deletions(-) create mode 100644 compatible/src/main/resources/META-INF/services/org.apache.seata.integration.tx.api.interceptor.parser.InterfaceParser diff --git a/compatible/src/main/java/io/seata/integration/tx/api/interceptor/handler/GlobalTransactionalInterceptorHandler.java b/compatible/src/main/java/io/seata/integration/tx/api/interceptor/handler/GlobalTransactionalInterceptorHandler.java index 2882ec1fa97..4609cfa6d8e 100644 --- a/compatible/src/main/java/io/seata/integration/tx/api/interceptor/handler/GlobalTransactionalInterceptorHandler.java +++ b/compatible/src/main/java/io/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 methodsToProxy) { super(failureHandler, methodsToProxy); } - public GlobalTransactionalInterceptorHandler(FailureHandler failureHandler, Set methodsToProxy, AspectTransactional aspectTransactional) { + public GlobalTransactionalInterceptorHandler(FailureHandler failureHandler, Set 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; } -} + +} \ No newline at end of file diff --git a/compatible/src/main/java/io/seata/integration/tx/api/interceptor/parser/GlobalTransactionalInterceptorParser.java b/compatible/src/main/java/io/seata/integration/tx/api/interceptor/parser/GlobalTransactionalInterceptorParser.java index 485034e6e3f..5772ca1b9ae 100644 --- a/compatible/src/main/java/io/seata/integration/tx/api/interceptor/parser/GlobalTransactionalInterceptorParser.java +++ b/compatible/src/main/java/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/compatible/src/main/resources/META-INF/services/org.apache.seata.integration.tx.api.interceptor.parser.InterfaceParser b/compatible/src/main/resources/META-INF/services/org.apache.seata.integration.tx.api.interceptor.parser.InterfaceParser new file mode 100644 index 00000000000..b9e1043dc3e --- /dev/null +++ b/compatible/src/main/resources/META-INF/services/org.apache.seata.integration.tx.api.interceptor.parser.InterfaceParser @@ -0,0 +1 @@ +io.seata.integration.tx.api.interceptor.parser.GlobalTransactionalInterceptorParser \ No newline at end of file diff --git a/integration-tx-api/src/main/java/org/apache/seata/integration/tx/api/interceptor/handler/AbstractProxyInvocationHandler.java b/integration-tx-api/src/main/java/org/apache/seata/integration/tx/api/interceptor/handler/AbstractProxyInvocationHandler.java index f6c3a533859..2e301fce3cf 100644 --- a/integration-tx-api/src/main/java/org/apache/seata/integration/tx/api/interceptor/handler/AbstractProxyInvocationHandler.java +++ b/integration-tx-api/src/main/java/org/apache/seata/integration/tx/api/interceptor/handler/AbstractProxyInvocationHandler.java @@ -16,7 +16,12 @@ */ 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; @@ -24,6 +29,12 @@ public abstract class AbstractProxyInvocationHandler implements ProxyInvocationH 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 getAnnotation(Method method, Class targetClass, Class 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/integration-tx-api/src/main/java/org/apache/seata/integration/tx/api/interceptor/handler/GlobalTransactionalInterceptorHandler.java b/integration-tx-api/src/main/java/org/apache/seata/integration/tx/api/interceptor/handler/GlobalTransactionalInterceptorHandler.java index 03f618ab51d..9fd41dad2aa 100644 --- a/integration-tx-api/src/main/java/org/apache/seata/integration/tx/api/interceptor/handler/GlobalTransactionalInterceptorHandler.java +++ b/integration-tx-api/src/main/java/org/apache/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 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 getAnnotation(Method method, Class targetClass, Class 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/integration-tx-api/src/main/java/org/apache/seata/integration/tx/api/interceptor/parser/GlobalTransactionalInterceptorParser.java b/integration-tx-api/src/main/java/org/apache/seata/integration/tx/api/interceptor/parser/GlobalTransactionalInterceptorParser.java index beacda7de11..ea889be604a 100644 --- a/integration-tx-api/src/main/java/org/apache/seata/integration/tx/api/interceptor/parser/GlobalTransactionalInterceptorParser.java +++ b/integration-tx-api/src/main/java/org/apache/seata/integration/tx/api/interceptor/parser/GlobalTransactionalInterceptorParser.java @@ -51,7 +51,7 @@ 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; } @@ -59,6 +59,10 @@ public ProxyInvocationHandler parserInterfaceToProxy(Object target, String objec return null; } + protected ProxyInvocationHandler createProxyInvocationHandler(){ + return new GlobalTransactionalInterceptorHandler(FailureHandlerHolder.getFailureHandler(), methodsToProxy); + } + @Override public IfNeedEnhanceBean parseIfNeedEnhancement(Class beanClass) { Set> interfaceClasses = ReflectionUtil.getInterfaces(beanClass); diff --git a/integration-tx-api/src/main/java/org/apache/seata/integration/tx/api/interceptor/parser/InterfaceParser.java b/integration-tx-api/src/main/java/org/apache/seata/integration/tx/api/interceptor/parser/InterfaceParser.java index d0e843f0456..063d2380bed 100644 --- a/integration-tx-api/src/main/java/org/apache/seata/integration/tx/api/interceptor/parser/InterfaceParser.java +++ b/integration-tx-api/src/main/java/org/apache/seata/integration/tx/api/interceptor/parser/InterfaceParser.java @@ -25,5 +25,4 @@ public interface InterfaceParser { IfNeedEnhanceBean parseIfNeedEnhancement(Class beanClass); - }