Spring AOP拦截器实战：从基础到深入-CSDN博客

本文链接：https://blog.csdn.net/weixin_35706255/article/details/148258975

简介：Spring AOP（面向切面编程）通过代理机制扩展和增强程序，而不改变源代码。本例介绍了如何实现一个简单的AOP拦截器，涵盖核心概念、工作原理及实际应用。通过定义切面、创建通知、配置代理、注册拦截器、定义切点表达式、关联切面与切点，以及进行测试验证，实现程序的横切关注点如日志记录、事务管理等的拦截。深入了解AOP，有助于提高代码的可维护性和可扩展性。

1. Spring AOP核心概念介绍

在软件开发中，关注点的模块化是提高代码维护性和可重用性的重要手段。面向切面编程（Aspect-Oriented Programming, AOP）正是为此而设计的一种编程范式。Spring AOP作为Spring框架的一部分，提供了一种简洁的方式来实现AOP，它依赖于动态代理模式来拦截方法调用，并在方法执行前后的关键时刻插入额外的行为。核心概念包括切面（Aspect）、连接点（Join Point）、通知（Advice）、切点（Pointcut）等，它们共同构成了AOP的骨架。

本章节将从浅入深地探讨Spring AOP的基础，为接下来更深入地了解拦截器实现和AOP的高级特性打下坚实基础。我们将首先介绍AOP的核心概念，并阐述这些概念如何帮助开发者更好地组织代码，使得关注点从主业务逻辑中分离出来，以达到高度解耦的目的。

2. 拦截器实现基础

2.1 拦截器设计原理

2.1.1 拦截器与过滤器的区别

拦截器（Interceptor）和过滤器（Filter）都是用来对Web请求进行拦截处理的组件，但它们在实现细节、使用场景和作用范围上有所不同。

实现层面： 过滤器是在Servlet规范中定义的组件，它依赖于Servlet容器，可以通过web.xml配置或注解的方式来定义。拦截器则是在Spring框架中提供的，基于Java的动态代理机制来实现的。
作用范围： 过滤器能够对几乎所有的请求进行拦截，包括静态资源、JS、CSS、图片等，而拦截器通常只拦截访问控制器（Controller）的请求。
执行时机： 过滤器是在请求进入Servlet之前被调用，而拦截器则是在请求进入Controller之后，视图渲染之前进行处理。
功能强大： 由于拦截器是基于Spring的动态代理实现的，因此拦截器可以使用Spring的IoC容器功能，可以访问Bean的上下文，使用AOP的特性，而过滤器则不可以。

总的来说，拦截器提供了更为丰富的功能和更加精细的控制，但过滤器对于请求的预处理和后处理则更为合适。

2.1.2 拦截器的工作流程

拦截器的工作流程是从用户的请求开始，直至响应结束。具体步骤如下：

用户发送请求到服务器。
请求被拦截器链拦截。
拦截器按照注册的顺序依次执行其 preHandle 方法。
如果某个拦截器的 preHandle 返回 false ，则后续的拦截器和目标控制器不会被执行，此时 postHandle 和 afterCompletion 也不会被调用。
如果所有拦截器的 preHandle 都返回 true ，则目标控制器被调用。
控制器处理完请求后，返回视图名称或ModelAndView对象。
SpringMVC的DispatcherServlet遍历拦截器链，调用每个拦截器的 postHandle 方法。
视图被渲染完成之后， DispatcherServlet再次遍历拦截器链，调用每个拦截器的 afterCompletion 方法。

这一流程展示了拦截器的灵活性和强大之处，允许开发者在请求处理的各个环节进行干预。

2.2 拦截器接口实现

2.2.1 HandlerInterceptor接口分析

HandlerInterceptor 是Spring MVC框架提供的一个接口，它定义了三个主要的回调方法： preHandle 、 postHandle 和 afterCompletion ，每个方法都提供了处理请求和响应的机会。

boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) ：该方法在控制器处理请求之前被调用。如果返回 true ，则请求继续被处理；如果返回 false ，则请求结束，且 postHandle 和 afterCompletion 不会被调用。
void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) ：该方法在控制器处理完请求之后，返回视图之前被调用。它可以对模型和视图进行一些修改。
void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) ：该方法在请求完全结束后被调用，可以进行一些清理工作。

HandlerInterceptor 接口的实现类需要通过实现这三个方法来实现具体的拦截逻辑。

2.2.2 实现自定义拦截器

实现自定义拦截器需要以下步骤：

创建一个实现了 HandlerInterceptor 接口的类。
在类中实现接口中的方法，添加自定义的逻辑。
创建一个配置类，继承 WebMvcConfigurerAdapter ，重写 addInterceptors 方法，注册拦截器。

下面是一个简单的自定义拦截器示例：

public class CustomInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 在请求被处理之前的操作
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // 在请求被处理之后的操作
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 在整个请求结束之后的操作
    }
}

2.2.3 配置拦截器的拦截规则

在自定义拦截器类准备就绪后，需要在Spring配置类中配置拦截器，指定其拦截路径：

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 创建拦截器实例
        CustomInterceptor interceptor = new CustomInterceptor();
        // 注册拦截器，并指定拦截路径
        registry.addInterceptor(interceptor)
                .addPathPatterns("/**") // 拦截所有请求
                .excludePathPatterns("/login", "/error"); // 排除登录和错误页面的拦截
    }
}

这里， addPathPatterns 方法用于指定拦截的路径模式， excludePathPatterns 用于排除不需要拦截的路径模式。这样，拦截器就能够正确地根据配置对请求进行拦截处理了。

3. 切面（Aspect）与通知（Advice）

3.1 切面（Aspect）定义

3.1.1 Aspect注解的作用与使用

在Spring AOP中，Aspect注解是用于声明切面的元注解。一个切面可以包含多个通知（Advice）和切点（Pointcut）定义。通过使用 @Aspect 注解，我们可以轻松地将一个普通的类转变为一个Spring管理的切面类。

当我们定义一个类并使用 @Aspect 注解修饰后，Spring将会扫描到这个类，并将其作为一个切面来处理。这意味着我们可以在这个类中定义切点表达式来指定通知的应用范围，并实现各种类型的通知来执行相应的逻辑。

下面是使用 @Aspect 注解的一个基本示例：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class LoggingAspect {

    // 定义切点表达式
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceLayer() {}

    // 定义通知方法
    @After("serviceLayer()")
    public void logAfterServiceCall() {
        System.out.println("Service method call completed.");
    }
}

在这个例子中， serviceLayer() 方法定义了一个切点表达式，它指定在 com.example.service 包下的所有方法调用时触发。然后，在 logAfterServiceCall() 方法上使用 @After 注解，表明这是一个后置通知，在切点方法执行完毕后执行。

3.1.2 切面的声明与实例化

在Spring AOP中，切面的声明与实例化是由Spring容器自动完成的。当我们使用 @Aspect 注解标注一个类时，这个类会被Spring识别为一个切面，并且在容器初始化时被创建实例。

为了更好地理解这个过程，我们来分析切面类是如何被Spring容器管理的。首先，需要在Spring的配置文件或者配置类中启用注解驱动的AOP功能。

以下是基于XML配置启用AOP的示例：

<aop:aspectj-autoproxy />

如果使用Java配置，则可以添加 @EnableAspectJAutoProxy 注解到配置类上：

import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    // 其他Bean定义...
}

在Spring容器中，每个切面类都是一个特殊的Bean。当Spring容器创建应用上下文时，会自动发现使用了 @Aspect 注解的类，并对其进行实例化。Spring容器使用代理模式来生成目标对象的代理，并将切面的通知逻辑编织到代理中，最终返回给调用者使用。

3.1.3 切面类的配置与AOP代理

