Java Interceptor如何扩展

在Java中，拦截器（Interceptor）通常用于在方法调用前后执行一些额外的逻辑。这种模式在AOP（面向切面编程）中非常常见。要扩展一个Java拦截器，你可以遵循以下步骤：

1. 定义拦截器接口： 首先，你需要定义一个拦截器接口，该接口包含一个方法，例如intercept，该方法将在目标方法调用前后执行。

   public interface Interceptor {
       Object intercept(Invocation invocation) throws Throwable;
   }
   

2. 创建拦截器实现类： 实现你定义的拦截器接口，并在intercept方法中编写你的逻辑。

   public class LoggingInterceptor implements Interceptor {
       @Override
       public Object intercept(Invocation invocation) throws Throwable {
           System.out.println("Before method: " + invocation.getMethodName());
           Object result = invocation.proceed(); // 调用目标方法
           System.out.println("After method: " + invocation.getMethodName());
           return result;
       }
   }
   

3. 定义调用者接口： 定义一个调用者接口，该接口包含一个方法，例如invoke，该方法将接受一个拦截器作为参数。

   public interface Caller {
       Object invoke(Interceptor interceptor, Object... args) throws Throwable;
   }
   

4. 创建调用者实现类： 实现你定义的调用者接口，并在invoke方法中使用拦截器。

   public class MethodInvoker implements Caller {
       private final Object target;
   
       public MethodInvoker(Object target) {
           this.target = target;
       }
   
       @Override
       public Object invoke(Interceptor interceptor, Object... args) throws Throwable {
           Invocation invocation = new Invocation(target, args);
           return interceptor.intercept(invocation);
       }
   }
   

5. 定义调用上下文： 创建一个调用上下文类，用于存储调用者和拦截器的信息。

   public class Invocation {
       private final Object target;
       private final Object[] args;
   
       public Invocation(Object target, Object[] args) {
           this.target = target;
           this.args = args;
       }
   
       public Object getTarget() {
           return target;
       }
   
       public Object[] getArgs() {
           return args;
       }
   
       public Object proceed() throws Throwable {
           Method method = target.getClass().getMethod("someMethod", String.class); // 假设目标方法名为someMethod，参数类型为String
           return method.invoke(target, args);
       }
   }
   

6. 使用拦截器： 现在你可以使用拦截器来扩展你的代码了。

   public class Main {
       public static void main(String[] args) throws Throwable {
           MyService myService = new MyServiceImpl();
           Caller caller = new MethodInvoker(myService);
           Interceptor interceptor = new LoggingInterceptor();
           Object result = caller.invoke(interceptor, "Hello, World!");
           System.out.println("Result: " + result);
       }
   }
   

通过这种方式，你可以轻松地扩展拦截器，添加更多的逻辑，或者创建多个不同的拦截器来实现不同的功能。