Spring AOP -- 面相切面编程

简介: 【2月更文挑战第1天】基于注解 @Aspect;切点表达式;通知类型;多种通知类型的执行顺序;@Pointcut;多个切面类的执行顺序;@Order;基于自定义注解;给已有的注解进行功能的增强;AOP的优势:代码无侵入:不修改原始的业务方法,就可以对原始的业务方法进行了功能的增强或者是功能的改变;减少了重复代码;提高开发效率;维护方便。​

AOP是Spring框架的核心之一,AOP是一种思想,它的实现方法有很多,有Spring AOP,也有AspectJ、CGLIB等。我们熟知的拦截器其实就是AOP思想的一种实现方式。

AOP是一种思想,是对某一类事情的集中处理。

Spring AOP的实现方式:

  1. 基于注解 @Aspect;
  2. 基于自定义注解;
  3. 基于Spring API(通过xml配置的方式);
  4. 基于代理来实现。

想要实现Spring Aop需要先引入以下依赖。

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

image.gif

例如:我们此时想要优化一个接口的执行效率

此时有一个接口如下:

@RequestMapping("/aop")
@RestController
public class Main {
    @Autowired
    private ForService fs;
    @RequestMapping("/fun1")
    public void fun1() {
        fs.fun(3);
        for (int i = 0; i < 1000; i++) {};
    }
}

image.gif

@Service
public class ForService {
    public int fun(int i) {
        for (int j = 0; j < 3000; j++) {
            i++;
        }
        return i;
    }
}

image.gif

我们首先需要知道这个接口在执行过程中调用的各个方法的执行时间,然后再对每个方法进行针对性优化。用AOP思想来实现:

基于注解 @Aspect

@Slf4j
@Component
@Aspect
public class WritTime {
    @Around("execution(* com.example.Spring_demo.aop.*.*(..)))")
    public Object time(ProceedingJoinPoint pjp) throws Throwable {
        //记录开始时间
        long start = System.currentTimeMillis();
        //执行目标方法
        Object a = pjp.proceed();
        //打印方法执行时间。pjp.toShortString()方法会返回方法签名的简写
        log.info(pjp.toShortString()+":"+(System.currentTimeMillis()-start)+"ms");
        return a;
    }
}

image.gif

image.gif

image.gif

  • 切点:也称之为"切入点",提供⼀组规则(切点表达式)告诉程序对哪些方法来进行功能增强;
  • 连接点:满足切点表达式规则的方法,就是连接点。也就是可以被AOP控制的方法;
  • 通知:就是具体要做的工作,指哪些重复的逻辑,也就是共性功能(最终体现为⼀个方法);
  • 切面:切点+通知。
  • 切面类:切面所在的类,一个切面类中可以包含多个切面。

切点表达式:

常见的切点表达式有两种表达方式:

  1. execution(……):根据方法的签名来匹配
  2. @annotation(……):根据注解匹配

image.gif

访问修饰限定符和异常可以被省略。

* :匹配任意字符,只匹配一个元素(返回类型,包,类名,方法或者方法参数)

  • 包名使用 * 表示任意包(一层包使用一个*);
  • 类名使用 * 表示任意类;
  • 返回值使用 * 表示任意返回值类型;
  • 方法名使用 * 表示任意方法;
  • 参数使用 * 表示⼀个任意类型的参数。

.. :匹配多个连续的任意符号,可以通配任意层级的包,或任意类型,任意个数的参数

  • 使用 .. 配置包名,标识此包以及此包下的所有子包;
  • 可以使用 .. 配置参数,任意个任意类型的参数。

+:表示匹配当前类和其子类

通知类型:

  • @Around:环绕通知,此注解标注的通知方法在目标方法前后都被执行;
  • @Before:前置通知,此注解标注的通知方法在目标方法前被执行;
  • @After:后置通知,此注解标注的通知方法在目标方法后被执行;
  • @AfterReturning:返回后通知;
  • @AfterThrowing:异常后通知。

多种通知类型的执行顺序

现有如下接口:

@Slf4j
@RequestMapping("/aop")
@RestController
public class Main {
    @RequestMapping("/fun1")
    public void fun1() {
        log.info("执行fun1方法");
    }
}

image.gif

定义如下切面类,里面有多个切面。

@Slf4j
@Component
@Aspect
public class WritTime {
    @Around("execution(* com.example.Spring_demo.aop.*.*(..)))")
    public Object time(ProceedingJoinPoint pjp) throws Throwable {
        log.info("@Around 方法前");
        //执行目标方法
        Object a = pjp.proceed();
        log.info("@Around 方法后");
        return a;
    }
    @Before("execution(* com.example.Spring_demo.aop.*.*(..)))")
    public void before() {
        log.info("@Before 前置通知");
    }
    @After("execution(* com.example.Spring_demo.aop.*.*(..)))")
    public void After() {
        log.info("@After 后置通知");
    }
    @AfterReturning("execution(* com.example.Spring_demo.aop.*.*(..)))")
    public void AfterReturning() {
        log.info("@AfterReturning 返回后通知");
    }
    @AfterThrowing("execution(* com.example.Spring_demo.aop.*.*(..)))")
    public void AfterThrowing() {
        log.info("@AfterThrowing 异常后通知");
    }
}

