Spring AOP之MethodInterceptor原理

简介: Spring AOP之MethodInterceptor原理


引言

之前我们讨论过了HandlerInterceptor,现在我们来看一下MethodInterceptor。

MethodInterceptor是Spring AOP中的一个重要接口,用来拦截方法调用,它只有一个invoke方法。

Spring AOP组成

  1. Aspect:切面,是一个普通的Java类,里面定义了通知(Advice)和切点(Pointcut)。
  2. Advice:通知,定义了切面要织入目标对象的具体时机和操作。有前置通知、后置通知、异常通知、最终通知和环绕通知等。
  3. Pointcut:切点,指明应用通知的具体对象和方法。可以通过表达式或匹配命名规范来指定切点。
  4. Target:目标对象,被通知和切点织入额对象。
  5. Weaving:织入,将切面应用到目标对象来创建代理对象的过程。Spring AOP中通常在运行期间通过动态代理来实现。

先看一下Advice

Spring AOP支持5种类型的Advice(通知),执行时机和简单解释如下:

通知名 执行时机 解释
@Before 目标方法执行前 在目标方法执行前执行,可以用于方法级预处理
@AfterReturning 目标方法执行后,且没有异常 用于方法后置处理,获取方法返回值等
@After 目标方法执行后,不论方法异常与否 用于资源清理
@AfterThrowing 目标方法抛出异常后 处理方法中抛出的异常
@Around 环绕目标方法 在目标方法执行前后都可以执行自定义操作,并控制目标方法是否执行及其参数

这5种Advice的执行顺序如下:

  1. @Before:前置通知,目标方法执行之前执行
  2. @Around:环绕通知, encloses 目标方法,在目标方法之前和之后执行自定义操作
  3. 目标方法执行
  4. @AfterReturning:返回通知,目标方法成功执行之后执行
  5. @AfterThrowing:异常通知,目标方法抛出异常后执行
  6. @After:后置通知,目标方法之后执行
    所以总结来说:
    @Before,@After在目标方法执行前后一定会执行。
    @AfterReturning只有目标方法成功执行后才会执行。
    @AfterThrowing只有目标方法抛出异常后才会执行。
    @Around会根据是否执行目标方法而在前后执行,还可以控制目标方法的执行。

偷了一张图,可以参考一下:

来源:Spring AOP通知(Advice)详解

示例

我们直接来个例子

pom文件,我用的gradle:

plugins {
    id 'org.springframework.boot' version '3.0.2'
    id 'io.spring.dependency-management' version '1.1.0'
    id 'java'
}
group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'
repositories {
    mavenLocal()
    maven { url "https://maven.aliyun.com/nexus/content/groups/public/"}
    mavenCentral()
    jcenter()
    maven { url "https://repo.spring.io/snapshot" }
    maven { url "https://repo.spring.io/milestone" }
    maven { url 'https://oss.jfrog.org/artifactory/oss-snapshot-local/' }
}
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    implementation 'org.springframework.boot:spring-boot-starter-aop'
}

service接口和类

public interface ExampleService {
    void doSomething();
    void doAnything();
    void justPlay();
}
@Service
public class ExampleServiceImpl implements ExampleService {
    @Override
    public void doSomething() {
        System.out.println("-----------doSomething ----------");
    }    
  @Override
    public void doAnything() {
        System.out.println("-----------doAnything ----------");
    }
    @Override
    public void justPlay() {
        System.out.println("-----------justPlay ----------");
    }
}

切面类:

@Aspect
@Component
public class ExampleAspect {
//只拦截do开头的方法
    @Before("execution(* com.example.gspringtest.service.impl.ExampleServiceImpl.do*(..))")
    public void beforeMethod() {
        System.out.println("Before method");
    }
}

测试接口:

package com.example.gspringtest.demos.web;
import com.example.gspringtest.service.ExampleService;
import com.example.gspringtest.service.impl.ExampleServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
/**
 * @author <a href="mailto:chenxilzx1@gmail.com">theonefx</a>
 */
