详解Spring AOP篇二

最新推荐文章于 2025-09-03 17:28:45 发布
原创 最新推荐文章于 2025-09-03 17:28:45 发布 · 1k 阅读 · 71 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#JAVA #Java #spring

目录

Spring AOP核心概念

切点(Pointcut)

连接点(Join Point)

切点和连接点的关系

通知(Advice)

切面(Aspect)

通知类型

AspectDemo

TestControler

通知类型的执行顺序 

关于@Around表示的方法返回值问题

@Pointcut

切面优先级@Order

切点表达式

execution表达式

annotation表达式

Spring AOP核心概念
切点(Pointcut)

切点(Pointcut), 也称之为"切⼊点"。
Pointcut 的作⽤就是提供⼀组规则 (使⽤ AspectJ pointcut expression language 来描述), 告诉程序对哪些⽅法来进⾏功能增强.

上面的表达式 execution(* com.wmh.springaop.controller.*.*(..)) 就是 切点表达式。

连接点(Join Point)

满⾜切点表达式规则的⽅法, 就是连接点. 也就是可以被AOP控制的⽅法.

对于下面的代码，com.wmh.springaop.controller路径下所有类的所有方法，都是连接点。

切点和连接点的关系

连接点是满⾜切点表达式的元素. 切点可以看做是保存了众多连接点的⼀个集合。

通知(Advice)

通知就是具体要做的⼯作, 指哪些重复的逻辑，也就是共性功能(最终体现为⼀个⽅法)
⽐如上述代码中记录业务⽅法的耗时时间, 就是通知。

在AOP⾯向切⾯编程当中, 我们把这部分重复的代码逻辑抽取出来单独定义, 这部分代码就是通知的内容.

切面(Aspect)

切⾯(Aspect) = 切点(Pointcut) + 通知(Advice).
通过切⾯就能够描述当前AOP程序需要针对于哪些⽅法, 在什么时候执⾏什么样的操作.
切⾯既包含了通知逻辑的定义, 也包括了连接点的定义.

切⾯所在的类, 我们⼀般称为切⾯类(被@Aspect注解标识的类)。

通知类型

上⾯我们讲了什么是通知, 接下来学习通知的类型. @Around 就是其中⼀种通知类型, 表⽰环绕通知.
Spring中AOP的通知类型有以下⼏种:

• @Around: 环绕通知, 此注解标注的通知⽅法在⽬标⽅法前, 后都被执⾏
• @Before: 前置通知, 此注解标注的通知⽅法在⽬标⽅法前被执⾏
• @After: 后置通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, ⽆论是否有异常都会执⾏
• @AfterReturning: 返回后通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, 有异常不会执⾏
• @AfterThrowing: 异常后通知, 此注解标注的通知⽅法发⽣异常后执⾏

下面通过代码加深对上面通知类型的理解：

AspectDemo
package com.wmh.springaop.aspect;


import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@Aspect
public class AspectDemo {

    @Before("execution(* com.wmh.springaop.controller..*(..))")
    public void doBefore(){
        log.info("AspectDemo do before....");
    }

    @After("execution(* com.wmh.springaop.controller..*(..))")
    public void doAfter(){
        log.info("AspectDemo do after....");
    }

    @Around("execution(* com.wmh.springaop.controller..*(..))")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("AspectDemo do around before....");
        Object result = joinPoint.proceed();
        log.info("AspectDemo do around after...");
        return result;
    }

    @AfterReturning("execution(* com.wmh.springaop.controller..*(..))")
    public void doAfterReturning(){
        log.info("AspectDemo do after returning....");
    }

    @AfterThrowing("execution(* com.wmh.springaop.controller..*(..))")
    public void doAfterThrowing(){
        log.info("AspectDemo do after throwing....");
    }
}
TestControler
package com.wmh.springaop.controller;

import com.wmh.springaop.config.MyAspect;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RequestMapping("/test")
@RestController
public class TestController {

    @RequestMapping("/t1")
    public String t1(){
        log.info("执行t1方法...");
        return "t1";
    }

