重构，将拦截器的ProceedingJoinPoint的相关调用重构到MethodContext类中

徐烜
1 parent 669aee46
Showing 26 changed files with 217 additions and 174 deletions
tcc-transaction-api/src/main/java/org/mengyun/tcctransaction/api/annotation/Compensable.java
tcc-transaction-api/target/classes/org/mengyun/tcctransaction/api/annotation/Compensable.class
tcc-transaction-core/src/main/java/org/mengyun/tcctransaction/Transaction.java
tcc-transaction-core/src/main/java/org/mengyun/tcctransaction/interceptor/CompensableTransactionInterceptor.java
tcc-transaction-core/src/main/java/org/mengyun/tcctransaction/interceptor/ResourceCoordinatorInterceptor.java
tcc-transaction-core/src/main/java/org/mengyun/tcctransaction/interceptor/invoke/MethodContext.java
tcc-transaction-core/src/main/java/org/mengyun/tcctransaction/interceptor/utils/MethodType.java → tcc-transaction-core/src/main/java/org/mengyun/tcctransaction/interceptor/invoke/MethodType.java
tcc-transaction-core/src/main/java/org/mengyun/tcctransaction/interceptor/Participant.java → tcc-transaction-core/src/main/java/org/mengyun/tcctransaction/interceptor/invoke/Participant.java
tcc-transaction-core/src/main/java/org/mengyun/tcctransaction/interceptor/utils/CompensableMethodUtils.java
tcc-transaction-core/src/main/java/org/mengyun/tcctransaction/recover/RecoverConfig.java
tcc-transaction-core/src/main/java/org/mengyun/tcctransaction/repository/impl/CachableTransactionRepository.java
tcc-transaction-core/target/classes/org/mengyun/tcctransaction/Transaction.class
tcc-transaction-core/target/classes/org/mengyun/tcctransaction/interceptor/CompensableTransactionInterceptor$1.class
tcc-transaction-core/target/classes/org/mengyun/tcctransaction/interceptor/CompensableTransactionInterceptor.class
tcc-transaction-core/target/classes/org/mengyun/tcctransaction/interceptor/Participant.class
tcc-transaction-core/target/classes/org/mengyun/tcctransaction/interceptor/ResourceCoordinatorInterceptor$1.class
tcc-transaction-core/target/classes/org/mengyun/tcctransaction/interceptor/ResourceCoordinatorInterceptor.class
tcc-transaction-core/target/classes/org/mengyun/tcctransaction/interceptor/utils/CompensableMethodUtils.class
tcc-transaction-core/target/classes/org/mengyun/tcctransaction/interceptor/utils/MethodType.class
tcc-transaction-core/target/classes/org/mengyun/tcctransaction/repository/impl/CachableTransactionRepository.class
@@ -12,8 +12,12 @@ import java.lang.annotation.Target;
 @Retention(RetentionPolicy.RUNTIME)
 @Target({ ElementType.METHOD })
 public @interface Compensable {
-
+    /** confirm方法名 */
     public String confirmMethod() default "";
-
+    /** cancel方法名 */
     public String cancelMethod() default "";
+    /** 是否异步调用confirm */
+    public boolean asyncConfirm() default false;
+    /** 是否异步调用cancel */
+    public boolean asyncCancel() default false;
 }
@@ -3,7 +3,7 @@ package org.mengyun.tcctransaction;
 import org.mengyun.tcctransaction.api.TransactionContext;
 import org.mengyun.tcctransaction.api.TransactionStatus;
 import org.mengyun.tcctransaction.api.TransactionXid;
-import org.mengyun.tcctransaction.interceptor.Participant;
+import org.mengyun.tcctransaction.interceptor.invoke.Participant;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
  
 package org.mengyun.tcctransaction.interceptor;
  
 import org.aspectj.lang.ProceedingJoinPoint;
-import org.aspectj.lang.reflect.MethodSignature;
+import org.mengyun.tcctransaction.TransactionManager;
 import org.mengyun.tcctransaction.api.TransactionContext;
 import org.mengyun.tcctransaction.api.TransactionStatus;
 import org.mengyun.tcctransaction.exception.NoExistedTransactionException;
 import org.mengyun.tcctransaction.exception.OptimisticLockException;
