怎样实现自定义Java Interceptor

在Java中，拦截器（Interceptor）通常用于在方法调用前后执行一些额外的逻辑。这可以通过多种方式实现，例如使用动态代理、AOP（面向切面编程）框架等。下面是一个简单的示例，展示如何使用动态代理实现自定义的Java拦截器。

使用动态代理实现拦截器

1. 定义一个接口： 首先，定义一个接口，这个接口包含你想要拦截的方法。

   public interface MyService {
       void doSomething();
   }
   

2. 实现接口： 实现这个接口，创建一个具体的类。

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

3. 创建拦截器类： 创建一个实现了InvocationHandler接口的拦截器类。

   import java.lang.reflect.InvocationHandler;
   import java.lang.reflect.Method;
   
   public class MyInterceptor implements InvocationHandler {
       private Object target;
   
       public MyInterceptor(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;
       }
   }
   

4. 创建代理对象： 使用Proxy.newProxyInstance方法创建一个代理对象。

   import java.lang.reflect.Proxy;
   
   public class Main {
       public static void main(String[] args) {
           // 创建目标对象
           MyService target = new MyServiceImpl();
   
           // 创建拦截器
           MyInterceptor interceptor = new MyInterceptor(target);
   
           // 创建代理对象
           MyService proxy = (MyService) Proxy.newProxyInstance(
                   target.getClass().getClassLoader(),
                   target.getClass().getInterfaces(),
                   interceptor
           );
   
           // 调用代理对象的方法
           proxy.doSomething();
       }
   }
   

运行结果

当你运行上述代码时，输出将会是：

Before method: doSomething
Doing something...
After method: doSomething

使用AOP框架

如果你希望使用更高级的AOP框架来实现拦截器，可以考虑使用Spring AOP。以下是一个简单的示例：

1. 添加依赖： 在pom.xml中添加Spring AOP依赖。

   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-context</artifactId>
       <version>5.3.10</version>
   </dependency>
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-aop</artifactId>
       <version>5.3.10</version>
   </dependency>
   

2. 定义接口和实现类： 与前面的示例相同。

3. 创建切面类： 使用Spring AOP的@Aspect注解创建一个切面类。

   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 MyAspect {
   
       @Before("execution(* com.example.MyService.doSomething(..))")
       public void beforeMethod() {
           System.out.println("Before method: doSomething");
       }
   
       @After("execution(* com.example.MyService.doSomething(..))")
       public void afterMethod() {
           System.out.println("After method: doSomething");
       }
   }
   

4. 配置Spring上下文： 创建一个Spring配置类。

   import org.springframework.context.annotation.ComponentScan;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.context.annotation.EnableAspectJAutoProxy;
   
   @Configuration
   @ComponentScan(basePackages = "com.example")
   @EnableAspectJAutoProxy
   public class AppConfig {
   }
   

5. 运行示例： 使用Spring的AnnotationConfigApplicationContext来运行示例。

   import org.springframework.context.ApplicationContext;
   import org.springframework.context.annotation.AnnotationConfigApplicationContext;
   
   public class Main {
       public static void main(String[] args) {
           ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
           MyService myService = context.getBean(MyService.class);
           myService.doSomething();
       }
   }
   

运行结果

当你运行上述代码时，输出将会是：

Before method: doSomething
Doing something...
After method: doSomething

通过这种方式，你可以使用Spring AOP来实现更复杂和灵活的拦截逻辑。