@Controller
public class BasicController {
    @Autowired
    private ExampleService exampleService;
    @Autowired
    private ApplicationContext applicationContext;
    @RequestMapping("/testMethod")
    @ResponseBody
    public String testMethod() {
        exampleService.doSomething();
        System.out.println("******************888888888********************");
        exampleService.doAnything();
        System.out.println("******************888888888********************");
        exampleService.justPlay();
//        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        ExampleService exampleService1 = applicationContext.getBean(ExampleServiceImpl.class);
        ExampleServiceImpl exampleService2 = applicationContext.getBean(ExampleServiceImpl.class);
        return "Hello " ;
    }
}

先来看一下输出

Before method
-----------doSomething ----------
******************888888888********************
Before method
-----------doAnything ----------
******************888888888********************
-----------justPlay ----------

提问

请告诉我,测试接口中的exampleService,exampleService1和exampleService2是同一个bean吗?是代理类还是原对象?

来揭晓一下答案:

首先是同一个bean

其次,只能拿到代理类:

原理

上面讲了这么多,好像跟MethodInterceptor没啥关系啊,我们

先来看几个类:

MethodBeforeAdviceAdapter

执行Before方法

AfterReturningAdviceInterceptor

执行AfterReturning方法

ThrowsAdviceInterceptor

执行AfterThrowing方法

AspectJAfterAdvice

执行Aftor方法

AspectJAroundAdvice

执行Around方法

这几个类都实现了MethodIntercepter,并且分别对应了不同的通知类型。

spring aop为目标对象生成的代理对象是通过实现MethodInterceptor接口来与拦截器协同工作的。

代理对象通过实现MethodInterceptor接口并协调拦截器链,与各MethodInterceptor实现相结合,最终执行完所有相关通知逻辑并将结果返回给客户端。

拦截器链中的每个拦截器通过mi.proceed()调用下一级,并在前/后执行本拦截器的通知逻辑,形成完整的通知调用链。