在切面类的配置过程中，我们通常需要指定它应该应用到哪些对象上，这可以通过使用切点表达式来实现。切点表达式定义了通知应该何时执行，它限定了通知应用的具体时机和方法。

在Spring AOP中，切点表达式可以通过 @Pointcut 注解来定义。下面是一个简单的示例：

@Aspect
public class LoggingAspect {

    // 定义切点表达式
    @Pointcut("within(com.example.service.*)")
    public void serviceLayer() {}

    // 定义通知方法
    @Before("serviceLayer()")
    public void logBeforeServiceCall(JoinPoint joinPoint) {
        // 执行日志记录
    }
}

在这个例子中， within(com.example.service.*) 是一个切点表达式，它指定了只有在 com.example.service 包下的对象的行为时，才会触发通知。

当Spring AOP创建代理时，它会根据配置的切点表达式来决定是否调用通知。这个代理是由目标对象和切面的通知逻辑编织而成。当调用目标对象方法时，代理会首先检查该调用是否匹配切点表达式，如果匹配，则执行相应的通知逻辑，最后再执行目标方法。

3.1.4 切面类与其他Bean的依赖关系

切面类作为Spring管理的普通Bean，它们可以拥有与其他Bean相同的作用域和生命周期。这意味着切面类可以注入其他依赖，并且可以使用 @Autowired , @Inject , 或 @Resource 等注解来自动注入所需依赖。

例如，如果我们有一个服务类 UserService 和一个切面类 LoggingAspect ，我们可能需要在 LoggingAspect 中使用 UserService 来执行一些额外的业务逻辑：

@Aspect
public class LoggingAspect {

    // 注入其他Bean依赖
    @Autowired
    private UserService userService;

    @Before("execution(* com.example.service.UserServiceImpl.*(..))")
    public void logBeforeMethodCall(JoinPoint joinPoint) {
        // 在UserServiceImpl的任何方法之前执行日志记录
        // 可以使用userService对象进行额外操作...
    }
}

上述代码中， LoggingAspect 切面类注入了 UserService 的实例。在使用 @Before 注解定义前置通知方法 logBeforeMethodCall 时，Spring会自动注入 UserService 的实例到 LoggingAspect 中。然后，当 UserServiceImpl 中的任何方法被调用之前， logBeforeMethodCall 方法将被执行。

这种方式使得切面类不仅可以执行与业务逻辑无关的通知逻辑，还可以在方法执行前、后或抛出异常时，参与到业务流程中去，实现更复杂的业务需求。

4. AOP代理配置与切点表达式

4.1 AOP代理配置选择

4.1.1 AOP代理的类型和选择策略

在Spring框架中，AOP代理的生成可以基于JDK动态代理或CGLIB代理。选择哪种代理策略取决于目标对象是否实现了接口。

JDK动态代理 ：仅当目标类实现了接口时，Spring AOP会自动使用JDK的 java.lang.reflect.Proxy 类来创建代理对象。这种方法的优点是简单且与JDK版本兼容性好；缺点是如果目标类没有接口，就无法使用这种代理。
CGLIB代理 ：当目标类没有实现接口时，或者在某些需要增强类本身而不是接口方法的情况下，Spring AOP会采用CGLIB库来创建目标类的子类作为代理。使用CGLIB创建代理对象时，需要在项目中引入CGLIB的依赖库。CGLIB代理的优势在于可以直接对类进行代理，不受接口限制；但生成的代理类效率可能低于JDK动态代理，且代码更加复杂。

代理选择策略的配置通常在Spring配置文件或Java配置类中进行设置，也可以通过注解指定使用哪种代理。

4.1.2 配置代理的Spring设置

在Spring配置中，可以通过 <aop:config> 标签或 @EnableAspectJAutoProxy 注解来配置代理的类型。使用XML配置方式示例如下：

<aop:aspectj-autoproxy proxy-target-class="true"/>

proxy-target-class="true" 属性表示使用CGLIB代理。如果设置为 false 或不设置，则默认使用JDK动态代理。