    @RequestMapping("/t2")
    public String t2(){
        log.info("执行t2方法...");
        int a = 10/0;
        return "t2";
    }

}
通知类型的执行顺序 

上面代码正常情况下的运行结果：

由此我们知道，正常情况下通知类型的执行顺序是：

发生异常时的运行结果：

由此我们知道，发生异常的情况下通知类型的执行顺序是： 

比较正常情况下和发生异常的情况下的运行结果：

从上面我们可以看到，当发生异常时@AfterReturning表示的通知方法不会执行了，@AfterThrowing表示的通知方法执行了。

而且，当@Around环绕通知中原始方法调用时有异常，通知中的环绕后的代码逻辑就不会执行了，因为原始方法调用出异常了。

关于@Around表示的方法返回值问题

当@Around标识的方法有返回值且类型为Object时：

AspectDemo

package com.wmh.springaop.aspect;


import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@Aspect
public class AspectDemo {

    @Around("execution(* com.wmh.springaop.controller..*(..))")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("AspectDemo do around before....");
        Object result = joinPoint.proceed();
        log.info("AspectDemo do around after...");
        return result;
    }
}

TestController

package com.wmh.springaop.controller;

import com.wmh.springaop.config.MyAspect;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RequestMapping("/test")
@RestController
public class TestController {

    @RequestMapping("/t1")
    public String t1(){
        log.info("执行t1方法...");
        return "t1";
    }

}

运行结果：

当@Around表示的方法没有返回值时：

AspectDemo

package com.wmh.springaop.aspect;


import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@Aspect
public class AspectDemo {

    @Around("execution(* com.wmh.springaop.controller..*(..))")
    public void doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("AspectDemo do around before....");
        Object result = joinPoint.proceed();
        log.info("AspectDemo do around after...");
    }
}

注意事项

• @Around 环绕通知需要调⽤ ProceedingJoinPoint.proceed() 来让原始⽅法执⾏, 其他
通知不需要考虑⽬标⽅法执⾏.
• @Around 环绕通知⽅法的返回值, 必须指定为Object, 来接收原始⽅法的返回值, 否则原始⽅法执⾏完毕, 是获取不到返回值的.
• ⼀个切⾯类可以有多个切点.

@Pointcut

上⾯代码存在⼀个问题, 就是存在⼤量重复的切点表达式 execution(* com.wmh.springaop.controller..*(..)) , Spring提供了 @PointCut 注解, 把公共的切点
表达式提取出来, 需要⽤到时引⽤该切⼊点表达式即可.

上述代码就可以修改为: 

package com.wmh.springaop.aspect;


import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@Aspect
public class AspectDemo {
    @Pointcut("execution(* com.wmh.springaop.controller..*(..))")
    public void pt(){};

    @Before("pt()")
    public void doBefore(){
        log.info("AspectDemo do before....");
    }

    @After("pt()")
    public void doAfter(){
        log.info("AspectDemo do after....");
    }

    @Around("pt()")
    public void doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("AspectDemo do around before....");
        Object result = joinPoint.proceed();
        log.info("AspectDemo do around after...");
    }

    @AfterReturning("pt()")
    public void doAfterReturning(){
        log.info("AspectDemo do after returning....");
    }

    @AfterThrowing("pt()")
    public void doAfterThrowing(){
        log.info("AspectDemo do after throwing....");
    }
}

当切点定义使⽤private修饰时, 仅能在当前切⾯类中使⽤, 当其他切⾯类也要使⽤当前切点定义时, 就需要把private改为public. 引⽤⽅式为: 全限定类名.⽅法名()

package com.wmh.springaop.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;

@Order(1)
@Slf4j
@Component
@Aspect
public class AspectDemo2 {

    @Before("com.wmh.springaop.aspect.AspectDemo.pt()")
    public void doBefore(){
        log.info("AspectDemo2 do before....");
    }

    @After("com.wmh.springaop.aspect.AspectDemo.pt()")
    public void doAfter(){
        log.info("AspectDemo2 do after....");
    }

}
切面优先级@Order