相关文章
|
21天前
|
缓存 Java 开发者
【Spring】原理:Bean的作用域与生命周期
本文将围绕 Spring Bean 的作用域与生命周期展开深度剖析,系统梳理作用域的类型与应用场景、生命周期的关键阶段与扩展点,并结合实际案例揭示其底层实现原理,为开发者提供从理论到实践的完整指导。
|
19天前
|
人工智能 Java 开发者
【Spring】原理解析:Spring Boot 自动配置
Spring Boot通过“约定优于配置”的设计理念,自动检测项目依赖并根据这些依赖自动装配相应的Bean,从而解放开发者从繁琐的配置工作中解脱出来,专注于业务逻辑实现。
|
20天前
|
XML 安全 Java
使用 Spring 的 @Aspect 和 @Pointcut 注解简化面向方面的编程 (AOP)
面向方面编程(AOP)通过分离横切关注点,如日志、安全和事务,提升代码模块化与可维护性。Spring 提供了对 AOP 的强大支持,核心注解 `@Aspect` 和 `@Pointcut` 使得定义切面与切入点变得简洁直观。`@Aspect` 标记切面类,集中处理通用逻辑;`@Pointcut` 则通过表达式定义通知的应用位置,提高代码可读性与复用性。二者结合,使开发者能清晰划分业务逻辑与辅助功能,简化维护并提升系统灵活性。Spring AOP 借助代理机制实现运行时织入,与 Spring 容器无缝集成,支持依赖注入与声明式配置,是构建清晰、高内聚应用的理想选择。
253 0
|
4月前
|
监控 安全 Java
Spring AOP实现原理
本内容主要介绍了Spring AOP的核心概念、实现机制及代理生成流程。涵盖切面(Aspect)、连接点(Join Point)、通知(Advice)、切点(Pointcut)等关键概念,解析了JDK动态代理与CGLIB代理的原理及对比,并深入探讨了通知执行链路和责任链模式的应用。同时,详细分析了AspectJ注解驱动的AOP解析过程,包括切面识别、切点表达式匹配及通知适配为Advice的机制,帮助理解Spring AOP的工作原理与实现细节。
|
1月前
|
人工智能 监控 安全
Spring AOP切面编程颠覆传统!3大核心注解+5种通知类型,让业务代码纯净如初
本文介绍了AOP(面向切面编程)的基本概念、优势及其在Spring Boot中的使用。AOP作为OOP的补充,通过将横切关注点(如日志、安全、事务等)与业务逻辑分离,实现代码解耦,提升模块化程度、可维护性和灵活性。文章详细讲解了Spring AOP的核心概念,包括切面、切点、通知等,并提供了在Spring Boot中实现AOP的具体步骤和代码示例。此外,还列举了AOP在日志记录、性能监控、事务管理和安全控制等场景中的实际应用。通过本文,开发者可以快速掌握AOP编程思想及其实践技巧。
|
1月前
|
Java 关系型数据库 数据库
深度剖析【Spring】事务:万字详解,彻底掌握传播机制与事务原理
在Java开发中,Spring框架通过事务管理机制,帮我们轻松实现了这种“承诺”。它不仅封装了底层复杂的事务控制逻辑(比如手动开启、提交、回滚事务),还提供了灵活的配置方式,让开发者能专注于业务逻辑,而不用纠结于事务细节。
|
1月前
|
人工智能 监控 安全
如何快速上手【Spring AOP】?核心应用实战(上篇)
哈喽大家好吖~欢迎来到Spring AOP系列教程的上篇 - 应用篇。在本篇,我们将专注于Spring AOP的实际应用,通过具体的代码示例和场景分析,帮助大家掌握AOP的使用方法和技巧。而在后续的下篇中,我们将深入探讨Spring AOP的实现原理和底层机制。 AOP(Aspect-Oriented Programming,面向切面编程)是Spring框架中的核心特性之一,它能够帮助我们解决横切关注点(如日志记录、性能统计、安全控制、事务管理等)的问题,提高代码的模块化程度和复用性。
|
1月前
|
设计模式 Java 开发者
如何快速上手【Spring AOP】?从动态代理到源码剖析(下篇)
Spring AOP的实现本质上依赖于代理模式这一经典设计模式。代理模式通过引入代理对象作为目标对象的中间层,实现了对目标对象访问的控制与增强,其核心价值在于解耦核心业务逻辑与横切关注点。在框架设计中,这种模式广泛用于实现功能扩展(如远程调用、延迟加载)、行为拦截(如权限校验、异常处理)等场景,为系统提供了更高的灵活性和可维护性。
|
5月前
|
存储 人工智能 自然语言处理
RAG 调优指南:Spring AI Alibaba 模块化 RAG 原理与使用
通过遵循以上最佳实践,可以构建一个高效、可靠的 RAG 系统,为用户提供准确和专业的回答。这些实践涵盖了从文档处理到系统配置的各个方面,能够帮助开发者构建更好的 RAG 应用。
2733 114
|
2月前
|
缓存 安全 Java
Spring 框架核心原理与实践解析
本文详解 Spring 框架核心知识,包括 IOC(容器管理对象)与 DI(容器注入依赖),以及通过注解(如 @Service、@Autowired)声明 Bean 和注入依赖的方式。阐述了 Bean 的线程安全(默认单例可能有安全问题,需业务避免共享状态或设为 prototype)、作用域(@Scope 注解,常用 singleton、prototype 等)及完整生命周期(实例化、依赖注入、初始化、销毁等步骤)。 解析了循环依赖的解决机制(三级缓存)、AOP 的概念(公共逻辑抽为切面)、底层动态代理(JDK 与 Cglib 的区别)及项目应用(如日志记录)。介绍了事务的实现(基于 AOP
115 0