Java Interceptor如何实现

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

1. 使用代理模式： 代理模式是实现拦截器的一种常见方式。你可以创建一个代理类，该代理类包含对目标对象的引用，并在调用目标对象的方法前后执行额外的逻辑。

   public interface TargetInterface {
       void doSomething();
   }
   
   public class TargetClass implements TargetInterface {
       @Override
       public void doSomething() {
           System.out.println("TargetClass is doing something.");
       }
   }
   
   public class ProxyClass implements TargetInterface {
       private TargetInterface target;
   
       public ProxyClass(TargetInterface target) {
           this.target = target;
       }
   
       @Override
       public void doSomething() {
           // 在调用目标方法前的逻辑
           System.out.println("ProxyClass is before calling doSomething.");
           target.doSomething();
           // 在调用目标方法后的逻辑
           System.out.println("ProxyClass is after calling doSomething.");
       }
   }
   

2. 使用动态代理： Java提供了java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来支持动态代理。动态代理可以在运行时创建代理对象，而不需要在编译时创建具体的代理类。

   import java.lang.reflect.InvocationHandler;
   import java.lang.reflect.Method;
   import java.lang.reflect.Proxy;
   
   public class DynamicProxyHandler implements InvocationHandler {
       private Object target;
   
       public DynamicProxyHandler(Object target) {
           this.target = target;
       }
   
       @Override
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           // 在调用目标方法前的逻辑
           System.out.println("DynamicProxyHandler is before calling " + method.getName());
           Object result = method.invoke(target, args);
           // 在调用目标方法后的逻辑
           System.out.println("DynamicProxyHandler is after calling " + method.getName());
           return result;
       }
   
       public static Object newProxyInstance(Object target) {
           return Proxy.newProxyInstance(
                   target.getClass().getClassLoader(),
                   target.getClass().getInterfaces(),
                   new DynamicProxyHandler(target)
           );
       }
   }
   

3. 使用AOP框架： 面向切面编程（AOP）框架如Spring AOP可以更方便地实现拦截器。在Spring AOP中，你可以通过定义切面（Aspect）和通知（Advice）来实现方法调用的拦截。

   import org.aspectj.lang.annotation.Aspect;
   import org.aspectj.lang.annotation.Before;
   import org.aspectj.lang.annotation.After;
   import org.springframework.stereotype.Component;
   
   @Aspect
   @Component
   public class LoggingAspect {
   
       @Before("execution(* com.example.service.*.*(..))")
       public void beforeMethodCall() {
           System.out.println("Before method call.");
       }
   
       @After("execution(* com.example.service.*.*(..))")
       public void afterMethodCall() {
           System.out.println("After method call.");
       }
   }
   

   在上面的例子中，@Before和@After注解分别定义了在目标方法调用前后的通知。

4. 使用Servlet过滤器： 如果你在开发Web应用程序，可以使用Servlet过滤器（Filter）来拦截HTTP请求和响应。

   import javax.servlet.*;
   import javax.servlet.http.HttpServletRequest;
   import java.io.IOException;
   
   public class LoggingFilter 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: " + httpRequest.getRequestURI());
           chain.doFilter(request, response);
           System.out.println("After request: " + httpRequest.getRequestURI());
       }
   
       @Override
       public void destroy() {
           // 销毁代码
       }
   }
   

   在web.xml中配置过滤器，或者使用@WebFilter注解来声明过滤器。

这些是实现拦截器的几种常见方式，具体选择哪种方式取决于你的应用场景和个人偏好。