当我们在⼀个项⽬中, 定义了多个切⾯类时, 并且这些切⾯类的多个切⼊点都匹配到了同⼀个⽬标⽅法.当⽬标⽅法运⾏的时候, 这些切⾯类中的通知⽅法都会执⾏, 那么这⼏个通知⽅法的执⾏顺序是什么样的呢?
我们还是通过程序来求证:
定义多个切⾯类:
为简单化, 只写了 @Before 和 @After 两个通知.

AspectDemo2

package com.wmh.springaop.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@Aspect
public class AspectDemo2 {

    @Before("com.wmh.springaop.aspect.AspectDemo.pt()")
    public void doBefore(){
        log.info("AspectDemo2 do before....");
    }

    @After("com.wmh.springaop.aspect.AspectDemo.pt()")
    public void doAfter(){
        log.info("AspectDemo2 do after....");
    }

}

AspectDemo3

package com.wmh.springaop.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@Aspect
public class AspectDemo3 {

    @Before("com.wmh.springaop.aspect.AspectDemo.pt()")
    public void doBefore(){
        log.info("AspectDemo3 do before....");
    }

    @After("com.wmh.springaop.aspect.AspectDemo.pt()")
    public void doAfter(){
        log.info("AspectDemo3 do after....");
    }

}

 AspectDemo4

package com.wmh.springaop.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@Aspect
public class AspectDemo4 {

    @Before("com.wmh.springaop.aspect.AspectDemo.pt()")
    public void doBefore(){
        log.info("AspectDemo4 do before....");
    }

    @After("com.wmh.springaop.aspect.AspectDemo.pt()")
    public void doAfter(){
        log.info("AspectDemo4 do after....");
    }

}

TestController

package com.wmh.springaop.controller;

import com.wmh.springaop.config.MyAspect;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RequestMapping("/test")
@RestController
public class TestController {

    @RequestMapping("/t1")
    public String t1(){
        log.info("执行t1方法...");
        return "t1";
    }

}

运行结果：

通过上述程序的运⾏结果, 可以看出:
存在多个切⾯类时, 默认按照切⾯类的类名字⺟排序：

• @Before 通知：字⺟排名靠前的先执⾏
• @After 通知：字⺟排名靠前的后执⾏

但这种⽅式不⽅便管理, 我们的类名更多还是具备⼀定含义的.
Spring 给我们提供了⼀个新的注解, 来控制这些切⾯通知的执⾏顺序: @Order
修改上面的代码：

AspectDemo2

package com.wmh.springaop.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Order(1)
@Slf4j
@Component
@Aspect
public class AspectDemo2 {

    @Before("com.wmh.springaop.aspect.AspectDemo.pt()")
    public void doBefore(){
        log.info("AspectDemo2 do before....");
    }

    @After("com.wmh.springaop.aspect.AspectDemo.pt()")
    public void doAfter(){
        log.info("AspectDemo2 do after....");
    }

}

AspectDemo3

package com.wmh.springaop.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Order(100)
@Slf4j
@Component
@Aspect
public class AspectDemo3 {

    @Before("com.wmh.springaop.aspect.AspectDemo.pt()")
    public void doBefore(){
        log.info("AspectDemo3 do before....");
    }

    @After("com.wmh.springaop.aspect.AspectDemo.pt()")
    public void doAfter(){
        log.info("AspectDemo3 do after....");
    }

}

AspectDemo4

package com.wmh.springaop.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Order(25)
@Slf4j
@Component
@Aspect
public class AspectDemo4 {

    @Before("com.wmh.springaop.aspect.AspectDemo.pt()")
    public void doBefore(){
        log.info("AspectDemo4 do before....");
    }

    @After("com.wmh.springaop.aspect.AspectDemo.pt()")
    public void doAfter(){
        log.info("AspectDemo4 do after....");
    }

}

运行结果：

通过上述程序的运⾏结果, 得出结论:
@Order 注解标识的切⾯类, 执⾏顺序如下:

• @Before 通知：数字越⼩先执⾏
• @After 通知：数字越⼤先执⾏