image.gif

image.gif

如果发生异常:

image.gif

异常是可以再切面中被捕获的,但需要通知类型为@Around

image.gif

@Pointcut

@Pointcut注解可以把公共的切点表达式提取出来,需要用到时引用该切入点表达式即可。

@Slf4j
@Component
@Aspect
public class WritTime {
    @Pointcut("execution(* com.example.Spring_demo.aop.*.*(..)))")
    public void pc(){}
    @Around("pc()")
    public Object time(ProceedingJoinPoint pjp) {
        log.info("@Around 方法前");
        //执行目标方法
        Object a = null;
        try {
            a = pjp.proceed();
        } catch (Throwable e) {
        }
        log.info("@Around 方法后");
        return a;
    }
    @Before("pc()")
    public void before() {
        log.info("@Before 前置通知");
    }
    @After("pc()")
    public void After() {
        log.info("@After 后置通知");
    }
    @AfterReturning("pc()")
    public void AfterReturning() {
        log.info("@AfterReturning 返回后通知");
    }
    @AfterThrowing("pc()")
    public void AfterThrowing() {
        log.info("@AfterThrowing 异常后通知");
    }
}

image.gif

image.gif

声明的切面表达式也可以再其他切面类中使用但需要提前声明

@Slf4j
@Component
@Aspect
public class WritTime1 {
    //()里引用的切面表达式前必须加上全限定类名
    @Before("com.example.Spring_demo.aop.WritTime.pc()")
    public void before() {
        log.info("WritTime1通知");
    }
}

image.gif

image.gif

多个切面类的执行顺序

@Slf4j
@RequestMapping("/aop")
@RestController
public class Main {
    @RequestMapping("/fun1")
    public void fun1() {
        log.info("执行fun1方法");
    }
}

image.gif

定义以下三个切面类,每个类里面只有一个切面:

//第一个
@Slf4j
@Component
@Aspect
public class WritTime1 {
    @Before("execution(* com.example.Spring_demo.aop.*.*(..)))")
    public void before() {
        log.info("WritTime1通知");
    }
}
//第二个
@Slf4j
@Component
@Aspect
public class WritTime2 {
    @Before("execution(* com.example.Spring_demo.aop.*.*(..)))")
    public void before() {
        log.info("WritTime2通知");
    }
}
//第三个
@Slf4j
@Component
@Aspect
public class WritTime3 {
    @Before("execution(* com.example.Spring_demo.aop.*.*(..)))")
    public void before() {
        log.info("WritTime3通知");
    }
}

image.gif

image.gif

如果存在多个切面类执行顺序默认是按照类名进行排序。

@Order

当存在多个切面类时可以通过@Order注解来定义各个切面类的优先级。

对上述切面类进行细微修改加上注解

//第一个
@Slf4j
@Component
@Aspect
@Order(3)
public class WritTime1 {
    ……
}
//第二个
@Slf4j
@Component
@Aspect
@Order(2)
public class WritTime2 {
    ……
}
//第三个
@Slf4j
@Component
@Aspect
@Order(1)
public class WritTime3 {
    ……
}

image.gif

image.gif

基于自定义注解

使用自定义注解来计算方法的执行时间。

声明一个自定义注解:

//表示该接口只能作用于方法
@Target({ElementType.METHOD})
//该接口的生命周期
@Retention(RetentionPolicy.RUNTIME)
public @interface Time {
}

image.gif

使用切面类实现该注解的功能:

@Slf4j
@Component
@Aspect
public class WritTime {
    //@annotation里面的值为要实现的目标注解的全限定类名
    @Around("@annotation(com.example.Spring_demo.aop.Time)")
    public Object time(ProceedingJoinPoint pjp) throws Throwable {
        //记录开始时间
        long start = System.currentTimeMillis();
        //执行目标方法
        Object a = pjp.proceed();
        //打印方法执行时间。pjp.toShortString()方法会返回方法签名的简写
        log.info(pjp.toShortString()+":"+(System.currentTimeMillis()-start)+"ms(注解实现)");
        return a;
    }
}

image.gif

给待测方法添加注解

@Slf4j
@RequestMapping("/aop")
@RestController
public class Main {
    @Autowired
    private ForService forService;
    @Time
    @RequestMapping("/fun1")
    public void fun1() {
        forService.fun(1);
        for (int i = 0; i < 10; i++) {}
    }
}

image.gif

image.gif

给已有的注解进行功能的增强

还可以使用上面的方式给已有的注解进行功能的增强(给@RequestMapping注解添加可以打印接口执行时间的功能):

