/**
 * 執(zhí)行代碼增強(qiáng)的插件
 *
 * @auther houyi.wh
 * @date 2023-08-15 20:12:01
 * @since 0.0.1
 */
public abstract class EnhancedPlugin {


    /**
     * 匹配特定的類型
     *
     * @return 類型匹配器
     * @since 0.0.1
     */
    public abstract ElementMatcher.Junction<TypeDescription> typeMatcher();


    /**
     * 匹配特定的方法
     *
     * @return 方法匹配器
     * @since 0.0.1
     */
    public abstract ElementMatcher.Junction<MethodDescription> methodMatcher();


    /**
     * 負(fù)責(zé)執(zhí)行增強(qiáng)邏輯的攔截器
     *
     * @return 攔截器
     * @since 0.0.1
     */
    public abstract Class<? extends Interceptor> interceptorClass();


}

/**
 * 在方法執(zhí)行前進(jìn)行切面
 *
 * @param pluginName 綁定在該目標(biāo)方法上的插件名稱
 * @param target     目標(biāo)方法所屬的對(duì)象，需要注意的是@Advice.This不能標(biāo)識(shí)構(gòu)造方法
 * @param method     目標(biāo)方法
 * @param arguments  方法參數(shù)
 * @return 方法執(zhí)行返回的臨時(shí)數(shù)據(jù)
 * @since 0.0.1
 */
@Advice.OnMethodEnter
public static <T> T beforeMethod(
        // 接收動(dòng)態(tài)傳遞過來的參數(shù)
        @PluginName String pluginName,
        // optinotallow=true，表示this注解可以接收：構(gòu)造方法或靜態(tài)方法(會(huì)將this賦值為null)，而不報(bào)錯(cuò)
        @Advice.This(optional = true) Object target,
        // 目標(biāo)方法
        @Advice.Origin Method method,
        // nullIfEmpty=true，表示可以接收空參數(shù)
        @Advice.AllArguments(nullIfEmpty = true) Object[] arguments
) {
    String[] parameterNames = new String[]{};
    T transmitResult = null;
    try {
        InstanceMethodInterceptor<T> interceptor = getInterceptor(pluginName);
        // 執(zhí)行beforeMethod的攔截邏輯
        transmitResult = interceptor.beforeMethod(target, method, parameterNames, arguments);
    } catch (Throwable e) {
        InternalLogger.AutoDetect.INSTANCE.error("InstanceMethodAdvice beforeMethod occurred error", e);
    }
    return transmitResult;
}

/**
 * 在方法執(zhí)行后進(jìn)行切面
 *
 * @param pluginName     綁定在該目標(biāo)方法上的插件名稱
 * @param transmitResult beforeMethod所傳遞過來的臨時(shí)數(shù)據(jù)
 * @param originResult   目標(biāo)方法原始返回結(jié)果，如果目標(biāo)方法是void型，則originResult為null
 * @param throwable      目標(biāo)方法拋出的異常
 */
@Advice.OnMethodExit(onThrowable = Throwable.class)
public static <T> void afterMethod(
        // 接收動(dòng)態(tài)傳遞過來的參數(shù)
        @PluginName String pluginName,
        // beforeMethod傳遞過來的臨時(shí)數(shù)據(jù)
        @Advice.Enter T transmitResult,
        // typing=DYNAMIC，表示可以接收void類型的方法
        @Advice.Return(typing = Assigner.Typing.DYNAMIC) Object originResult,
        // 目標(biāo)方法自己拋出的運(yùn)行時(shí)異常，可以在方法中進(jìn)行捕獲，看具體的需求
        @Advice.Thrown Throwable throwable
) {
    try {
        InstanceMethodInterceptor<T> interceptor = getInterceptor(pluginName);
        // 執(zhí)行afterMethod的攔截邏輯
        interceptor.afterMethod(transmitResult, originResult);
    } catch (Throwable e) {
        InternalLogger.AutoDetect.INSTANCE.error("InstanceMethodAdvice afterMethod occurred error", e);
    }
}

public class MethodCallPlugin extends EnhancedPlugin {


    private final List<String> anyClassNameStartWith;
    private final List<String> anyAnnotationNameOnMethod;


