深入探索String AOP想详情

一.AOP的概述

AOP是Spring框架的第⼆⼤核⼼(第⼀⼤核⼼是IoC）

Q:什么是AOP？

A:Aspect Oriented Programming（⾯向切⾯编程）

什么是⾯向切⾯编程呢? 切⾯就是指某⼀类特定问题, 所以AOP也可以理解为⾯向特定⽅法编程. 什么是⾯向特定⽅法编程呢? ⽐如上个章节学习的"登录校验", 就是⼀类特定问题. 登录校验拦截器, 就是对"登录校验"这类问题的统⼀处理. 所以, 拦截器也是AOP的⼀种应⽤. AOP是⼀种思想, 拦截器是AOP思想的⼀种实现. Spring框架实现了这种思想, 提供了拦截器技术的相关接⼝.

同样的, 统⼀数据返回格式和统⼀异常处理, 也是AOP思想的⼀种实现.

简单来说: AOP是⼀种思想, 是对某⼀类事情的集中处理.

什么是Spring AOP?

AOP是⼀种思想, 它的实现⽅法有很多, 有Spring AOP，也有AspectJ、CGLIB等.

Spring AOP是其中的⼀种实现⽅式.

学会了统⼀功能之后, 是不是就学会了Spring AOP呢, 当然不是.

拦截器作⽤的维度是URL(⼀次请求和响应), @ControllerAdvice 应⽤场景主要是全局异常处理

(配合⾃定义异常效果更佳), 数据绑定, 数据预处理. AOP作⽤的维度更加细致(可以根据包、类、⽅法名、参数等进⾏拦截), 能够实现更加复杂的业务逻辑.

二.AOP入门程序

现在有⼀些业务的执⾏效率⽐较低, 耗时较⻓, 我们需要对接⼝进⾏优化.

第⼀步就需要定位出执⾏耗时⽐较⻓的业务⽅法, 再针对该业务⽅法来进

如何定位呢? 我们就需要统计当前项⽬中每⼀个业务⽅法的执⾏耗时.

如何统计呢? 可以在业务⽅法运⾏前和运⾏后, 记录下⽅法的开始时间和结束时间, 两者之差就是这个⽅法的耗时.

这种⽅法是可以解决问题的, 但⼀个项⽬中会包含很多业务模块, 每个业务模块⼜有很多接⼝, ⼀个接⼝⼜包含很多⽅法, 如果我们要在每个业务⽅法中都记录⽅法的耗时, 对于程序员⽽⾔, 会增加很多的⼯作量。

AOP就可以做到在不改动这些原始⽅法的基础上, 针对特定的⽅法进⾏功能的增强.

接下来我们来看Spring AOP如何来实现。

1.引入依赖

代码：

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

2.在建包（aspect），创建一个TimeRecordAspect.类

作用范围是controller包下所有类的方法。

代码：

package com.example.demo.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//交给Spring管理
@Aspect
public class TimeRecordAspect {
/*记录耗时*/
    @Around("execution(* com.example.demo.controller.*.*(..))")//作用范围
    public Object timeRecord(ProceedingJoinPoint joinPoint) throws Throwable {
        //记录开始时间
        long start = System.currentTimeMillis();
        //执行目标方法
        Object proceed = joinPoint.proceed();
        //记录结束时间
        long end = System.currentTimeMillis();
        log.info("时间耗时："+(end - start)+"ms");
        return  proceed;

    }

}

@Aspect: 标识这是⼀个切⾯类
@Around: 环绕通知, 在⽬标⽅法的前后都会被执⾏. 后⾯的表达式表⽰对哪些⽅法进⾏增强.
ProceedingJoinPoint.proceed() 让原始方法执行

3.入侵 controller包的三个方法

package com.example.demo.controller;

import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;




@RequestMapping("t1")
    public void sayHi(){
       // userService.doService();
        System.out.println("do controller...");
    }
    public int test1(){
        int count = 0;
        for (int i = 0; i < 10000; i++) {
             count += i;
        }
        return count;
    }
    public int test2(){
        int count = 0;
        for (int i = 0; i < 10000000; i++) {
            count += i;
        }
        return count;
    }

}