使用Java配置类的方式示例如下：

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AppConfig {
    // ...
}

在这里， proxyTargetClass = true 同样表示启用CGLIB代理。通过这种方式配置，可以确保在创建代理时使用正确的方式。

4.2 切点表达式定义

4.2.1 Pointcut表达式的作用与语法

Pointcut表达式是AOP的核心概念之一，它用于定义哪些连接点（Joinpoints）会被特定的通知（Advice）所拦截。连接点通常指的是方法的执行点，但也可以是字段的修改操作等。

Pointcut表达式一般由两部分组成：一个方法匹配模式和一系列指定的修饰符、参数类型、返回类型和注解等。

语法示例： execution(* com.example.service.*.*(..))

上述表达式中： - execution 是指示器，表示执行点匹配。 - * 表示任意返回类型。 - com.example.service.*.* 表示 com.example.service 包下任意类的任意方法。 - (..) 表示任意参数列表。

4.2.2 Pointcut表达式的高级匹配规则

除了基本的匹配规则外，Pointcut表达式还支持更复杂的模式匹配规则，可以用来精确指定需要拦截的方法。

通配符 ：可以使用 * 来匹配任意字符序列，或者使用 .. 来匹配任意数量的包层级。
逻辑运算符 ：可以使用 && （与）、 || （或）和 ! （非）来组合多个指示器。
参数匹配 ：可以指定参数类型和参数的匹配模式，如 execution(* *(String, ..)) 表示匹配第一个参数为String类型，后面可以跟任意数量和类型参数的方法。
注解限定 ：可以使用 @ 符号来指定方法必须被特定注解修饰，如 @annotation(com.example.annotation.Loggable) 。

4.2.3 配置通知的方法和时机

在Spring AOP中，通过Pointcut表达式配置通知的拦截时机。可以在方法执行前后、抛出异常后或返回值前后等时机进行拦截。

前置通知（Before） ：使用 @Before 注解指定方法执行前执行的通知。
后置通知（After-returning） ：使用 @AfterReturning 注解指定在方法返回后执行的通知。
异常通知（After-throwing） ：使用 @AfterThrowing 注解指定在方法抛出异常后执行的通知。
最终通知（After） ：使用 @After 注解指定无论方法执行结果如何都执行的通知。
环绕通知（Around） ：使用 @Around 注解指定可以完全控制目标方法执行的通知，包括方法的调用和返回值的处理。

下面是一个使用环绕通知的示例代码：

@Aspect
@Component
public class MyAroundAspect {
    @Around("execution(* com.example.service.*.*(..))")
    public Object process(ProceedingJoinPoint pjp) throws Throwable {
        // 在方法执行前的操作
        Object proceed = pjp.proceed();
        // 在方法执行后的操作
        return proceed;
    }
}

在这个例子中，我们定义了一个环绕通知，它会在 com.example.service 包下任意类的任意方法执行前后进行拦截。

通过这些高级匹配规则和配置通知的方法，我们可以精确控制AOP代理的行为，使得横切关注点（cross-cutting concerns）的逻辑可以独立于业务逻辑之外。这不仅提高了代码的复用性，也使得业务逻辑更加清晰。

5. AOP实战应用与测试验证

5.1 拦截器注册

拦截器作为Spring MVC的一部分，是在Web请求处理链中拦截请求，并进行一些预处理或后处理的重要组件。注册拦截器主要涉及配置和实现拦截规则。

5.1.1 注册拦截器的流程

要在Spring MVC中注册一个拦截器，首先需要创建一个实现 HandlerInterceptor 接口的类，并重写其中的方法。然后，需要创建一个配置类，并使用 WebMvcConfigurer 接口来注册拦截器。

以下是一个简单的拦截器注册示例：

public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 在请求处理之前进行调用（Controller方法调用之前）
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // 请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 在整个请求结束之后被调用，也就是在DispatcherServlet渲染了对应的视图之后执行（主要用于进行资源清理工作）
    }
}

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**");
    }
}

