添加线程池变量传递的aop类

Author: saleson

pom.xml

@@ -72,6 +72,7 @@
         <guava.version>27.0.1-jre</guava.version>
         <mapstruct.version>1.1.0.Final</mapstruct.version>
         <caffeine.version>2.7.0</caffeine.version>
+        <aspectj.version>1.8.13</aspectj.version>
     </properties>
 
 
@@ -163,6 +164,13 @@
                 <version>${project.version}</version>
             </dependency>
 
+            <dependency>
+                <groupId>org.aspectj</groupId>
+                <artifactId>aspectjrt</artifactId>
+                <version>${aspectj.version}</version>
+                <scope>compile</scope>
+            </dependency>
+
 
             <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui -->
             <dependency>

spring-cloud-gray-client-netflix/pom.xml

@@ -102,8 +102,6 @@
         <dependency>
             <groupId>org.aspectj</groupId>
             <artifactId>aspectjrt</artifactId>
-            <version>1.8.13</version>
-            <scope>compile</scope>
         </dependency>
 
 

spring-cloud-gray-client/pom.xml

@@ -73,6 +73,11 @@
             <scope>compile</scope>
         </dependency>
 
+        <dependency>
+            <groupId>org.aspectj</groupId>
+            <artifactId>aspectjrt</artifactId>
+        </dependency>
+
     </dependencies>
 
 

spring-cloud-gray-client/src/main/java/cn/springcloud/gray/concurrent/GrayConcurrentHelper.java

@@ -61,4 +61,5 @@ public static GrayTrackInfo getGrayTrackInfo() {
         RequestLocalStorage requestLocalStorage = GrayClientHolder.getRequestLocalStorage();
         return requestLocalStorage == null ? null : requestLocalStorage.getGrayTrackInfo();
     }
+
 }

spring-cloud-gray-client/src/main/java/cn/springcloud/gray/concurrent/GrayExecutor.java

@@ -14,4 +14,8 @@ public GrayExecutor(Executor delegater) {
     public void execute(Runnable command) {
         delegater.execute(GrayConcurrentHelper.createDelegateRunnable(command));
     }
+
+    public Executor getDelegater() {
+        return delegater;
+    }
 }

spring-cloud-gray-client/src/main/java/cn/springcloud/gray/concurrent/GrayExecutorService.java

@@ -92,4 +92,7 @@ public void execute(Runnable command) {
     }
 
 
+    public ExecutorService getDelegater() {
+        return delegater;
+    }
 }

spring-cloud-gray-client/src/main/java/cn/springcloud/gray/concurrent/GrayTaskDecorator.java

@@ -1,12 +1,11 @@
 package cn.springcloud.gray.concurrent;
 
