Add a dependency: lombok

pom.xml

@@ -57,6 +57,7 @@
         <revision>2.0.0-SNAPSHOT</revision>
         <mockito.version>3.12.4</mockito.version>
         <java.version>1.8</java.version>
+        <lombok-version>1.18.24</lombok-version>
         <skip.maven.gpg.plugin>true</skip.maven.gpg.plugin>
         <skip.spotless.apply>false</skip.spotless.apply>
         <skip.checkstyle.check>true</skip.checkstyle.check>
@@ -66,9 +67,10 @@
         <jacoco-maven-plugin.version>0.8.8</jacoco-maven-plugin.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
-        <maven.compiler.plugin.version>3.6.1</maven.compiler.plugin.version>
+        <maven.compiler.plugin.version>3.8.1</maven.compiler.plugin.version>
         <maven.javadoc.plugin.version>3.0.0</maven.javadoc.plugin.version>
         <maven.source.plugin.version>3.0.1</maven.source.plugin.version>
+        <maven.resources.plugin.version>3.2.0</maven.resources.plugin.version>
         <maven.jar.plugin.version>3.0.2</maven.jar.plugin.version>
         <flatten-maven-plugin.version>1.1.0</flatten-maven-plugin.version>
         <maven-gpg-plugin.version>1.6</maven-gpg-plugin.version>
@@ -82,6 +84,11 @@
 
     <dependencyManagement>
         <dependencies>
+            <dependency>
+                <groupId>org.projectlombok</groupId>
+                <artifactId>lombok</artifactId>
+                <version>${lombok-version}</version>
+            </dependency>
             <dependency>
                 <groupId>cn.hippo4j</groupId>
                 <artifactId>hippo4j-dependencies</artifactId>
@@ -125,6 +132,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-jar-plugin</artifactId>
+                <version>${maven.jar.plugin.version}</version>
                 <configuration>
                     <archive>
                         <manifestEntries>
@@ -136,6 +144,11 @@
                     </archive>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-resources-plugin</artifactId>
+                <version>${maven.resources.plugin.version}</version> <!-- 添加版本号 -->
+            </plugin>
             <plugin>
                 <groupId>org.codehaus.mojo</groupId>
                 <artifactId>flatten-maven-plugin</artifactId>
@@ -209,7 +222,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-source-plugin</artifactId>
-                <version>${maven-source-plugin.version}</version>
+                <version>${maven.source.plugin.version}</version>
                 <configuration>
                     <attach>true</attach>
                 </configuration>

threadpool/core/src/test/java/brave/internal/WrappingExecutorService.java

@@ -0,0 +1,105 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package brave.internal;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+public abstract class WrappingExecutorService implements ExecutorService {
+
+    protected WrappingExecutorService() {
+    }
+
+    protected abstract ExecutorService delegate();
+
+    protected abstract <R> Callable<R> wrap(Callable<R> var1);
+
+    protected abstract Runnable wrap(Runnable var1);
+
+    public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
+        return this.delegate().awaitTermination(timeout, unit);
+    }
+
+    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
+        return this.delegate().invokeAll(this.wrap(tasks));
+    }
+
+    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException {
+        return this.delegate().invokeAll(this.wrap(tasks), timeout, unit);
+    }
+
+    public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
+        return this.delegate().invokeAny(this.wrap(tasks));
+    }
+
+    public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+        return this.delegate().invokeAny(this.wrap(tasks), timeout, unit);
+    }
+
+    public boolean isShutdown() {
+        return this.delegate().isShutdown();
+    }
+
+    public boolean isTerminated() {
+        return this.delegate().isTerminated();
+    }
+
+    public void shutdown() {
+        this.delegate().shutdown();
+    }
+
+    public List<Runnable> shutdownNow() {
+        return this.delegate().shutdownNow();
+    }
+
+    public void execute(Runnable task) {
+        this.delegate().execute(this.wrap(task));
+    }
+
+    public <T> Future<T> submit(Callable<T> task) {
+        return this.delegate().submit(this.wrap(task));
+    }
+
+    public Future<?> submit(Runnable task) {
+        return this.delegate().submit(this.wrap(task));
+    }
+
+    public <T> Future<T> submit(Runnable task, T result) {
+        return this.delegate().submit(this.wrap(task), result);
+    }
+
+    <T> Collection<? extends Callable<T>> wrap(Collection<? extends Callable<T>> tasks) {
+        ArrayList<Callable<T>> result = new ArrayList(tasks.size());
+        Iterator var3 = tasks.iterator();
+
+        while (var3.hasNext()) {
+            Callable<T> task = (Callable) var3.next();
+            result.add(this.wrap(task));
+        }
+
+        return result;
+    }
+}

