Interceptor 在 Java 中如何工作

在Java中，拦截器（Interceptor）是一种设计模式，用于在不修改原始类代码的情况下，对方法的调用进行拦截和处理

拦截器的工作原理如下：

1. 定义一个接口：首先，需要定义一个接口，该接口包含要拦截的方法。这些方法将被拦截器在实际调用之前和之后执行。

public interface MyInterceptor {
    void beforeMethod();
    void afterMethod();
}

2. 实现拦截器接口：接下来，创建一个实现上述接口的类，这个类将包含实际执行拦截逻辑的代码。

public class MyInterceptorImpl implements MyInterceptor {
    @Override
    public void beforeMethod() {
        System.out.println("Before method execution");
    }

    @Override
    public void afterMethod() {
        System.out.println("After method execution");
    }
}

3. 创建拦截器管理器：为了在运行时动态地添加、删除或替换拦截器，需要创建一个拦截器管理器。这个管理器将负责维护一个拦截器列表，并在需要时调用相应的拦截器方法。

import java.util.ArrayList;
import java.util.List;

public class InterceptorManager {
    private List<MyInterceptor> interceptors = new ArrayList<>();

    public void addInterceptor(MyInterceptor interceptor) {
        interceptors.add(interceptor);
    }

    public void removeInterceptor(MyInterceptor interceptor) {
        interceptors.remove(interceptor);
    }

    public void executeBeforeMethod(Object target, String methodName) {
        for (MyInterceptor interceptor : interceptors) {
            interceptor.beforeMethod();
        }
    }

    public void executeAfterMethod(Object target, String methodName) {
        for (int i = interceptors.size() - 1; i >= 0; i--) {
            interceptors.get(i).afterMethod();
        }
    }
}

4. 使用拦截器：现在可以在需要拦截方法的地方使用拦截器管理器。首先，创建一个实现接口的类，并在其方法中使用拦截器管理器。

public class MyClass implements MyInterface {
    private InterceptorManager interceptorManager = new InterceptorManager();

    public MyClass(MyInterceptor interceptor) {
        interceptorManager.addInterceptor(interceptor);
    }

    @Override
    public void myMethod() {
        interceptorManager.executeBeforeMethod(this, "myMethod");
        System.out.println("Inside myMethod");
        interceptorManager.executeAfterMethod(this, "myMethod");
    }
}

5. 测试拦截器：最后，可以创建一个测试类来验证拦截器是否按预期工作。

public class TestInterceptor {
    public static void main(String[] args) {
        MyInterceptor interceptor = new MyInterceptorImpl();
        MyClass obj = new MyClass(interceptor);
        obj.myMethod();
    }
}

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

Before method execution
Inside myMethod
After method execution

这表明拦截器已成功地在方法调用之前和之后执行。通过这种方式，可以在不修改原始类代码的情况下，为方法添加额外的处理逻辑。