在这个配置中， MyInterceptor 类定义了拦截器的具体逻辑，而 WebConfig 类将拦截器应用到了所有路径上。

5.1.2 拦截器链的构建与执行顺序

拦截器链是按照注册顺序依次执行的。每个拦截器的 preHandle 方法如果返回 true ，则继续执行下一个拦截器；如果返回 false ，则整个请求处理链将被中断，不再执行后续拦截器和Controller方法。

5.2 切面与切点关联

在AOP中，切面与切点的关联是通过定义通知（Advice）并将它们与切点表达式结合来实现的。

5.2.1 AspectJ与Spring AOP的关联配置

Spring AOP支持AspectJ注解。要在Spring中使用AspectJ定义切面，需要在Spring的配置类上启用AspectJ的支持。

@Configuration
@EnableAspectJAutoProxy
public class AopConfig {
    // 其他配置...
}

@EnableAspectJAutoProxy 注解告诉Spring框架，自动为使用 @Aspect 注解的类创建代理。

5.2.2 关联切点与切面的最佳实践

在切面中，我们可以使用 @Pointcut 注解来定义切点表达式，并在通知方法上使用 @Before 、 @After 、 @Around 等注解来指定通知类型和关联的切点。

@Aspect
@Component
public class LoggingAspect {

    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceLayerExecution() {}

    @Before("serviceLayerExecution()")
    public void logBefore(JoinPoint joinPoint) {
        // 在目标方法执行前记录日志
    }
}

在这个例子中， serviceLayerExecution 方法定义了一个切点，该切点匹配 com.example.service 包下所有类的所有方法。 logBefore 通知将在这些方法执行前执行。

5.3 测试与验证方法

验证AOP的实现是否正确，需要编写测试代码，分别通过单元测试和集成测试进行验证。

5.3.1 单元测试的编写与执行

单元测试通常是针对单个组件进行的测试。对于拦截器，可以使用JUnit和Mockito来模拟请求和响应。

public class MyInterceptorTest {

    @Mock
    private HttpServletRequest request;

    @Mock
    private HttpServletResponse response;

    @InjectMocks
    private MyInterceptor interceptor;

    @Test
    public void testPreHandle() {
        Mockito.when(request.getRequestURI()).thenReturn("/some/path");
        assertTrue(interceptor.preHandle(request, response, null));
    }
}

5.3.2 集成测试的策略与技巧

集成测试覆盖了多个组件协同工作的场景。在Spring Boot中，可以通过 @SpringBootTest 和 MockMvc 来编写集成测试。

@SpringBootTest
@AutoConfigureMockMvc
public class WebLayerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testInterceptor() throws Exception {
        mockMvc.perform(get("/some/path"))
                .andExpect(status().isOk());
        // 可以添加额外的断言来验证拦截器逻辑
    }
}

5.4 AOP在实际开发中的应用

AOP在实际开发中的应用非常广泛，以下是一些常见的应用场景。

5.4.1 AOP在日志记录中的应用

通过AOP可以非常方便地在方法执行前后记录日志信息，而不需要在每个方法中重复编写日志代码。

@Before("execution(* com.example.service.*.*(..))")
public void logBefore(JoinPoint joinPoint) {
    // 记录方法调用前的日志信息
}

5.4.2 AOP在事务管理中的应用

在Spring框架中，AOP可用于声明式事务管理，简化事务控制代码。

@Transactional
public void someMethod() {
    // 方法内部可以省略事务控制代码
}

5.4.3 AOP在安全性控制中的应用

AOP可以用来在方法执行前检查用户权限，确保安全性。

@Before("execution(* com.example.service.*.*(..))")
public void checkPermission(JoinPoint joinPoint) {
    // 检查当前用户是否有权限调用该方法
}

通过上述示例，我们可以看到AOP在实际开发中的强大功能和灵活性，有效地减少了重复代码，增强了程序的模块化和可维护性。

本文还有配套的精品资源，点击获取