    /**
     * 方法調(diào)用攔截插件
     *
     * @param anyClassNameStartWith     任何包路徑，或者全限定類名
     * @param anyAnnotationNameOnMethod 任何方法上的注解的全限定名稱
     */
    public MethodCallPlugin(List<String> anyClassNameStartWith, List<String> anyAnnotationNameOnMethod) {
        boolean nameStartWithInvalid = anyClassNameStartWith == null || anyClassNameStartWith.isEmpty();
        boolean annotationNameOnMethodInvalid = anyAnnotationNameOnMethod == null || anyAnnotationNameOnMethod.isEmpty();
        if (nameStartWithInvalid && annotationNameOnMethodInvalid) {
            throw new IllegalArgumentException("anyClassNameStartWith and anyAnnotationNameOnMethod can't be both empty");
        }
        this.anyClassNameStartWith = anyClassNameStartWith;
        this.anyAnnotationNameOnMethod = anyAnnotationNameOnMethod;
    }


    @Override
    public ElementMatcher.Junction<TypeDescription> typeMatcher() {
        ElementMatcher.Junction<TypeDescription> anyTypes = none();
        if (anyClassNameStartWith != null && !anyClassNameStartWith.isEmpty()) {
            for (String classNameStartWith : anyClassNameStartWith) {
                // 根據(jù)類的前綴或者全限定類名進(jìn)行匹配
                anyTypes = anyTypes.or(nameStartsWith(classNameStartWith));
            }
        }
        if (anyAnnotationNameOnMethod != null && !anyAnnotationNameOnMethod.isEmpty()) {
            ElementMatcher.Junction<MethodDescription> methodsWithAnnotation = none();
            for (String annotationNameOnMethod : anyAnnotationNameOnMethod) {
                // 根據(jù)方法上是否有特定注解進(jìn)行匹配
                methodsWithAnnotation = methodsWithAnnotation.or(isAnnotatedWith(named(annotationNameOnMethod)));
            }
            anyTypes = anyTypes.or(declaresMethod(methodsWithAnnotation));
        }
        return anyTypes;
    }
}

匹配特定方法的邏輯就比較簡(jiǎn)單了，可以匹配除了構(gòu)造方法之外的任意方法：

public class MethodCallPlugin extends EnhancedPlugin {


    @Override
    public ElementMatcher.Junction<MethodDescription> methodMatcher() {
        return any().and(not(isConstructor()));
    }
}

/**
 * 方法調(diào)用信息的攔截器
 * 在方法調(diào)用之前進(jìn)行攔截，將方法調(diào)用信息封裝后，放入堆棧中，
 * 在方法調(diào)用之后，從堆棧中將所有方法取出來，按照進(jìn)入堆棧的順序進(jìn)行排序，
 * 得到方法調(diào)用信息的列表，最后將該列表交給{@link MethodCallHandler}進(jìn)行處理
 * 如果用戶指定了自己的{@link MethodCallHandler}則優(yōu)先使用用戶自定義的Handler進(jìn)行處理
 * 否則使用SDK內(nèi)置的{@link MethodCallHandler.PrintLogHandler}進(jìn)行處理，即將方法調(diào)用信息打印到日志中
 *
 * @auther houyi.wh
 * @date 2023-08-16 10:16:48
 * @since 0.0.1
 */
public class MethodCallInterceptor implements InstanceMethodInterceptor<MethodCall> {


    /**
     * 當(dāng)前方法進(jìn)入方法棧的順序
     * 用以最后一個(gè)方法出棧后，進(jìn)行方法調(diào)用棧的排序
     *
     * @since 0.0.1
     */
    private static final ThreadLocal<AtomicInteger> methodEnterStackOrderThreadLocal = new TransmittableThreadLocal<AtomicInteger>() {
        @Override
        protected AtomicInteger initialValue() {
            return new AtomicInteger(0);
        }
    };


    /**
     * 當(dāng)前方法調(diào)用棧
     *
     * @since 0.0.1
     */
    private static final ThreadLocal<Deque<MethodCall>> methodStackThreadLocal = new ThreadLocal<Deque<MethodCall>>() {
        @Override
        protected Deque<MethodCall> initialValue() {
            return new ArrayDeque<>();
        }
    };


    /**
     * 當(dāng)前方法棧中所有方法調(diào)用的信息
     *
     * @since 0.0.1
     */
    private static final ThreadLocal<List<MethodCall>> methodCallThreadLocal = new ThreadLocal<List<MethodCall>>() {
        @Override
        protected ArrayList<MethodCall> initialValue() {
            return new ArrayList<>();
        }
    };
    
}

