Java Interceptor如何使用

在Java中，拦截器（Interceptor）通常用于在方法调用前后执行一些额外的逻辑，例如日志记录、事务管理、权限检查等。拦截器可以通过多种方式实现，比如使用动态代理、AOP（面向切面编程）框架（如Spring AOP）或者在Servlet API中使用过滤器（Filter）。

以下是使用这些不同方法实现拦截器的基本示例：

1. 使用动态代理

动态代理是一种在运行时创建代理对象的技术，可以在方法调用前后添加额外的逻辑。

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

interface MyInterface {
    void doSomething();
}

class MyInterfaceImpl implements MyInterface {
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

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 DynamicProxyExample {
    public static void main(String[] args) {
        MyInterface target = new MyInterfaceImpl();
        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new MyInvocationHandler(target)
        );
        proxy.doSomething();
    }
}

2. 使用Spring AOP

Spring AOP允许你定义切面（Aspect），在方法执行前后插入通知（Advice）。

首先，你需要在你的项目中添加Spring AOP依赖。

<!-- Maven dependency for Spring AOP -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.3.10</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
</dependency>

然后，你可以定义一个切面：

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 execution");
    }

    @After("execution(* com.example.MyService.*(..))")
    public void afterMethod() {
        System.out.println("After method execution");
    }
}

最后，确保你的Spring配置启用了AOP自动代理：

@Configuration
@EnableAspectJAutoProxy
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    // ... other bean definitions ...
}

3. 使用Servlet Filter

在Web应用程序中，你可以使用Servlet Filter来拦截HTTP请求。

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 {
        // Initialization code, if needed
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        System.out.println("Before request processing");
        
        chain.doFilter(request, response); // Continue processing the request
        
        System.out.println("After request processing");
    }

    @Override
    public void destroy() {
        // Cleanup code, if needed
    }
}

然后在web.xml中配置Filter：

<filter>
    <filter-name>MyFilter</filter-name>
    <filter-class>com.example.MyFilter</filter-class>
</filter>

<filter-mapping>
    <filter-name>MyFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

这些是实现拦截器的几种常见方法。选择哪种方法取决于你的具体需求和项目环境。