Java Interceptor如何管理

在Java中，拦截器（Interceptor）是一种设计模式，用于在不修改原始类的情况下，对方法调用进行拦截和处理。拦截器通常用于实现横切关注点（cross-cutting concerns），例如日志记录、事务管理、安全检查等。在Java中，拦截器可以通过多种方式实现，例如使用动态代理、AOP框架（如Spring AOP）等。

以下是使用Java动态代理实现拦截器的一种方法：

1. 定义一个接口，包含需要拦截的方法：

public interface MyInterface {
    void doSomething();
}

2. 实现该接口，并编写具体的业务逻辑：

public class MyInterfaceImpl implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("MyInterfaceImpl: doSomething");
    }
}

3. 创建一个实现了InvocationHandler接口的拦截器类：

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

public class MyInterceptor implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}

4. 使用Proxy.newProxyInstance()方法创建代理对象，并将拦截器作为参数传入：

import java.lang.reflect.Proxy;

public class Main {
    public static void main(String[] args) {
        MyInterface target = new MyInterfaceImpl();
        MyInterceptor interceptor = new MyInterceptor(target);
        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                interceptor
        );
        proxy.doSomething();
    }
}

运行上述代码，将看到以下输出：

Before method: doSomething
MyInterfaceImpl: doSomething
After method: doSomething

这样，我们就实现了一个简单的拦截器，可以在方法调用前后执行自定义的操作。在实际项目中，可以根据需要使用更高级的AOP框架来管理拦截器，例如Spring AOP。