@Order 控制切⾯的优先级, 先执⾏优先级较⾼的切⾯, 再执⾏优先级较低的切⾯, 最终执⾏⽬标⽅法. 

切点表达式

上⾯的代码中, 我们⼀直在使⽤切点表达式来描述切点. 下⾯我们来介绍⼀下切点表达式的语法.
切点表达式常⻅有两种表达⽅式：

1. execution(RR)：根据⽅法的签名来匹配
2. @annotation(RR) ：根据注解匹配

execution表达式

execution() 是最常⽤的切点表达式, ⽤来匹配⽅法, 语法为: 

execution(<访问修饰符> <返回类型> <包名.类名.⽅法(⽅法参数)> <异常>)

其中: 访问修饰符和异常可以省略。

切点表达式⽀持通配符表达:

1. * ：匹配任意字符，只匹配⼀个元素(返回类型, 包, 类名, ⽅法或者⽅法参数)
        a. 包名使⽤ * 表⽰任意包(⼀层包使⽤⼀个*)
        b. 类名使⽤ * 表⽰任意类
        c. 返回值使⽤ * 表⽰任意返回值类型
        d. ⽅法名使⽤ * 表⽰任意⽅法
        e. 参数使⽤ * 表⽰⼀个任意类型的参数
2. .. ：匹配多个连续的任意符号, 可以通配任意层级的包, 或任意类型, 任意个数的参数
        a. 使⽤ .. 配置包名，标识此包以及此包下的所有⼦包
        b. 可以使⽤ .. 配置参数，任意个任意类型的参数

切点表达式示例

TestController 下的 public修饰, 返回类型为String ⽅法名为t1, ⽆参⽅法

execution(public String com.example.demo.controller.TestController.t1()) 

省略访问修饰符

execution(String com.example.demo.controller.TestController.t1()) 

匹配所有返回类型

execution(* com.example.demo.controller.TestController.t1())

匹配TestController 下的所有⽆参⽅法

 execution(* com.example.demo.controller.TestController.*()) 

匹配TestController 下的所有⽅法

execution(* com.example.demo.controller.TestController.*(..)) 

匹配controller包下所有的类的所有⽅法

execution(* com.example.demo.controller.*.*(..)) 

匹配所有包下⾯的TestController

execution(* com..TestController.*(..)) 

匹配com.example.demo包下, ⼦包下的所有类的所有⽅法 

execution(* com.example.demo..*(..))

annotation表达式

execution表达式更适⽤有规则的, 如果我们要匹配多个⽆规则的⽅法呢, ⽐如：TestController中的t1()和UserController中的u1()这两个⽅法.
这个时候我们使⽤execution这种切点表达式来描述就不是很⽅便了.
我们可以借助⾃定义注解的⽅式以及另⼀种切点表达式 @annotation 来描述这⼀类的切点。

实现步骤：

1. 编写⾃定义注解
2. 使⽤ @annotation 表达式来描述切点
3. 在连接点的⽅法上添加⾃定义注解 

自定义注解@MyAspect

package com.wmh.springaop.config;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAspect {
}

说明

1.@Target 标识了 Annotation 所修饰的对象范围, 即该注解可以⽤在什么地⽅.
常⽤取值:
        ElementType.TYPE: ⽤于描述类、接⼝(包括注解类型) 或enum声明
        ElementType.METHOD: 描述⽅法
        ElementType.PARAMETER: 描述参数
        ElementType.TYPE_USE: 可以标注任意类型
2. @Retention 指Annotation被保留的时间⻓短, 标明注解的⽣命周期
@Retention 的取值有三种:
        1. RetentionPolicy.SOURCE：表⽰注解仅存在于源代码中, 编译成字节码后会被丢弃. 这意味着在运⾏时⽆法获取到该注解的信息, 只能在编译时使⽤. ⽐如 @SuppressWarnings , 以及lombok提供的注解 @Data , @Slf4j
        2. RetentionPolicy.CLASS：编译时注解. 表⽰注解存在于源代码和字节码中, 但在运⾏时会被丢弃. 这意味着在编译时和字节码中可以通过反射获取到该注解的信息, 但在实际运⾏时⽆法获取. 通常⽤于⼀些框架和⼯具的注解.
        3. RetentionPolicy.RUNTIME：运⾏时注解. 表⽰注解存在于源代码, 字节码和运⾏时中. 这意味着在编译时, 字节码中和实际运⾏时都可以通过反射获取到该注解的信息. 通常⽤于⼀些需要在运⾏时处理的注解, 如Spring的 @Controller @ResponseBody 

