如何配置Java Interceptor

在Java中，拦截器（Interceptor）通常用于在方法调用前后执行一些额外的逻辑，比如日志记录、事务管理、安全检查等。拦截器可以通过多种方式实现，例如使用动态代理、AOP（面向切面编程）框架等。下面是一些常见的配置拦截器的方法：

1. 使用Java动态代理

Java标准库提供了动态代理机制，可以用来创建实现了特定接口的代理对象。以下是一个简单的例子：

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("MyInterfaceImpl: 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: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}

public class DynamicProxyExample {
    public static void main(String[] args) {
        MyInterface target = new MyInterfaceImpl();
        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
            MyInterface.class.getClassLoader(),
            new Class<?>[] { MyInterface.class },
            new MyInvocationHandler(target)
        );
        proxy.doSomething();
    }
}

2. 使用Spring AOP

Spring框架提供了强大的AOP功能，可以通过配置或者注解的方式来定义拦截器。以下是使用注解配置的一个例子：

首先，定义一个切面（Aspect）：

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和组件扫描：

<aop:aspectj-autoproxy />
<context:component-scan base-package="com.example" />

最后，确保你的服务类被Spring管理：

import org.springframework.stereotype.Service;

@Service
public class MyService {
    public void doSomething() {
        System.out.println("MyService: doSomething");
    }
}

3. 使用JAX-RS拦截器

如果你在使用JAX-RS（Java API for RESTful Web Services），可以通过实现ContainerRequestFilter和ContainerResponseFilter接口来创建拦截器：

import javax.ws.rs.container.ContainerRequestContext;
import javax.ws.rs.container.ContainerRequestFilter;
import javax.ws.rs.container.ContainerResponseContext;
import javax.ws.rs.container.ContainerResponseFilter;
import javax.ws.rs.ext.Provider;
import java.io.IOException;

@Provider
public class LoggingFilter implements ContainerRequestFilter, ContainerResponseFilter {

    @Override
    public void filter(ContainerRequestContext requestContext) throws IOException {
        System.out.println("Request: " + requestContext.getMethod() + " " + requestContext.getUriInfo().getRequestUri());
    }

    @Override
    public void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext) throws IOException {
        System.out.println("Response: " + responseContext.getStatus());
    }
}

确保你的应用扫描到了这个类，它就会被自动注册为拦截器。

这些只是配置拦截器的几种方式。具体使用哪种方式取决于你的应用需求和所使用的框架。