threadpool/core/src/test/java/cn/hippo4j/core/CustomWrappingExecutorService.java

@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package cn.hippo4j.core;
+
+import brave.internal.WrappingExecutorService;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+
+public class CustomWrappingExecutorService extends WrappingExecutorService {
+
+    ExecutorService delegate;
+
+    public CustomWrappingExecutorService() {
+    }
+
+    public CustomWrappingExecutorService(ExecutorService delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public ExecutorService delegate() {
+        return delegate;
+    }
+
+    @Override
+    protected <R> Callable<R> wrap(Callable<R> callable) {
+        return callable;
+    }
+
+    @Override
+    protected Runnable wrap(Runnable runnable) {
+        return runnable;
+    }
+}

threadpool/core/src/test/java/cn/hippo4j/core/adapter/ZipkinExecutorAdapterTest.java

@@ -0,0 +1,79 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package cn.hippo4j.core.adapter;
+
+import cn.hippo4j.common.executor.support.RunsOldestTaskPolicy;
+import cn.hippo4j.common.handler.ZipkinExecutorAdapter;
+import cn.hippo4j.core.CustomWrappingExecutorService;
+import cn.hippo4j.core.executor.support.ThreadPoolBuilder;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.Assert;
+import org.junit.Test;
+import org.springframework.scheduling.concurrent.DefaultManagedAwareThreadFactory;
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * test for ${@link ZipkinExecutorAdapter}
+ * */
+@Slf4j
+public class ZipkinExecutorAdapterTest {
+
+    ZipkinExecutorAdapter zipkinExecutorAdapter = new ZipkinExecutorAdapter();
+    Executor dynamicThreadPool = ThreadPoolBuilder.builder()
+            .threadPoolId("test")
+            .dynamicPool()
+            .corePoolSize(1)
+            .maximumPoolSize(2)
+            .keepAliveTime(1000)
+            .timeUnit(TimeUnit.MICROSECONDS)
+            .threadFactory(new DefaultManagedAwareThreadFactory())
+            .workQueue(new SynchronousQueue<>())
+            .rejected(new RunsOldestTaskPolicy())
+            .build();
+
+    @Test
+    public void testMatch() {
+        Object executor = new CustomWrappingExecutorService(Executors.newCachedThreadPool());
+        Assert.assertTrue(zipkinExecutorAdapter.match(executor));
+    }
+
+    @Test
+    public void testUnwrap() {
+        Object executor = new CustomWrappingExecutorService(Executors.newCachedThreadPool());
+        ThreadPoolExecutor unwrap = zipkinExecutorAdapter.unwrap(executor);
+        Assert.assertNull(unwrap);
+    }
+
+    @Test
+    public void testReplace() {
+        Object executor = new CustomWrappingExecutorService(Executors.newCachedThreadPool());
+        CustomWrappingExecutorService executorChange = (CustomWrappingExecutorService)executor;
+        ExecutorService beforeReplace = executorChange.delegate();
+        zipkinExecutorAdapter.replace(executor, dynamicThreadPool);
+        ExecutorService afterReplace = executorChange.delegate();
+
+        Assert.assertNotSame(beforeReplace, afterReplace);
+        Assert.assertSame(afterReplace, dynamicThreadPool);
+    }
+}