切面类

使⽤ @annotation 切点表达式定义切点, 只对 @MyAspect ⽣效
切⾯类代码如下： 

package com.wmh.springaop.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@Aspect
public class MyAspectDemo {
    @Around("@annotation(com.wmh.springaop.config.MyAspect)")
    public Object doAround(ProceedingJoinPoint joinPoint){
        log.info("do around before...");
        Object o = null;
        try {
            o = joinPoint.proceed();
        } catch (Throwable e) {
            log.error("发生异常,e:", e);
        }
        log.info("do around after...");
        return o;
    }
}

添加自定义注解

TestController

package com.wmh.springaop.controller;

import com.wmh.springaop.config.MyAspect;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RequestMapping("/test")
@RestController
public class TestController {

    @MyAspect
    @RequestMapping("/t1")
    public String t1(){
        log.info("执行t1方法...");
        return "t1";
    }

    @RequestMapping("/t2")
    public String t2(){
        log.info("执行t2方法...");
        int a = 10/0;
        return "t2";
    }

}

UserController

package com.wmh.springaop.controller;

import com.wmh.springaop.config.MyAspect;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RequestMapping("/user")
@RestController
public class UserController {
    @RequestMapping("/u1")
    public String u1(){
        log.info("执行u1方法...");
        return "u1";
    }

    @MyAspect
    @RequestMapping("/u2")
    public String u2(){
        log.info("执行u2方法...");
        return "u2";
    }
}

 访问test/t1运行结果：

访问user/u2运行结果：

