Java Interceptor拦截器如何部署

在Java中，拦截器（Interceptor）通常用于在方法调用前后执行一些额外的逻辑，例如日志记录、性能监控、权限检查等。拦截器可以通过多种方式实现，例如使用动态代理、AOP（面向切面编程）框架等。下面是一个简单的示例，展示如何使用Spring AOP实现一个拦截器并将其部署到Spring应用中。

1. 创建拦截器类

首先，创建一个拦截器类，实现MethodInterceptor接口。

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class LoggingInterceptor implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("Before method: " + invocation.getMethod().getName());
        Object result = invocation.proceed();
        System.out.println("After method: " + invocation.getMethod().getName());
        return result;
    }
}

2. 配置Spring AOP

接下来，配置Spring AOP以使用拦截器。你可以使用XML配置或Java配置。

使用Java配置

创建一个配置类，启用AOP并定义拦截器。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.After;

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {

    @Bean
    public LoggingInterceptor loggingInterceptor() {
        return new LoggingInterceptor();
    }

    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }

    @Bean
    public LoggingAspect loggingAspect(LoggingInterceptor loggingInterceptor) {
        return new LoggingAspect(loggingInterceptor);
    }
}

@Aspect
class LoggingAspect {

    private final LoggingInterceptor loggingInterceptor;

    public LoggingAspect(LoggingInterceptor loggingInterceptor) {
        this.loggingInterceptor = loggingInterceptor;
    }

    @Pointcut("execution(* com.example.MyService.*(..))")
    public void serviceMethods() {}

    @Before("serviceMethods()")
    public void beforeServiceMethod(JoinPoint joinPoint) {
        loggingInterceptor.invoke(joinPoint);
    }

    @After("serviceMethods()")
    public void afterServiceMethod(JoinPoint joinPoint) {
        loggingInterceptor.invoke(joinPoint);
    }
}

使用XML配置

创建一个Spring XML配置文件，启用AOP并定义拦截器。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="loggingInterceptor" class="com.example.LoggingInterceptor"/>

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

    <aop:config>
        <aop:aspect id="loggingAspect" ref="loggingInterceptor">
            <aop:pointcut id="serviceMethods" expression="execution(* com.example.MyService.*(..))"/>
            <aop:before pointcut-ref="serviceMethods" method="invoke"/>
            <aop:after pointcut-ref="serviceMethods" method="invoke"/>
        </aop:aspect>
    </aop:config>
</beans>

3. 创建服务类

创建一个简单的服务类，用于测试拦截器。

package com.example;

public class MyServiceImpl implements MyService {

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

4. 创建服务接口

创建一个服务接口，服务类将实现该接口。

package com.example;

public interface MyService {
    void doSomething();
}

5. 运行应用

最后，运行你的Spring应用，调用服务方法，观察拦截器的效果。

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

运行上述代码，你将看到拦截器在方法调用前后打印日志。

通过这种方式，你可以轻松地将拦截器部署到Spring应用中，并在方法调用前后执行自定义逻辑。