@Override
public MethodCall beforeMethod(Object target, Method method, String[] parameters, Object[] arguments) {
    // 排除掉各種非法攔截到的方法
    if (target == null) {
        return null;
    }
    String methodName = target.getClass().getName() + ":" + method.getName() + "()";
    Deque<MethodCall> methodCallStack = methodStackThreadLocal.get();
    // 當(dāng)前方法進(jìn)入整個(gè)方法調(diào)用棧的順序
    int methodEnterOrder = methodEnterStackOrderThreadLocal.get().addAndGet(1);
    // 當(dāng)前方法在整個(gè)方法棧中的深度
    int methodInStackDepth = methodCallStack.size() + 1;


    MethodCall methodCall = MethodCall.Default.of()
            .setMethodName(methodName)
            .setCallTime(System.nanoTime())
            .setThreadName(Thread.currentThread().getName())
            .setCurrentMethodEnterStackOrder(methodEnterOrder)
            .setCurrentMethodInStackDepth(methodInStackDepth);
    // 將當(dāng)前方法的調(diào)用信息壓入調(diào)用棧
    methodCallStack.push(methodCall);
    return methodCall;
}

@Override
public void afterMethod(MethodCall transmitResult, Object originResult) {
    if (target == null) {
        return null;
    }
    Deque<MethodCall> methodCallStack = methodStackThreadLocal.get();
    MethodCall lastMethodCall = methodCallStack.pop();
    // 毫秒單位的耗時(shí)
    double costTimeInMills = (double) (System.nanoTime() - lastMethodCall.getCallTime()) / 1000000.0;
    lastMethodCall.setCostInMills(costTimeInMills);


    List<MethodCall> methodCallList = methodCallThreadLocal.get();
    methodCallList.add(lastMethodCall);
    // 如果堆?？樟?，則說明最頂層的方法已經(jīng)退出了
    if (methodCallStack.isEmpty()) {
        // 對(duì)方法調(diào)用列表進(jìn)行排序
        sortMethodCallList(methodCallList);
        // 獲取MethodCallHandler對(duì)MethodCall的信息進(jìn)行處理
        MethodCallHandler methodCallHandler = Configuration.Global.getGlobal().getMethodCallHandler();
        methodCallHandler.handle(methodCallList);


        // 方法退出時(shí)，將ThreadLocal中保存的內(nèi)容清空掉，而不是將ThreadLocal remove，
        // 因?yàn)槿绻看畏椒ㄍ顺鰰r(shí)，都將ThreadLocal都清空，當(dāng)下一個(gè)方法再進(jìn)入時(shí)又需要初始化新的ThreadLocal，性能會(huì)有損耗
        methodCallStack.clear();
        methodCallList.clear();
        // 將臨時(shí)保存的方法調(diào)用順序清空
        methodEnterStackOrderThreadLocal.get().set(0);
    }
}


private void sortMethodCallList(List<MethodCall> methodCallList) {
    methodCallList.sort(new Comparator<MethodCall>() {
        @Override
        public int compare(MethodCall o1, MethodCall o2) {
            // 根據(jù)每個(gè)方法進(jìn)入方法棧的順序進(jìn)行排序
            return Integer.compare(o1.getCurrentMethodEnterStackOrder(), o2.getCurrentMethodEnterStackOrder());
        }
    });
}