Spring AOP 详解
2301_80035594的博客
10-19 6325
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
Spring AOP详解
2303_80195175的博客
05-04 1421
面向切面编程（AOP，Aspect-Oriented Programming）是一种编程范式，旨在通过分离横切关注点（cross-cutting concerns）来提升代码的模块化。AOP 的核心思想横切关注点：指那些分散在多个模块中的通用功能（如日志、事务、安全等），传统OOP难以集中管理，导致代码冗余。切面（Aspect）：将横切关注点封装为独立模块，通过声明式或编程方式注入到业务逻辑中，实现关注点分离。关键概念切面（Aspect）封装横切逻辑的模块（如日志切面），包含通知和切点定义。
spring AOP详解
是程序喵呀
11-07 3679
AOP（Aspect Orient Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善；
细说Spring——AOP详解（AOP概览）
热门推荐
啦啦啦的博客
05-30 54万+
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而...
详解Spring AOP
N_0050的博客
08-30 1791
Aspect Oriented Programming（面向切面编程），OOP是面向对象编程（开发的时候把一个个都抽象成对象来开发），两者的维度不同，处理的事情不同切⾯就是指某⼀类特定问题, 所以AOP也可以理解为⾯向特定⽅法编程。面向切面编程就是针对某一类特定问题统一进行编程比如people类有自己的属性和行为，但是有小一部分人生病要去医院看病，看病这个业务逻辑就不属于哪一个类，因为people泛指所有人，所有人不会都看病。
SpringAOP(图文详解)
lhj520cb的博客
07-16 5万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
【Spring篇】Spring的Aop详解
m0_74202856的博客
10-23 4951
一个有趣爱睡觉的intp，期待和更多人分享自己所学知识的真诚大学生。
【JavaEE进阶】Spring AOP详解
2301_81510374的博客
03-09 1192
AOP是Aspect Oriented Programming的简称（又称为面向切⾯编程）什么是面向切面编程呢?切面就是指某⼀类特定问题,所以AOP也可以理解为面向特定方法编程.什么是面向特定方法编程呢?比如在前面文章实现的的"登录校验",就是⼀类特定问题.登录校验拦截器,就是对"登录校验"这类问题的统⼀处理.所以,拦截器也是AOP的⼀种应用.AOP是⼀种思想,拦截器是AOP思想的⼀种实现.Spring框架实现了这种思想,提供了拦截器技术的相关接⼝.
Spring AOP全面详解(超级详细)
Cr1556648487的博客
09-09 11万+
AOP （Aspect Orient Programming）,直译过来就是 面向切面编程,AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向切面编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术，如下图所示：AOP可以拦截指定的方法并且对方法增强，而且无需侵入到业务代码中，使业务与非业务处理逻辑分离，比如Spring的事务，通过事务的注解配置，Spring会自动在业务方法中开启、提交业务，并且在业务处理失败时，执行相应的回滚策略。
详解使用Spring AOP和自定义注解进行参数检查
08-27
使用Spring AOP和自定义注解进行参数检查 了解使用Spring AOP和自定义注解进行参数检查的技术细节。通过自定义注解和spring AOP，我们可以实现参数的校验，提高代码的可读性和可维护性。 自定义注解 在本篇文章中...
Spring 控制器参数注解
Elastic开源社区
09-01 957
本文详细解析了Java Spring中常用的控制器方法参数注解及其区别。主要包括@RequestParam、@PathVariable、@RequestBody、@ModelAttribute等8种核心注解，分别用于处理URL参数、路径变量、请求体数据、表单绑定等不同场景。文章通过对比表格和示例代码，说明了各注解的适用情境和关键特性，并提供了选择建议。例如，@RequestParam适合获取查询参数，@RequestBody用于解析JSON请求体，@RequestPart专为文件上传设计。最后还解答了常见问
基于SpringBoot的旅游管理系统
最新发布
2501_90968670的博客
09-03 571
旅游管理系统是一个基于Spring Boot和Vue.js的现代化旅游服务平台，提供景点信息展示、在线订票、用户评价等核心功能。系统采用前后端分离架构，包含管理员后台和用户前端两个子系统，实现了完整的旅游服务业务流程。
基于SpringBoot的足球俱乐部管理系统【2026最新】
计算机学姐的博客
09-01 947
【2026最新】基于Java+SpringBoo+Vue+MySQL的足球俱乐部管理系统
mit6.031 2023spring 软件构造 笔记 Testing
zzu_zzdysq的博客
08-31 866
当你编码时，目标是使程序正常工作。但作为测试设计者，你希望让它失败。这是一个微妙但重要的区别。
基于SpringBoot景区商户管理系统
Rookie
09-03 520
开发语言：Java框架：springboot VueJDK版本：JDK1.8服务器：tomcat7数据库：mysql数据库工具：Navicat11开发软件：eclipse/myeclipse/ideaMaven包：Maven系统采用模块化设计思想，遵循高内聚、低耦合原则，将核心业务拆分为独立功能模块，便于开发、维护与扩展。模块划分基于银行客户管理的核心业务流程，结合 Spring Boot 的组件化开发特性，确保各模块职责清晰、协作高效。
企业级架构师综合能力项目案例一（各种组件集群搭建+SpringBoot整合）
usa_washington的博客
08-31 1029
第三方组件搭建以及和SpringBoot进行整合
Library cache lock常见案例分析（二）
Sebastien23的博客
08-31 49
此外，在库缓存中定位某个对象的操作过程中也会获取该锁（首先获取库缓存child latch以扫描句柄列表，找到对象后，再在该对象的句柄上放置此锁）。TKProfTKProf是Oracle数据库官方提供的核心性能诊断工具，主要用于分析数据库后台生成的SQL Trace（SQL 跟踪文件），将原始、杂乱的跟踪日志转换为结构化、可读性强的报告，帮助数据库管理员（DBA）和开发人员定位SQL语句的性能瓶颈（如执行效率低、资源消耗过高的SQL）。
评论 44
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

新绿MEHO

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值