如何实现Java Interceptor

在Java中，拦截器（Interceptor）通常用于在方法调用前后执行一些额外的逻辑，比如日志记录、事务管理、权限检查等。拦截器可以通过多种方式实现，以下是一些常见的方法：

1. 使用Java代理（Proxy）: Java提供了动态代理机制，可以在运行时创建一个实现了一组接口的新类。这个新类会将所有方法调用转发给一个InvocationHandler，你可以在这个处理器中添加拦截逻辑。

   import java.lang.reflect.InvocationHandler;
   import java.lang.reflect.Method;
   import java.lang.reflect.Proxy;
   
   interface MyInterface {
       void doSomething();
   }
   
   class MyInvocationHandler implements InvocationHandler {
       private Object target;
   
       public MyInvocationHandler(Object target) {
           this.target = target;
       }
   
       @Override
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           // 在方法调用前的逻辑
           System.out.println("Before method call");
   
           // 调用目标方法
           Object result = method.invoke(target, args);
   
           // 在方法调用后的逻辑
           System.out.println("After method call");
   
           return result;
       }
   }
   
   public class InterceptorExample {
       public static void main(String[] args) {
           MyInterface target = new MyInterface() {
               @Override
               public void doSomething() {
                   System.out.println("Doing something");
               }
           };
   
           MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
                   MyInterface.class.getClassLoader(),
                   new Class<?>[]{MyInterface.class},
                   new MyInvocationHandler(target)
           );
   
           proxy.doSomething();
       }
   }
   

2. 使用Spring AOP: 如果你在使用Spring框架，可以利用Spring AOP（面向切面编程）来实现拦截器。通过定义一个切面（Aspect），你可以在不修改原有代码的情况下，增加横切关注点（cross-cutting concerns）。

   import org.aspectj.lang.annotation.Aspect;
   import org.aspectj.lang.annotation.Before;
   import org.aspectj.lang.annotation.After;
   
   @Aspect
   public class MyAspect {
   
       @Before("execution(* com.example.MyService.*(..))")
       public void beforeMethod() {
           System.out.println("Before method call");
       }
   
       @After("execution(* com.example.MyService.*(..))")
       public void afterMethod() {
           System.out.println("After method call");
       }
   }
   

   然后在Spring配置中启用AOP和你的切面。

3. 使用Servlet Filter: 如果你的拦截器是用于Web应用程序，并且想要拦截HTTP请求，可以使用Servlet Filter。

   import javax.servlet.*;
   import javax.servlet.http.HttpServletRequest;
   import java.io.IOException;
   
   public class MyFilter implements Filter {
   
       @Override
       public void init(FilterConfig filterConfig) throws ServletException {
           // 初始化代码
       }
   
       @Override
       public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
           HttpServletRequest httpRequest = (HttpServletRequest) request;
           // 在请求处理前的逻辑
           System.out.println("Before request");
   
           // 继续处理请求
           chain.doFilter(request, response);
   
           // 在请求处理后的逻辑
           System.out.println("After request");
       }
   
       @Override
       public void destroy() {
           // 销毁代码
       }
   }
   

   然后在web.xml中配置这个Filter。

这些是实现Java拦截器的几种常见方式。选择哪种方式取决于你的具体需求和应用场景。