4.运行程序，观察日志

我们通过AOP⼊⻔程序完成了业务接⼝执⾏耗时的统计.

通过上⾯的程序, 我们也可以感受到AOP⾯向切⾯编程的⼀些优势：

模块化：通过将横切关注点从主要业务逻辑中分离出来，实现了更好的模块化。在上面的例子中，服务团队负责处理非烹饪业务，使得厨师们可以专注于烹饪。同样，在软件开发中，AOP使得代码更加模块化，易于理解和维护。
重用性：AOP允许开发者将横切关注点封装为可重用的模块（切面），并在需要时将其应用于不同的模块中。例如，日志记录功能可以在多个服务或组件中被重用，而无需在每个地方都编写相同的代码。
解耦合：AOP将横切关注点与主要业务逻辑分离开来，降低了它们之间的耦合度。这使得代码更加灵活，易于修改和扩展。在上面的例子中，如果餐厅需要改变支付方式，服务团队可以独立地进行调整，而不需要厨师们参与。
提高开发效率：通过减少重复代码和降低耦合度，AOP提高了开发效率。开发者可以更快地编写和维护代码，同时减少了出错的可能性。

简而言之：

代码⽆侵⼊: 不修改原始的业务⽅法, 就可以对原始的业务⽅法进⾏了功能的增强或者是功能的改变
减少了重复代码
提⾼开发效率
维护⽅便

三.Spring AOP 详解

3.1Spring AOP中涉及的核⼼概念

3.1.1切点(Pointcut)

切点(Pointcut), 也称之为"切⼊点

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

上⾯的表达式 execution(* com.example.demo.controller.*.*(..)) 就是切点表达式.

3.1.2 连接点(Join Point)

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

以⼊⻔程序举例, 所有 com.example.demo.controller 路径下的⽅法, 都是连接点.

package com.example.demo.controller;

import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("Test")
public class UserController {
//    private  UserService userService;
//    @Autowired
//    private UserService userService;


//    //通过构造方法注入
//    public UserController( ) {
//
//    }
//    @Autowired
//    public UserController(UserService userService) {
//        this.userService = userService;
//    }

    //通过Setter方法注入
//    @Autowired
//
//    public void setUserService(UserService userService) {
//        this.userService = userService;
//    }






@RequestMapping("t1")
    public void sayHi(){
       // userService.doService();
        System.out.println("do controller...");
    }
    public int test1(){
        int count = 0;
        for (int i = 0; i < 10000; i++) {
             count += i;
        }
        return count;
    }
    public int test2(){
        int count = 0;
        for (int i = 0; i < 10000000; i++) {
            count += i;
        }
        return count;
    }

}

切点和连接点的关系

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

3.1.3 通知(Advice)

通知就是具体要做的⼯作, 指哪些重复的逻辑，也就是共性功能(最终体现为⼀个⽅法)

⽐如上述程序中记录业务⽅法的耗时时间, 就是通知.

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

3.1.4 切⾯(Aspect)

切⾯(Aspect) = 切点(Pointcut) + 通知(Advice)

通过切⾯就能够描述当前AOP程序需要针对于哪些⽅法, 在什么时候执⾏什么样的操作.

切⾯既包含了通知逻辑的定义, 也包括了连接点的定义.

切⾯所在的类, 我们⼀般称为切⾯类 .

3.2Spring AOP通知类型

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

Spring中AOP的通知类型有以下⼏种:

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

接下来我们通过代码来加深对这⼏个通知的理解:

为⽅便学习, 我们可以新建⼀个项⽬

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Slf4j
@Aspect
@Component
public class AspectDemo {
    //前置通知
    @Before("execution(* com.example.demo.controller.*.*(..))")
    public void doBefore() {
        log.info("执⾏ Before ⽅法");
    }
    //后置通知
    @After("execution(* com.example.demo.controller.*.*(..))")
    public void doAfter() {
        log.info("执⾏ After ⽅法");
    }
    //返回后通知
    @AfterReturning("execution(* com.example.demo.controller.*.*(..))")
    public void doAfterReturning() {
        log.info("执⾏ AfterReturning ⽅法");
    }
    //抛出异常后通知
    @AfterThrowing("execution(* com.example.demo.controller.*.*(..))")
    public void doAfterThrowing() {
        log.info("执⾏ doAfterThrowing ⽅法");
    }
    //添加环绕通知
    @Around("execution(* com.example.demo.controller.*.*(..))")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("Around ⽅法开始执⾏");
        Object result = joinPoint.proceed();
        log.info("Around ⽅法结束执⾏");
        return result;
    }
}

写⼀些测试程序:

package com.example.demo.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RequestMapping("/test")
@RestController
public class TestController {
    @RequestMapping("/t1")
    public String t1() {
        return "t1";
    }
    @RequestMapping("/t2")
    public boolean t2() {
        int a = 10 / 0;
        return true;
    }
}

运⾏程序, 观察⽇志:

1. 正常运⾏的情况

观察日志：

程序正常运⾏的情况下, @AfterThrowing 标识的通知⽅法不会执⾏。

从上图也可以看出来, @Around 标识的通知⽅法包含两部分, ⼀个"前置逻辑", ⼀个"后置逻辑".其

中"前置逻辑" 会先于 @Before 标识的通知⽅法执⾏, "后置逻辑" 会晚于 @After 标识的通知⽅法执

⾏。

2.异常时的情况

观察⽇志:

程序发⽣异常的情况下：

• @AfterReturning 标识的通知⽅法不会执⾏， @AfterThrowing 标识的通知⽅法执⾏了

• @Around 环绕通知中原始⽅法调⽤时有异常，通知中的环绕后的代码逻辑也不会在执⾏了(因为

原始⽅法调⽤出异常了)

注意事项:

• @Around 环绕通知需要调⽤ ProceedingJoinPoint.proceed() 来让原始⽅法执⾏, 其他

通知不需要考虑⽬标⽅法执⾏.

• @Around 环绕通知⽅法的返回值, 必须指定为Object, 来接收原始⽅法的返回值, 否则原始⽅法执

⾏完毕, 是获取不到返回值的.

• ⼀个切⾯类可以有多个切点.

3.3@PointCut

上⾯代码存在⼀个问题, 就是存在⼤量重复的切点表达式 execution(*

com.example.demo.controller.*.*(..)) , Spring提供了 @PointCut 注解, 把公共的切点

表达式提取出来, 需要⽤到时引⽤该切⼊点表达式即可.

上述代码就可以修改为:

@Slf4j
@Aspect
@Component
public class AspectDemo {
    //定义切点(公共的切点表达式)
    @Pointcut("execution(* com.example.demo.controller.*.*(..))")
    private void pt(){}
    //前置通知
    @Before("pt()")
    public void doBefore() {
        //...代码省略
    }
    //后置通知
    @After("pt()")
    public void doAfter() {
        //...代码省略
    }
    //返回后通知
    @AfterReturning("pt()")
    public void doAfterReturning() {
        //...代码省略
    }
    //抛出异常后通知
    @AfterThrowing("pt()")
    public void doAfterThrowing() {
        //...代码省略
    }
    //添加环绕通知
    @Around("pt()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        //...代码省略
    }
}

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

@Slf4j
@Aspect
@Component
public class AspectDemo2 {
 //前置通知
 @Before("com.example.demo.aspect.AspectDemo.pt()")
 public void doBefore() {
 log.info("执⾏ AspectDemo2 -> Before ⽅法");
 }
}