@Slf4j
@Component
@Aspect
public class WritTime {
    //@annotation里面的值为@RequestMapping注解的全限定类名   
    @Around("@annotation(org.springframework.web.bind.annotation.RequestMapping)")
    public Object time(ProceedingJoinPoint pjp) throws Throwable {
        //记录开始时间
        long start = System.currentTimeMillis();
        //执行目标方法
        Object a = pjp.proceed();
        //打印方法执行时间。pjp.toShortString()方法会返回方法签名的简写
        log.info(pjp.toShortString()+":"+(System.currentTimeMillis()-start)+"ms(注解实现)");
        return a;
    }
}

image.gif

image.gif

AOP的优势:

  1. 代码无侵入:不修改原始的业务方法,就可以对原始的业务方法进行了功能的增强或者是功能的改变;
  2. 减少了重复代码;
  3. 提高开发效率;
  4. 维护方便。
目录
相关文章
|
16天前
|
XML Java 数据安全/隐私保护
Spring Aop该如何使用
本文介绍了AOP(面向切面编程)的基本概念和术语,并通过具体业务场景演示了如何在Spring框架中使用Spring AOP。文章详细解释了切面、连接点、通知、切点等关键术语,并提供了完整的示例代码,帮助读者轻松理解和应用Spring AOP。
Spring Aop该如何使用
|
1月前
|
存储 缓存 Java
Spring高手之路23——AOP触发机制与代理逻辑的执行
本篇文章深入解析了Spring AOP代理的触发机制和执行流程,从源码角度详细讲解了Bean如何被AOP代理,包括代理对象的创建、配置与执行逻辑,帮助读者全面掌握Spring AOP的核心技术。
40 3
Spring高手之路23——AOP触发机制与代理逻辑的执行
|
21天前
|
Java Spring
[Spring]aop的配置与使用
本文介绍了AOP(面向切面编程)的基本概念和核心思想。AOP是Spring框架的核心功能之一,通过动态代理在不修改原代码的情况下注入新功能。文章详细解释了连接点、切入点、通知、切面等关键概念,并列举了前置通知、后置通知、最终通知、异常通知和环绕通知五种通知类型。
30 1
|
17天前
|
安全 Java 测试技术
Java开发必读,谈谈对Spring IOC与AOP的理解
Spring的IOC和AOP机制通过依赖注入和横切关注点的分离,大大提高了代码的模块化和可维护性。IOC使得对象的创建和管理变得灵活可控,降低了对象之间的耦合度;AOP则通过动态代理机制实现了横切关注点的集中管理,减少了重复代码。理解和掌握这两个核心概念,是高效使用Spring框架的关键。希望本文对你深入理解Spring的IOC和AOP有所帮助。
31 0
|
2月前
|
设计模式 Java 测试技术
spring复习04,静态代理动态代理,AOP
这篇文章讲解了Java代理模式的相关知识,包括静态代理和动态代理(JDK动态代理和CGLIB),以及AOP(面向切面编程)的概念和在Spring框架中的应用。文章还提供了详细的示例代码,演示了如何使用Spring AOP进行方法增强和代理对象的创建。
spring复习04,静态代理动态代理,AOP
|
1月前
|
Java 编译器 Spring
Spring AOP 和 AspectJ 的区别
Spring AOP和AspectJ AOP都是面向切面编程(AOP)的实现,但它们在实现方式、灵活性、依赖性、性能和使用场景等方面存在显著区别。‌
81 2
|
1月前
|
Java Spring 容器
Spring IOC、AOP与事务管理底层原理及源码解析
【10月更文挑战第1天】Spring框架以其强大的控制反转(IOC)和面向切面编程(AOP)功能,成为Java企业级开发中的首选框架。本文将深入探讨Spring IOC和AOP的底层原理,并通过源码解析来揭示其实现机制。同时,我们还将探讨Spring事务管理的核心原理,并给出相应的源码示例。
134 9
|
1月前
|
XML Java 数据格式
Spring的IOC和AOP
Spring的IOC和AOP
48 0
|
2月前
|
Java 数据库连接 数据库
Spring基础3——AOP,事务管理
AOP简介、入门案例、工作流程、切入点表达式、环绕通知、通知获取参数或返回值或异常、事务管理
Spring基础3——AOP,事务管理
|
3月前
|
Java Spring XML
掌握面向切面编程的秘密武器:Spring AOP 让你的代码优雅转身,横切关注点再也不是难题!
【8月更文挑战第31天】面向切面编程(AOP)通过切面封装横切关注点,如日志记录、事务管理等,使业务逻辑更清晰。Spring AOP提供强大工具,无需在业务代码中硬编码这些功能。本文将深入探讨Spring AOP的概念、工作原理及实际应用,展示如何通过基于注解的配置创建切面,优化代码结构并提高可维护性。通过示例说明如何定义切面类、通知方法及其应用时机,实现方法调用前后的日志记录,展示AOP在分离关注点和添加新功能方面的优势。
59 0
下一篇
无影云桌面