Java Interceptor如何集成

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

1. 使用Spring AOP

Spring框架提供了强大的面向切面编程（AOP）功能，可以很方便地实现拦截器。

步骤：

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 logBefore(JoinPoint joinPoint) {
           System.out.println("Before method: " + joinPoint.getSignature().getName());
       }
   
       @After("execution(* com.example.service.*.*(..))")
       public void logAfter(JoinPoint joinPoint) {
           System.out.println("After method: " + joinPoint.getSignature().getName());
       }
   }
   

2. 配置Spring AOP： 在Spring配置文件中启用AOP自动代理：

   <aop:aspectj-autoproxy />
   

3. 定义业务逻辑类：

   import org.springframework.stereotype.Service;
   
   @Service
   public class MyService {
       public void doSomething() {
           System.out.println("Doing something...");
       }
   }
   

4. 测试：

   import org.springframework.context.ApplicationContext;
   import org.springframework.context.support.ClassPathXmlApplicationContext;
   
   public class Main {
       public static void main(String[] args) {
           ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
           MyService myService = context.getBean(MyService.class);
           myService.doSomething();
       }
   }
   

2. 使用Java EE拦截器

Java EE提供了拦截器机制，可以在EJB或CDI中使用。

步骤：

1. 定义拦截器类：

   import javax.interceptor.AroundInvoke;
   import javax.interceptor.InvocationContext;
   
   public class LoggingInterceptor {
   
       @AroundInvoke
       public Object logAround(InvocationContext ctx) throws Exception {
           System.out.println("Before method: " + ctx.getMethod().getName());
           try {
               return ctx.proceed();
           } finally {
               System.out.println("After method: " + ctx.getMethod().getName());
           }
       }
   }
   

2. 定义业务逻辑类：

   import javax.ejb.Stateless;
   
   @Stateless
   public class MyBean {
   
       public void doSomething() {
           System.out.println("Doing something...");
       }
   }
   

3. 配置拦截器： 在ejb-jar.xml中配置拦截器：

   <ejb-jar>
       <enterprise-beans>
           <session>
               <ejb-name>MyBean</ejb-name>
               <ejb-class>com.example.MyBean</ejb-class>
               <interceptors>
                   <interceptor-class>com.example.LoggingInterceptor</interceptor-class>
               </interceptors>
           </session>
       </enterprise-beans>
   </ejb-jar>
   

4. 测试： 使用EJB容器（如WildFly、GlassFish）部署并测试。

3. 使用自定义注解和反射

可以通过自定义注解和反射机制实现拦截器。

步骤：

1. 定义注解：

   import java.lang.annotation.Retention;
   import java.lang.annotation.RetentionPolicy;
   
   @Retention(RetentionPolicy.RUNTIME)
   public @interface Loggable {
   }
   

2. 定义拦截器类：

   import java.lang.reflect.Method;
   
   public class LoggingInterceptor {
   
       public static void intercept(Object target) {
           Class<?> clazz = target.getClass();
           for (Method method : clazz.getDeclaredMethods()) {
               if (method.isAnnotationPresent(Loggable.class)) {
                   try {
                       System.out.println("Before method: " + method.getName());
                       method.invoke(target);
                       System.out.println("After method: " + method.getName());
                   } catch (Exception e) {
                       e.printStackTrace();
                   }
               }
           }
       }
   }
   

3. 定义业务逻辑类：

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

4. 测试：

   public class Main {
       public static void main(String[] args) {
           MyService myService = new MyService();
           LoggingInterceptor.intercept(myService);
       }
   }
   

以上是几种常见的Java拦截器集成方法，具体选择哪种方法取决于你的项目需求和技术栈。