public class MethodCallExample {
    public void costTime1() {
        System.out.println("costTime1");
        randomSleep();
        innerCostTime1();
    }
    public void costTime2() {
        System.out.println("costTime2");
        randomSleep();
        innerCostTime2();
    }
    public void costTime3() {
        System.out.println("costTime3");
        randomSleep();
    }
    public void innerCostTime1() {
        System.out.println("innerCostTime1");
        randomSleep();
    }
    public void innerCostTime2() {
        System.out.println("innerCostTime2");
        randomSleep();
    }
    private void randomSleep() {
        Random random = new Random();
        try {
            Thread.sleep(random.nextInt(100));
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

public static void main(String[] args) {
    MethodCallPlugin plugin = new MethodCallPlugin(Collections.singletonList("com.shizhuang.duapp.enhancer.example"), null);
    Enhancer enhancer = Enhancer.Default.INSTANCE;
    enhancer.enhance(Configuration.of().setPlugins(Collections.singletonList(plugin)));


    MethodCallExample example = new MethodCallExample();
    example.costTime1();
    example.costTime2();
    example.costTime3();
        
    try {
        // 這里主要是防止主線程提前結(jié)束
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

private void randomSleep() {
    new Thread(() -> {
        Random random = new Random();
        try {
            Thread.sleep(random.nextInt(100));
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }).start();
}

再次執(zhí)行后，得到如下的結(jié)果：

private void randomSleep() {
    new Thread(() -> {
        doSleep();
    }).start();
}


private void doSleep() {
    Random random = new Random();
    try {
        Thread.sleep(random.nextInt(100));
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

/**
 * 鏈路追蹤器
 *
 * @auther houyi.wh
 * @date 2023-08-22 14:59:50
 * @since 0.0.1
 */
public interface Tracer {


    /**
     * 獲取鏈路id
     *
     * @return 鏈路id
     * @since 0.0.1
     */
    String getTraceId();


    /**
     * 一個(gè)空的實(shí)現(xiàn)類
     * @since 0.0.1
     */
    enum Empty implements Tracer {
        INSTANCE;


        @Override
        public String getTraceId() {
            return "";
        }
    }
}

// 啟動(dòng)代碼增強(qiáng)
Enhancer enhancer = Enhancer.Default.INSTANCE;
Configuration config = Configuration.of()
      // 指定自定義的Tracer
      .setTracer(yourTracer)
      .xxx() // 其他配置項(xiàng)
      ;
enhancer.enhance(config);

/*
 * 因?yàn)?JVM 的 JIT 機(jī)制的存在，如果某個(gè)函數(shù)被調(diào)用多次之后，JVM 會(huì)嘗試將其編譯成為機(jī)器碼從而提高執(zhí)行速度。
 * 所以為了讓 benchmark 的結(jié)果更加接近真實(shí)情況就需要進(jìn)行預(yù)熱
 * 其中的參數(shù) iterations 是預(yù)熱輪數(shù)
 */
@Warmup(iterations = 1)
/*
 * 基準(zhǔn)測(cè)試的類型：
 * Throughput：吞吐量，指1s內(nèi)可以執(zhí)行多少次操作
 * AverageTime：調(diào)用時(shí)間，指1次調(diào)用所耗費(fèi)的時(shí)間
 */
@BenchmarkMode({Mode.AverageTime, Mode.Throughput})
/*
 * 測(cè)試的一些度量
 * iterations：進(jìn)行測(cè)試的輪次
 * time：每輪進(jìn)行的時(shí)長(zhǎng)
 * timeUnit：時(shí)長(zhǎng)單位
 */
@Measurement(iterations = 2, time = 1)
/*
 * 基準(zhǔn)測(cè)試結(jié)果的時(shí)間類型。一般選擇秒、毫秒、微秒。
 */
@OutputTimeUnit(TimeUnit.MILLISECONDS)
/*
 * fork出幾個(gè)進(jìn)場(chǎng)進(jìn)行測(cè)試。
 * 如果 fork 數(shù)是 2 的話，則 JMH 會(huì) fork 出兩個(gè)進(jìn)程來進(jìn)行測(cè)試。
 */
@Fork(value = 2)
/*
 * 每個(gè)進(jìn)程中測(cè)試線程的個(gè)數(shù)。
 */
@Threads(8)
/*
 * State 用于聲明某個(gè)類是一個(gè)“狀態(tài)”，然后接受一個(gè) Scope 參數(shù)用來表示該狀態(tài)的共享范圍。
 * 因?yàn)楹芏?benchmark 會(huì)需要一些表示狀態(tài)的類，JMH 允許你把這些類以依賴注入的方式注入到 benchmark 函數(shù)里。
 * Scope 主要分為三種：
 * Thread - 該狀態(tài)為每個(gè)線程獨(dú)享。
 * Group - 該狀態(tài)為同一個(gè)組里面所有線程共享。
 * Benchmark - 該狀態(tài)在所有線程間共享。
 */
@State(Scope.Benchmark)
public class MethodCallInterceptorBench {


    private MethodCallInterceptor methodCallInterceptor;
    private Object target;
    private Method method;
    private String[] parameters;
    private Object[] arguments;


    @Setup
    public void prepare() {
        methodCallInterceptor = new MethodCallInterceptor();
        target = new MethodCallExample();
        try {
            method = target.getClass().getMethod("costTime1");
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
        parameters = null;
        arguments = null;
    }


    @Benchmark
    public void testMethodCallInterceptor_beforeMethod() {
        methodCallInterceptor.beforeMethod(target, method, parameters, arguments);
    }


    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(MethodCallInterceptorBench.class.getSimpleName())
                .build();


        new Runner(opt).run();
    }


}

基準(zhǔn)測(cè)試的結(jié)果如下：

<dependency>
    <groupId>com.shizhuang.duapp</groupId>
    <artifactId>commodity-common-enhancer</artifactId>
    <version>${commodity-common-enhancer-version}</version>
</dependency>

public class CommodityAdminApplication {
    public static void main(String[] args) {
        SpringApplication.run(CommodityAdminApplication.class, args);
        // 啟動(dòng)代碼增強(qiáng)
        Enhancer enhancer = Enhancer.Default.INSTANCE;
        enhancer.enhance(null);
    }
}

public class CommodityAdminApplication {
    public static void main(String[] args) {
        SpringApplication.run(CommodityAdminApplication.class, args);
        // 啟動(dòng)代碼增強(qiáng)
        Enhancer enhancer = Enhancer.Default.INSTANCE;
        Configuration config = Configuration.of()
              .setPlugins(Collections.singletonList(plugin))
              .xxx() // 其他配置項(xiàng)
              ;
        enhancer.enhance(config);
    }
}

enum MyCustomHandler implements MethodCallHandler {
    INSTANCE;
    
    private double maxCostTime() {
        // 這里可以通過動(dòng)態(tài)配置想要分析的方法耗時(shí)的最小值
        return 500;
    }


    @Override
    public void handle(List<MethodCall> methodCallList) {
        logger.info("=========================================================================");
        // 檢查方法耗時(shí)超過xx時(shí)，才打印
        MethodCall firstMethodCall = methodCallList.stream().findFirst().orElse(null);
        if (firstMethodCall == null) {
            return;
        }
        // 方法耗時(shí)
        double costInMills = firstMethodCall.getCostInMills();
        int currentMethodEnterStackOrder = firstMethodCall.getCurrentMethodEnterStackOrder();
        // 如果整體的方法小于500毫秒，則直接放棄
        if (currentMethodEnterStackOrder == 1 && costInMills < maxCostTime()) {
            return;
        }
        // 然后在這里實(shí)現(xiàn)方法耗時(shí)的打印
        logger.info(getMethodCallInfo(methodCallList));
    }
}

/**
 * 是否停止采集MethodCall的開關(guān)
 *
 * @auther houyi.wh
 * @date 2023-08-27 18:56:47
 * @since 0.0.1
 */
public interface MethodCallSwitcher {


    /**
     * 是否停止對(duì)方法的MethodCall的采集
     * 如果返回true，則會(huì)停止對(duì)方法MethodCall的采集
     *
     * @return true：停止采集 false：繼續(xù)采集
     */
    boolean stopScratch();


    /**
     * 永遠(yuǎn)不停止采集
     */
    enum NeverStop implements MethodCallSwitcher {
        INSTANCE;


        @Override
        public boolean stopScratch() {
            // 一直進(jìn)行采集
            return false;
        }
    }


}

public MyCustomePlugin extends EnhancedPlugin {
    
    @Override
    public ElementMatcher.Junction<TypeDescription> typeMatcher() {
      // 實(shí)現(xiàn)類型匹配
    }
    
    @Override
    public ElementMatcher.Junction<MethodDescription> methodMatcher() {
      // 實(shí)現(xiàn)方法匹配
    }
    
    @Override
    public Class<? extends Interceptor> interceptorClass() {
      // 指定攔截器
      return MyInterceptor.class;
    }
}

通過如下方式實(shí)現(xiàn)自定義攔截器：

// 臨時(shí)傳遞數(shù)據(jù)的對(duì)象
public class Carrier {


}


public class MyInterceptor implements InstanceMethodInterceptor<Carrier> {


    @Override
    public Carrier beforeMethod(Object target, Method method, String[] parameters, Object[] arguments) {
         // 實(shí)現(xiàn)方法調(diào)用前攔截
    }
    @Override
    public void afterMethod(Carrier transmitResult, Object originResult) {
        // 實(shí)現(xiàn)方法調(diào)用后攔截
    }
}

public class CommodityAdminApplication {
    public static void main(String[] args) {
        SpringApplication.run(CommodityAdminApplication.class, args);
        // 啟動(dòng)代碼增強(qiáng)
        Enhancer enhancer = Enhancer.Default.INSTANCE;
        Configuration config = Configuration.of()
              // 指定自定義的插件
              .setPlugins(Collections.singletonList(new MyCustomePlugin()))
              .xxx() // 其他配置項(xiàng)
              ;
        enhancer.enhance(config);
    }
}