Java Interceptor 拦截器如何实现

在Java中，拦截器（Interceptor）通常用于在方法调用前后执行一些额外的逻辑，比如日志记录、事务管理、权限检查等。拦截器可以通过多种方式实现，这里我将介绍两种常见的方法：使用Java代理（Proxy）和使用面向切面编程（AOP）框架，如Spring AOP。

方法一：使用Java代理（Proxy）

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 InterceptorExample {
    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();
    }
}

在这个例子中，MyInvocationHandler 类实现了 InvocationHandler 接口，并在 invoke 方法中添加了拦截逻辑。当我们通过代理对象调用 doSomething 方法时，会先执行拦截器中的逻辑，然后调用实际的方法。

方法二：使用Spring AOP

Spring AOP是Spring框架提供的一个面向切面编程的实现，它可以让你在不修改原有代码的情况下，通过声明式的方式添加横切关注点（cross-cutting concerns）。

以下是一个使用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 />

<bean id="myAspect" class="com.example.MyAspect" />
<bean id="myService" class="com.example.MyServiceImpl" />

最后，定义一个服务接口和其实现：

package com.example;

public interface MyService {
    void doSomething();
}

package com.example;

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

现在，当你调用 MyService 的 doSomething 方法时，Spring AOP会自动应用 MyAspect 中定义的拦截逻辑。

这两种方法都可以实现拦截器的功能，选择哪一种取决于你的具体需求和项目环境。如果你的项目中已经使用了Spring框架，那么使用Spring AOP会更加方便。如果你需要一个更轻量级的解决方案，或者不想引入额外的框架依赖，那么Java代理可能是一个更好的选择。