拦截器在Java中怎么用

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

1. 使用Spring AOP（面向切面编程）

Spring AOP是Spring框架提供的一个强大的功能，可以用来实现拦截器。通过定义切面（Aspect）和通知（Advice），可以在方法调用前后插入自定义逻辑。

示例：

1. 定义切面类

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 beforeMethod(JoinPoint joinPoint) {
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }

    @After("execution(* com.example.service.*.*(..))")
    public void afterMethod(JoinPoint joinPoint) {
        System.out.println("After method: " + joinPoint.getSignature().getName());
    }
}

2. 配置Spring AOP

确保你的Spring配置文件或Java配置类中启用了AOP支持。

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
}

3. 使用切面

在你的服务类中，Spring会自动应用切面逻辑。

import org.springframework.stereotype.Service;

@Service
public class MyService {

    public void doSomething() {
        System.out.println("Doing something in MyService");
    }
}

2. 使用Java动态代理

Java动态代理可以在运行时创建一个代理对象，拦截对目标对象方法的调用。

示例：

1. 定义接口

public interface MyService {
    void doSomething();
}

2. 实现接口

public class MyServiceImpl implements MyService {
    @Override
    public void doSomething() {
        System.out.println("Doing something in MyServiceImpl");
    }
}

3. 创建代理类

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

public class MyServiceProxy implements InvocationHandler {

    private Object target;

    public MyServiceProxy(Object target) {
        this.target = target;
    }

    public static Object newProxyInstance(Object target) {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new MyServiceProxy(target)
        );
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}

4. 使用代理对象

public class Main {
    public static void main(String[] args) {
        MyService target = new MyServiceImpl();
        MyService proxy = (MyService) MyServiceProxy.newProxyInstance(target);
        proxy.doSomething();
    }
}

3. 使用Servlet过滤器

在Web应用中，可以使用Servlet过滤器来拦截HTTP请求和响应。

示例：

1. 定义过滤器类

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() {
        // 销毁逻辑
    }
}

2. 配置过滤器

在web.xml中配置过滤器。

<filter>
    <filter-name>LoggingFilter</filter-name>
    <filter-class>com.example.LoggingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>LoggingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

通过这些方法，你可以在Java应用中实现拦截器，根据具体需求选择合适的方式。