如何创建可监听所有方法调用的Java监听器并动态修改逻辑？

嘿，我明白你想要的是能覆盖所有方法调用的监听逻辑，而不是只局限于TestNG的测试注解方法——TestNG的IInvokedMethodListener确实是绑定它自己的测试生命周期的，只对标注了@Test、@BeforeMethod这类TestNG专属注解的方法生效，所以没法满足全局方法监听的需求。这时候你需要用到Java的**面向切面编程（AOP）**技术，下面给你两种最实用的方案：

方案一：动态代理（适合基于接口的场景） #

动态代理是Java原生支持的轻量级AOP方式，适合你的类都实现了接口的情况。核心思路是通过代理对象包裹原始对象，在方法调用前后插入自定义逻辑。

步骤1：定义你的特定注解 #

首先先创建你要检查的自定义注解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyCheck {
    // 可以添加注解参数，比如描述信息
    String value() default "";
}

步骤2：实现InvocationHandler处理逻辑 #

创建一个InvocationHandler的实现类，在invoke方法里拦截所有方法调用，检查是否带有你的注解，再执行自定义逻辑：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MethodCheckHandler implements InvocationHandler {
    private final Object target; // 原始对象

    public MethodCheckHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 检查当前方法是否带有@MyCheck注解
        if (method.isAnnotationPresent(MyCheck.class)) {
            System.out.println("方法[" + method.getName() + "]带有@MyCheck注解，执行前置检查逻辑");
            // 这里可以添加你的自定义逻辑，比如参数校验、权限检查、逻辑修改等
            // 甚至可以修改args参数，改变方法的输入
        }

        // 执行原始方法
        Object result = method.invoke(target, args);

        // 如果你需要在方法调用后也执行逻辑，也可以在这里添加
        return result;
    }
}

步骤3：生成代理对象并使用 #

在调用目标对象方法时，通过Proxy.newProxyInstance生成代理对象，所有方法调用都会被拦截：

import java.lang.reflect.Proxy;

public class Main {
    public static void main(String[] args) {
        // 原始对象（假设实现了某个接口）
        MyService originalService = new MyServiceImpl();

        // 生成代理对象
        MyService proxyService = (MyService) Proxy.newProxyInstance(
                originalService.getClass().getClassLoader(),
                originalService.getClass().getInterfaces(),
                new MethodCheckHandler(originalService)
        );

        // 调用代理对象的方法，会触发拦截逻辑
        proxyService.normalMethod();
        proxyService.checkableMethod();
    }
}

// 示例接口和实现类
interface MyService {
    void normalMethod();

    @MyCheck("需要检查的方法")
    void checkableMethod();
}

class MyServiceImpl implements MyService {
    @Override
    public void normalMethod() {
        System.out.println("执行普通方法");
    }

    @Override
    public void checkableMethod() {
        System.out.println("执行需要检查的方法");
    }
}

方案二：AspectJ（支持所有类/方法，更强大） #

如果你需要监听的方法不在接口上（比如普通类的方法、私有方法），AspectJ是更好的选择——它支持编译时织入或运行时织入，能拦截几乎所有方法调用。

步骤1：定义自定义注解（和方案一的一样） #

// 同方案一的@MyCheck注解

步骤2：编写Aspect切面类 #

创建一个切面类，用@Around或@Before切点来匹配带有@MyCheck注解的方法：

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 MethodCheckAspect {
    // 定义切点：匹配所有带有@MyCheck注解的方法
    @Pointcut("@annotation(com.example.MyCheck)")
    public void checkableMethod() {}

    // 环绕通知，能在方法调用前后都执行逻辑，甚至修改返回值
    @Around("checkableMethod()")
    public Object aroundMethodCall(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取当前方法信息
        String methodName = joinPoint.getSignature().getName();
        System.out.println("方法[" + methodName + "]带有@MyCheck注解，执行前置检查逻辑");

        // 可以修改方法参数
        Object[] args = joinPoint.getArgs();
        // 比如修改第一个参数（如果有的话）
        // if (args.length > 0) args[0] = "modified value";

        // 执行原始方法
        Object result = joinPoint.proceed(args);

        // 方法调用后的逻辑
        System.out.println("方法[" + methodName + "]执行完成，返回值：" + result);

        // 甚至可以修改返回值
        // result = "modified result";
        return result;
    }
}

步骤3：配置AspectJ #

如果是Maven项目，需要添加AspectJ的依赖和编译插件（编译时织入）：

<!-- 依赖 -->
<dependencies>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.9.20</version>
    </dependency>
</dependencies>

<!-- 编译插件 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>aspectj-maven-plugin</artifactId>
            <version>1.14.0</version>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>
                        <goal>test-compile</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <source>17</source> <!-- 对应你的Java版本 -->
                <target>17</target>
                <complianceLevel>17</complianceLevel>
            </configuration>
        </plugin>
    </plugins>
</build>

如果是运行时织入，可以在JVM启动参数中添加：

-javaagent:/path/to/aspectjweaver-1.9.20.jar

两种方案对比 #

• 动态代理：Java原生支持，无需额外依赖，实现简单，但只能代理接口类，无法处理普通类的方法。
• AspectJ：功能强大，支持所有类（包括私有方法、静态方法），但需要额外依赖和配置，学习成本稍高。

根据你的实际场景选择合适的方案就好啦！

内容的提问来源于stack exchange，提问作者Javed Ahmed