-import org.mengyun.tcctransaction.interceptor.utils.CompensableMethodUtils;
-import org.mengyun.tcctransaction.interceptor.utils.MethodType;
+import org.mengyun.tcctransaction.interceptor.invoke.MethodContext;
+import org.mengyun.tcctransaction.interceptor.invoke.MethodType;
 import org.mengyun.tcctransaction.interceptor.utils.ReflectionUtils;
 import org.mengyun.tcctransaction.support.TransactionConfigurator;
 import org.slf4j.Logger;
@@ -35,40 +35,39 @@ public class CompensableTransactionInterceptor {
      * @throws Throwable
      */
     public Object interceptCompensableMethod(ProceedingJoinPoint pjp) throws Throwable {
-
-        // 从拦截方法的参数中获取事务上下文
-        TransactionContext transactionContext = CompensableMethodUtils.getTransactionContextFromArgs(pjp.getArgs());
-
-        // 计算可补偿事务方法类型
-        MethodType methodType = CompensableMethodUtils.calculateMethodType(transactionContext, true);
+        // 创建方法上下文
+        MethodContext compensableMethodContext = new MethodContext(pjp);
+        // 获取methodType
+        MethodType methodType = compensableMethodContext.getMethodType();
  
         LOG.debug("==>interceptCompensableMethod methodType:" + methodType.toString());
  
         switch (methodType) {
             case ROOT:
-                return rootMethodProceed(pjp); // 主事务方法的处理
+                return rootMethodProceed(compensableMethodContext); // 主事务方法的处理
             case PROVIDER:
-                return providerMethodProceed(pjp, transactionContext); // 服务提供者事务方法处理
+                return providerMethodProceed(compensableMethodContext); // 服务提供者事务方法处理
             default:
-                return pjp.proceed(); // 其他的方法都是直接执行
+                return compensableMethodContext.proceed(); // 其他的方法都是直接执行
         }
     }
  
     /**
      * 主事务方法的处理.
-     * @param pjp
+     * @param compensableMethodContext
      * @throws Throwable
      */
-    private Object rootMethodProceed(ProceedingJoinPoint pjp) throws Throwable {
+    private Object rootMethodProceed(MethodContext compensableMethodContext) throws Throwable {
         LOG.debug("==>rootMethodProceed");
  
-        transactionConfigurator.getTransactionManager().begin(); // 事务开始（创建事务日志记录，并在当前线程缓存该事务日志记录）
+        TransactionManager transactionManager = transactionConfigurator.getTransactionManager();
+        transactionManager.begin(); // 事务开始（创建事务日志记录，并在当前线程缓存该事务日志记录）
  
         Object returnValue = null; // 返回值
         try {
  
             LOG.debug("==>rootMethodProceed try begin");
-            returnValue = pjp.proceed();  // Try (开始执行被拦截的方法)
+            returnValue = compensableMethodContext.proceed();  // Try (开始执行被拦截的方法)
             LOG.debug("==>rootMethodProceed try end");
  
         } catch (OptimisticLockException e) {
@@ -76,25 +75,25 @@ public class CompensableTransactionInterceptor {
             throw e; //do not rollback, waiting for recovery job
         } catch (Throwable tryingException) {
             LOG.warn("compensable transaction trying failed.", tryingException);
-            transactionConfigurator.getTransactionManager().rollback();
+            transactionManager.rollback();
             throw tryingException;
         }
  
         LOG.info("===>rootMethodProceed begin commit()");
-        transactionConfigurator.getTransactionManager().commit(); // Try检验正常后提交(事务管理器在控制提交)
+        transactionManager.commit(); // Try检验正常后提交(事务管理器在控制提交)
  
         return returnValue;
     }
  
     /**
      * 服务提供者事务方法处理.
-     * @param pjp
-     * @param transactionContext
+     * @param compensableMethodContext
      * @throws Throwable
      */
-    private Object providerMethodProceed(ProceedingJoinPoint pjp, TransactionContext transactionContext) throws Throwable {
+    private Object providerMethodProceed(MethodContext compensableMethodContext) throws Throwable {
+        TransactionContext transactionContext = compensableMethodContext.getTransactionContext();
  
-        LOG.debug("==>providerMethodProceed transactionStatus:" + TransactionStatus.valueOf(transactionContext.getStatus()).toString());
+        LOG.debug("==>providerMethodProceed transactionStatus:{}", TransactionStatus.valueOf(transactionContext.getStatus()).toString());
  
         switch (TransactionStatus.valueOf(transactionContext.getStatus())) {
             case TRYING:
@@ -102,7 +101,7 @@ public class CompensableTransactionInterceptor {
                 // 基于全局事务ID扩展创建新的分支事务，并存于当前线程的事务局部变量中.
                 transactionConfigurator.getTransactionManager().propagationNewBegin(transactionContext);
                 LOG.debug("==>providerMethodProceed try end");
-                return pjp.proceed();
+                return compensableMethodContext.proceed();
             case CONFIRMING:
                 try {
                     LOG.debug("==>providerMethodProceed confirm begin");
@@ -126,8 +125,7 @@ public class CompensableTransactionInterceptor {
                 break;
         }
  
-        Method method = ((MethodSignature) (pjp.getSignature())).getMethod();
-
+        Method method = compensableMethodContext.getMethod();
         return ReflectionUtils.getNullValue(method.getReturnType());
     }
  
 package org.mengyun.tcctransaction.interceptor;
  
 import org.aspectj.lang.ProceedingJoinPoint;
-import org.aspectj.lang.reflect.MethodSignature;
 import org.mengyun.tcctransaction.Transaction;
 import org.mengyun.tcctransaction.api.TransactionContext;
 import org.mengyun.tcctransaction.api.TransactionStatus;
 import org.mengyun.tcctransaction.api.TransactionXid;
 import org.mengyun.tcctransaction.api.UuidUtils;
-import org.mengyun.tcctransaction.api.annotation.Compensable;
 import org.mengyun.tcctransaction.interceptor.invoke.InvocationContext;
+import org.mengyun.tcctransaction.interceptor.invoke.MethodContext;
+import org.mengyun.tcctransaction.interceptor.invoke.Participant;
 import org.mengyun.tcctransaction.interceptor.invoke.Terminator;
-import org.mengyun.tcctransaction.interceptor.utils.CompensableMethodUtils;
-import org.mengyun.tcctransaction.interceptor.utils.MethodType;
+import org.mengyun.tcctransaction.interceptor.invoke.MethodType;
 import org.mengyun.tcctransaction.interceptor.utils.ReflectionUtils;
 import org.mengyun.tcctransaction.repository.TransactionRepository;
 import org.mengyun.tcctransaction.support.TransactionConfigurator;
@@ -40,6 +39,9 @@ public class ResourceCoordinatorInterceptor {
      * @throws Throwable
      */
     public Object interceptTransactionContextMethod(ProceedingJoinPoint pjp) throws Throwable {
+        // 创建方法上下文
+        MethodContext methodContext = new MethodContext(pjp);
+
         LOG.debug("==>ResourceCoordinatorInterceptor interceptTransactionContextMethod(ProceedingJoinPoint pjp)");
         // 获取当前事务
         Transaction transaction = transactionConfigurator.getTransactionManager().getCurrentTransaction();
@@ -47,23 +49,19 @@ public class ResourceCoordinatorInterceptor {
         // Trying(判断是否Try阶段的事务)
         if (transaction != null && transaction.getStatus().equals(TransactionStatus.TRYING)) {
             LOG.debug("==>TransactionStatus:" + transaction.getStatus().toString());
-            // 从参数获取事务上下文
-            TransactionContext transactionContext = CompensableMethodUtils.getTransactionContextFromArgs(pjp.getArgs());
-            // 获取事务补偿注解
-            Compensable compensable = getCompensable(pjp);
-            // 计算方法类型
-            MethodType methodType = CompensableMethodUtils.calculateMethodType(transactionContext, compensable != null ? true : false);
+            // 获取方法类型
+            MethodType methodType = methodContext.getMethodType();
             LOG.debug("==>methodType:" + methodType.toString());
  
             switch (methodType) {
                 case ROOT:
-                    generateAndEnlistRootParticipant(pjp); // 生成和登记根参与者
+                    generateAndEnlistRootParticipant(methodContext); // 生成和登记根参与者
                     break;
                 case CONSUMER:
-                    generateAndEnlistConsumerParticipant(pjp); // 生成并登记消费者的参与者
+                    generateAndEnlistConsumerParticipant(methodContext); // 生成并登记消费者的参与者
                     break;
                 case PROVIDER:
-                    generateAndEnlistProviderParticipant(pjp); // 生成并登记服务提供者的参与者
+                    generateAndEnlistProviderParticipant(methodContext); // 生成并登记服务提供者的参与者
                     break;
             }
         }
@@ -74,24 +72,26 @@ public class ResourceCoordinatorInterceptor {
  
     /**
      * 生成和登记根参与者.
-     * @param pjp
+     * @param methodContext
      * @return
      */
-    private Participant generateAndEnlistRootParticipant(ProceedingJoinPoint pjp) {
+    private Participant generateAndEnlistRootParticipant(MethodContext methodContext) {
         LOG.debug("==>ResourceCoordinatorInterceptor generateAndEnlistRootParticipant(ProceedingJoinPoint pjp)");
-        MethodSignature signature = (MethodSignature) pjp.getSignature();
-        Method method = signature.getMethod();
-        Compensable compensable = getCompensable(pjp);
-        String confirmMethodName = compensable.confirmMethod(); // 确认方法
-        String cancelMethodName = compensable.cancelMethod(); // 取消方法
+        String confirmMethodName = methodContext.getConfirmMethodName(); // 确认方法
+        String cancelMethodName = methodContext.getCancelMethodName(); // 取消方法
  
         Transaction transaction = transactionConfigurator.getTransactionManager().getCurrentTransaction(); // 获取当前事务
-
         TransactionXid xid = new TransactionXid(transaction.getXid().getGlobalTransactionId()); // 获取事务Xid
         LOG.debug("==>TransactionXid：" + UuidUtils.byteArrayToUUID(xid.getGlobalTransactionId()).toString()
                 + "|" + UuidUtils.byteArrayToUUID(xid.getBranchQualifier()).toString());
  
-        Class targetClass = ReflectionUtils.getDeclaringType(pjp.getTarget().getClass(), method.getName(), method.getParameterTypes());
+        ProceedingJoinPoint pjp = methodContext.getProceedingJoinPoint();
+        Method method = methodContext.getMethod();
+
+        Class targetClass = ReflectionUtils.getDeclaringType(
+                pjp.getTarget().getClass(),
+                method.getName(),
+                method.getParameterTypes());
  
         // 构建确认方法的提交上下文
         InvocationContext confirmInvocation = new InvocationContext(targetClass,
@@ -119,22 +119,22 @@ public class ResourceCoordinatorInterceptor {
  
     /**
      * 生成并登记消费者的参与者
-     * @param pjp
+     * @param methodContext
      * @return
      */
-    private Participant generateAndEnlistConsumerParticipant(ProceedingJoinPoint pjp) {
+    private Participant generateAndEnlistConsumerParticipant(MethodContext methodContext) {
         LOG.debug("==>ResourceCoordinatorInterceptor generateAndEnlistConsumerParticipant(ProceedingJoinPoint pjp)");
-        MethodSignature signature = (MethodSignature) pjp.getSignature();
-        Method method = signature.getMethod();
  
         Transaction transaction = transactionConfigurator.getTransactionManager().getCurrentTransaction(); // 获取当前事务
-
         TransactionXid xid = new TransactionXid(transaction.getXid().getGlobalTransactionId()); // 获取事务Xid
         LOG.debug("==>TransactionXid：" + UuidUtils.byteArrayToUUID(xid.getGlobalTransactionId()).toString()
                 + "|" + UuidUtils.byteArrayToUUID(xid.getBranchQualifier()).toString());
  
         // 获取事务上下文参数的位置
-        int position = CompensableMethodUtils.getTransactionContextParamPosition(((MethodSignature) pjp.getSignature()).getParameterTypes());
+        int position = methodContext.getTransactionContextParamPosition();
+
+        ProceedingJoinPoint pjp = methodContext.getProceedingJoinPoint();
+        Method method = methodContext.getMethod();
  
         // 给服务接口的TransactionContext参数设值
         pjp.getArgs()[position] = new TransactionContext(xid, transaction.getStatus().getId()); // 构建事务上下文
@@ -173,25 +173,21 @@ public class ResourceCoordinatorInterceptor {
  
     /**
      * 生成并登记服务提供者的参与者
-     * @param pjp
+     * @param methodContext
      * @return
      */
-    private Participant generateAndEnlistProviderParticipant(ProceedingJoinPoint pjp) {
-
-        MethodSignature signature = (MethodSignature) pjp.getSignature();
-        Method method = signature.getMethod();
-
-        Compensable compensable = getCompensable(pjp);
-
-        String confirmMethodName = compensable.confirmMethod();
-        String cancelMethodName = compensable.cancelMethod();
+    private Participant generateAndEnlistProviderParticipant(MethodContext methodContext) {
+        String confirmMethodName = methodContext.getConfirmMethodName();
+        String cancelMethodName = methodContext.getCancelMethodName();
  
         Transaction transaction = transactionConfigurator.getTransactionManager().getCurrentTransaction();
-
         TransactionXid xid = new TransactionXid(transaction.getXid().getGlobalTransactionId());
         LOG.debug("==>TransactionXid：" + UuidUtils.byteArrayToUUID(xid.getGlobalTransactionId()).toString()
                 + "|" + UuidUtils.byteArrayToUUID(xid.getBranchQualifier()).toString());
  
+        ProceedingJoinPoint pjp = methodContext.getProceedingJoinPoint();
+        Method method = methodContext.getMethod();
+
         Class targetClass = ReflectionUtils.getDeclaringType(pjp.getTarget().getClass(), method.getName(), method.getParameterTypes());
  
         // 构建确认方法的提交上下文
@@ -216,33 +212,4 @@ public class ResourceCoordinatorInterceptor {
         return participant;
     }
  
-    /**
-     * 根据切点，获取事务注解.
-     * @param pjp
-     * @return
-     */
-    private Compensable getCompensable(ProceedingJoinPoint pjp) {
-        LOG.debug("==>ResourceCoordinatorInterceptor getCompensable(ProceedingJoinPoint pjp)");
-        MethodSignature signature = (MethodSignature) pjp.getSignature(); // 获取签名
-        Method method = signature.getMethod(); // 获取方法
-
-        Compensable compensable = method.getAnnotation(Compensable.class); // 获取注解
-
-        if (compensable == null) {
-            Method targetMethod = null;
-            try {
-                // 获取目标方法
-                targetMethod = pjp.getTarget().getClass().getMethod(method.getName(), method.getParameterTypes());
-
-                if (targetMethod != null) {
-                    compensable = targetMethod.getAnnotation(Compensable.class);
-                }
-
-            } catch (NoSuchMethodException e) {
-                compensable = null;
-            }
-
-        }
-        return compensable;
-    }
 }
+package org.mengyun.tcctransaction.interceptor.invoke;
+
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.mengyun.tcctransaction.api.TransactionContext;
+import org.mengyun.tcctransaction.api.annotation.Compensable;
+
+import java.lang.reflect.Method;
+
+/**
+ * 标注的方法上下文。
+ */
+public class MethodContext {
+    /** 切入点 */
+    private ProceedingJoinPoint proceedingJoinPoint;
+    public ProceedingJoinPoint getProceedingJoinPoint() {
+        return proceedingJoinPoint;
+    }
+    /** 方法 */
+    private Method method;
+    public Method getMethod() {
+        return method;
+    }
+    /** Compensable标注 */
+    private Compensable compensable;
+    /** 事务上下文 */
+    private TransactionContext transactionContext;
+    public TransactionContext getTransactionContext() {
+        return transactionContext;
+    }
+
+    public MethodContext(ProceedingJoinPoint proceedingJoinPoint) {
+        // 切入点
+        this.proceedingJoinPoint = proceedingJoinPoint;
+
+        // 方法
+        this.method = ((MethodSignature) (this.proceedingJoinPoint.getSignature())).getMethod();
+        if (this.method.getAnnotation(Compensable.class) == null) {
+            try {
+                this.method = this.proceedingJoinPoint.getTarget().getClass().getMethod(
+                        method.getName(), method.getParameterTypes());
+            } catch (NoSuchMethodException e) {
+                this.method = null;
+            }
+        }
+
+        // 根据切点，获取事务注解
+        this.compensable = method.getAnnotation(Compensable.class); // 获取注解
+        if (this.compensable == null) {
+            Method targetMethod = null;
+            try {
+                // 获取目标方法
+                targetMethod = this.proceedingJoinPoint.getTarget().getClass().getMethod(
+                        this.method.getName(), this.method.getParameterTypes());
+
+                if (targetMethod != null) {
+                    this.compensable = targetMethod.getAnnotation(Compensable.class);
+                }
+
+            } catch (NoSuchMethodException e) {
+                this.compensable = null;
+            }
+
+        }
+
+        // 从拦截方法的参数中获取事务上下文
+        this.transactionContext = null;
+        for (Object arg : this.proceedingJoinPoint.getArgs()) {
+            if (arg != null && org.mengyun.tcctransaction.api.TransactionContext.class.isAssignableFrom(arg.getClass())) {
+
+                this.transactionContext = (org.mengyun.tcctransaction.api.TransactionContext) arg;
+            }
+        }
+
+    }
+
+    // 计算方法类型
+    public MethodType getMethodType() {
+        boolean isCompensable = this.compensable != null;
+        if (this.transactionContext == null && isCompensable) {
+            // 没有事务上下文信息，并且方法有事务注解的，为可补偿事务根方法（也就是事务发起者）
+            //isRootTransactionMethod
+            return MethodType.ROOT;
+        } else if (this.transactionContext == null && !isCompensable) {
+            // 没有事务上下文信息，并且方法没有事务注解的，为可补偿事务服务消费者（参考者）方法（一般为被调用的服务接口）
+            //isSoaConsumer
+            return MethodType.CONSUMER;
+        } else if (isCompensable) {
+            // 有事务上下文信息，并且方法有事务注解的，为可补偿事务服务提供者方法（一般为被调用的服务接口的实现方法）
+            //isSoaProvider
+            return MethodType.PROVIDER;
+        } else {
+            return MethodType.NORMAL;
+        }
+    }
+
+    /**
+     * 获取方法中，参数为TransactionContext类型的参数位置.
+     * @return
+     */
+    public int getTransactionContextParamPosition() {
+        int i = -1;
+        Class<?>[] parameterTypes = this.method.getParameterTypes();
+        for (i = 0; i < parameterTypes.length; i++) {
+            if (parameterTypes[i].equals(org.mengyun.tcctransaction.api.TransactionContext.class)) {
+                break;
+            }
+        }
+        return i;
+    }
+
+    /**
+     * 获取confirm方法名。
+     * @return
+     */
+    public String getConfirmMethodName() {
+        return this.compensable.confirmMethod();
+    }
+
+    /**
+     * 获取cancel方法名。
+     * @return
+     */
+    public String getCancelMethodName() {
+        return this.compensable.cancelMethod();
+    }
+
+    /**
+     * 执行方法。
+     * @return
+     * @throws Throwable
+     */
+    public Object proceed() throws Throwable {
+        return this.proceedingJoinPoint.proceed();
+    }
+
+
+}
-package org.mengyun.tcctransaction.interceptor.utils;
+package org.mengyun.tcctransaction.interceptor.invoke;
  
 /**
  * Created by changmingxie on 11/11/15.
-package org.mengyun.tcctransaction.interceptor;
+package org.mengyun.tcctransaction.interceptor.invoke;
  
 import org.mengyun.tcctransaction.api.TransactionXid;
-import org.mengyun.tcctransaction.interceptor.invoke.Terminator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
  
-package org.mengyun.tcctransaction.interceptor.utils;
-
-import org.mengyun.tcctransaction.api.TransactionContext;
-
-/**
- * Created by changmingxie on 11/21/15.
- * 可补偿方法工具类。
- */
-public class CompensableMethodUtils {
-    /**
-     * 计算方法类型.
-     * @param transactionContext
-     * @param isCompensable
-     * @return
-     */
-    public static MethodType calculateMethodType(TransactionContext transactionContext, boolean isCompensable) {
-
-        if (transactionContext == null && isCompensable) {
-            // 没有事务上下文信息，并且方法有事务注解的，为可补偿事务根方法（也就是事务发起者）
-            //isRootTransactionMethod
-            return MethodType.ROOT;
-        } else if (transactionContext == null && !isCompensable) {
-            // 没有事务上下文信息，并且方法没有事务注解的，为可补偿事务服务消费者（参考者）方法（一般为被调用的服务接口）
-            //isSoaConsumer
-            return MethodType.CONSUMER;
-        } else if (transactionContext != null && isCompensable) {
-            // 有事务上下文信息，并且方法有事务注解的，为可补偿事务服务提供者方法（一般为被调用的服务接口的实现方法）
-            //isSoaProvider
-            return MethodType.PROVIDER;
-        } else {
-            return MethodType.NORMAL;
-        }
-    }
-
-    /**
-     * 获取事务上下文参数的位置.
-     * @param parameterTypes
-     * @return
-     */
-    public static int getTransactionContextParamPosition(Class<?>[] parameterTypes) {
-
-        int i = -1;
-
-        for (i = 0; i < parameterTypes.length; i++) {
-            if (parameterTypes[i].equals(org.mengyun.tcctransaction.api.TransactionContext.class)) {
-                break;
-            }
-        }
-        return i;
-    }
-
-    /**
-     * 从参数获取事务上下文.
-     * @param args
-     * @return
-     */
-    public static TransactionContext getTransactionContextFromArgs(Object[] args) {
-
-        TransactionContext transactionContext = null;
-
-        for (Object arg : args) {
-            if (arg != null && org.mengyun.tcctransaction.api.TransactionContext.class.isAssignableFrom(arg.getClass())) {
-
-                transactionContext = (org.mengyun.tcctransaction.api.TransactionContext) arg;
-            }
-        }
-
-        return transactionContext;
-    }
-}
@@ -12,7 +12,7 @@ public interface RecoverConfig {
     int getMaxRetryCount();
  
     /**
-     * 获取需要执行事务恢复的持续时间.
+     * 获取需要执行事务恢复的持续时间（以当前时间计算），此外还和CachableTransactionRepository中的缓存时间一致.
      * @return
      */
     int getRecoverDuration();
@@ -24,7 +24,7 @@ public abstract class CachableTransactionRepository implements TransactionReposi
     private final static Logger LOG = LoggerFactory.getLogger(CachableTransactionRepository.class);
  
     /** 缓存到期时间(以秒为单位) */
-    private int expireDuration = 300;
+    private int expireDuration = 120;
     public final void setExpireDuration(int durationInSeconds) {
         this.expireDuration = durationInSeconds;
     }
@@ -27,7 +27,7 @@ public class TccCompensableAspect implements Ordered {
     }
     @Override
     public int getOrder() {
-        return 0;
+        return order;
     }
  
     /** 可补偿事务拦截器 */
@@ -21,13 +21,13 @@ public class TccTransactionContextAspect implements Ordered {
  
     /** 优先级顺序（值较低的那个有更高的优先级） */
     // 对于Around增强，方法前增强较低的优先级先执行，方法后的增强较高的优先级先执行
-    private int order = Ordered.HIGHEST_PRECEDENCE;
+    private int order = Ordered.HIGHEST_PRECEDENCE + 1;
     public void setOrder(int order) {
         this.order = order;
     }
     @Override
     public int getOrder() {
-        return 0;
+        return order;
     }
  
     /** 资源协调拦截器 */
@@ -3,6 +3,7 @@ package org.mengyun.tcctransaction.spring.support;
 import org.mengyun.tcctransaction.TransactionManager;
 import org.mengyun.tcctransaction.recover.RecoverConfig;
 import org.mengyun.tcctransaction.repository.TransactionRepository;
+import org.mengyun.tcctransaction.repository.impl.CachableTransactionRepository;
 import org.mengyun.tcctransaction.spring.recover.DefaultRecoverConfig;
 import org.mengyun.tcctransaction.support.TransactionConfigurator;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -46,9 +47,15 @@ public class TccTransactionConfigurator implements TransactionConfigurator {
         // 1、事务repo注入检测
         if (transactionRepository == null) {
             throw new RuntimeException("自项目必须注入TransactionRepository相关实现类，如SpringJdbcTransactionRepository");
+        } else if (transactionRepository instanceof CachableTransactionRepository) {
+            ((CachableTransactionRepository) transactionRepository).setExpireDuration(
+                    recoverConfig.getRecoverDuration()
+            );
         }
         // 2、事务配置器配置事务repo
         transactionManager.setTransactionRepository(transactionRepository);
+
+        // TODO：3、executeService配置
     }