-import cn.springcloud.gray.request.RequestLocalStorage;
 import org.springframework.core.task.TaskDecorator;
 
 public class GrayTaskDecorator implements TaskDecorator {
 
 
-    public GrayTaskDecorator(RequestLocalStorage requestLocalStorage) {
+    public GrayTaskDecorator() {
     }
 
     @Override

spring-cloud-gray-client/src/main/java/cn/springcloud/gray/concurrent/aspect/ExecutorGrayAspect.java

@@ -0,0 +1,34 @@
+package cn.springcloud.gray.concurrent.aspect;
+
+import cn.springcloud.gray.concurrent.GrayConcurrentHelper;
+import cn.springcloud.gray.concurrent.GrayExecutor;
+import cn.springcloud.gray.concurrent.GrayExecutorService;
+import cn.springcloud.gray.concurrent.GrayRunnable;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+
+@Aspect
+public class ExecutorGrayAspect {
+
+    @Pointcut("execution(* java.util.concurrent.Executor.execute(..)) && args(command)")
+    public void pointCut(Runnable command) {
+
+    }
+
+
+    @Around("pointCut(command)")
+    public Object aroundLog(ProceedingJoinPoint joinpoint, Runnable command) throws Throwable {
+        if (joinpoint.getTarget() instanceof GrayExecutor
+                || joinpoint.getTarget() instanceof GrayExecutorService
+                || command instanceof GrayRunnable) {
+            return joinpoint.proceed();
+        }
+
+        Runnable runnable = GrayConcurrentHelper.createDelegateRunnable(command);
+        return joinpoint.proceed(new Object[]{runnable});
+
+    }
+
+}

spring-cloud-gray-client/src/main/java/cn/springcloud/gray/concurrent/aspect/ExecutorServiceGrayAspect.java

@@ -0,0 +1,118 @@
+package cn.springcloud.gray.concurrent.aspect;
+
+import cn.springcloud.gray.concurrent.*;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+
+import java.util.Collection;
+import java.util.concurrent.Callable;
+import java.util.concurrent.TimeUnit;
+
+@Aspect
+public class ExecutorServiceGrayAspect {
+
+    @Pointcut("execution(* java.util.concurrent.ExecutorService.execute(..)) && args(command)")
+    public void executePointCut(Runnable command) {
+
+    }
+
+
+    @Pointcut("execution(* java.util.concurrent.ExecutorService.submit(..)) && args(command)")
+    public void submitPointCut(Callable command) {
+
+    }
+
+    @Pointcut("execution(* java.util.concurrent.ExecutorService.submit(..)) && args(command, result)")
+    public void submitPointCut2(Runnable command, Object result) {
+
+    }
+
+
+    @Pointcut("execution(* java.util.concurrent.ExecutorService.submit(..)) && args(command)")
+    public void submitPointCut3(Runnable command) {
+
+    }
+
+    @Pointcut("(execution(* java.util.concurrent.ExecutorService.invokeAll(..)) || execution(* java.util.concurrent.ExecutorService.invokeAny(..)) ) && args(tasks)")
+    public <V> void invokeAllOrAnyPointCut(Collection<? extends Callable<V>> tasks) {
+
+    }
+
+    @Pointcut("(execution(* java.util.concurrent.ExecutorService.invokeAll(..)) || execution(* java.util.concurrent.ExecutorService.invokeAny(..))) && args(tasks, timeout, unit)")
+    public <V> void invokeAllOrAnyPointCut2(Collection<? extends Callable<V>> tasks, long timeout, TimeUnit unit) {
+
+    }
+
+    @Around("executePointCut(command)")
+    public Object executeAround(ProceedingJoinPoint joinpoint, Runnable command) throws Throwable {
+        if (joinpoint.getTarget() instanceof GrayExecutor
+                || joinpoint.getTarget() instanceof GrayExecutorService
+                || command instanceof GrayRunnable) {
+            return joinpoint.proceed();
+        }
+
+        Runnable runnable = GrayConcurrentHelper.createDelegateRunnable(command);
+        return joinpoint.proceed(new Object[]{runnable});
+
+    }
+
+
+    @Around("submitPointCut(command)")
+    public Object submitAround(ProceedingJoinPoint joinpoint, Callable command) throws Throwable {
+        if (joinpoint.getTarget() instanceof GrayExecutorService
+                || command instanceof GrayCallable) {
+            return joinpoint.proceed();
+        }
+
+        Callable runnable = GrayConcurrentHelper.createDelegateCallable(command);
+        return joinpoint.proceed(new Object[]{runnable});
+
+    }
+
+    @Around("submitPointCut2(command, result)")
+    public Object submitAround(ProceedingJoinPoint joinpoint, Runnable command, Object result) throws Throwable {
+        if (joinpoint.getTarget() instanceof GrayExecutorService
+                || command instanceof GrayRunnable) {
+            return joinpoint.proceed();
+        }
+
+        Runnable runnable = GrayConcurrentHelper.createDelegateRunnable(command);
+        return joinpoint.proceed(new Object[]{runnable, result});
+    }
+
+    @Around("submitPointCut3(command)")
+    public Object submitAround(ProceedingJoinPoint joinpoint, Runnable command) throws Throwable {
+        if (joinpoint.getTarget() instanceof GrayExecutorService
+                || command instanceof GrayRunnable) {
+            return joinpoint.proceed();
+        }
+
+        Runnable runnable = GrayConcurrentHelper.createDelegateRunnable(command);
+        return joinpoint.proceed(new Object[]{runnable});
+    }
+
+    @Around("invokeAllOrAnyPointCut(tasks)")
+    public <V> Object invokeAllOrAnyAround(ProceedingJoinPoint joinpoint, Collection<? extends Callable<V>> tasks) throws Throwable {
+        if (joinpoint.getTarget() instanceof GrayExecutorService) {
+            return joinpoint.proceed();
+        }
+
+        return joinpoint.proceed(new Object[]{GrayConcurrentHelper.mapDelegateCallables(tasks)});
+    }
+
+    @Around("invokeAllOrAnyPointCut2(tasks, timeout, unit)")
+    public <V> Object invokeAllOrAnyAround(
+            ProceedingJoinPoint joinpoint,
+            Collection<? extends Callable<V>> tasks,
+            long timeout, TimeUnit unit) throws Throwable {
+        if (joinpoint.getTarget() instanceof GrayExecutorService) {
+            return joinpoint.proceed();
+        }
+
+        return joinpoint.proceed(new Object[]{GrayConcurrentHelper.mapDelegateCallables(tasks), timeout, unit});
+    }
+
+
+}