1. AOP概述

2. Spring AOP快速入门

2.1 引入AOP依赖

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

package com.example.demo.component;

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;

@Aspect
@Component
@Slf4j
public class TimeAspect {
    /**
     * 记录⽅法耗时
     */
    @Around("execution(* com.example.demo.controller.*.*(..))")
    public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
        //记录⽅法执⾏开始时间
        long begin = System.currentTimeMillis();
        //执⾏原始⽅法
        Object result = pjp.proceed();
        //记录⽅法执⾏结束时间
        long end = System.currentTimeMillis();
        //记录⽅法执⾏耗时
        log.info(pjp.getSignature() + "执⾏耗时: {}ms", end - begin);
        return result;
    }
}

整个代码划分为三部分  

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

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

• 代码⽆侵⼊: 不修改原始的业务⽅法, 就可以对原始的业务⽅法进⾏了功能的增强或者是功能的改变

• 减少了重复代码

• 提⾼开发效率

• 维护⽅便

3. Spring AOP 详解 

3.1 Spring AOP核⼼概念

3.1.1 切点(Pointcut)

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

3.1.2 连接点(Join Point)

满⾜切点表达式规则的⽅法, 就是连接点.

也就是可以被AOP控制的⽅法

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

上述controller 中的⽅法都是连接点

切点和连接点的关系

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

比如:

切点表达式: 娱乐圈所有明星

连接点就是: 张艺兴、黄渤等各个明星

3.1.3 通知(Advice)

3.1.4 切⾯(Aspect)

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

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

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

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

3.2 通知类型

@Around 就是其中⼀种通知类型, 表⽰环绕通知.

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

• @Around: 环绕通知, 此注解标注的通知⽅法在⽬标⽅法前, 后都被执⾏

• @Before: 前置通知, 此注解标注的通知⽅法在⽬标⽅法前被执⾏

• @After: 后置通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, ⽆论是否有异常都会执⾏

• @AfterReturning: 返回后通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, 有异常不会执⾏

• @AfterThrowing: 异常后通知, 此注解标注的通知⽅法发⽣异常后执⾏

3.2.1 结合代码学习

 2. 异常时的情况

3.3 @PointCut

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

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

Spring提供了 @PointCut 注解, 把公共的切点表达式提取出来, 需要⽤到时引⽤该切⼊点表达式即可.

上述代码就可以修改为:

3.4 切⾯优先级 @Order  

通过上述运⾏结果, 可以看出:

存在多个切⾯类时, 默认按照切⾯类的类名字⺟排序：

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

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

但这种⽅式不⽅便管理, 我们的类名更多还是具备⼀定含义的.

Spring 给我们提供了⼀个新的注解, 来控制这些切⾯通知的执⾏顺序: @Order

 使用方式如下

@Aspect
@Component
@Order(2)
public class AspectDemo2 {
 //...代码省略
}

@Aspect
@Component
@Order(1)
public class AspectDemo3 {
 //...代码省略
}

@Aspect
@Component
@Order(3)
public class AspectDemo4 {
 //...代码省略
}

通过上述程序的运⾏结果, 得出结论:

@Order 注解标识的切⾯类, 执⾏顺序如下:

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

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

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

3.5 切点表达式

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

1. * ：匹配任意字符，只匹配⼀个元素(返回类型, 包, 类名, ⽅法或者⽅法参数)

a. 包名使⽤ * 表⽰任意包(⼀层包使⽤⼀个*)

b. 类名使⽤ * 表⽰任意类

c. 返回值使⽤ * 表⽰ 任意返回值类型

d. ⽅法名使⽤ * 表⽰任意⽅法

e. 参数使⽤ * 表⽰⼀个任意类型的参数

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

a. 使⽤ .. 配置包名，标识此包以及此包下的所有⼦包

b. 可以使⽤ .. 配置参数，任意个任意类型的参数

• TestController 下的 public修饰, 返回类型为String ⽅法名为t1, ⽆参⽅法
• execution(public String com.example.demo.controller.TestController.t1())

• 省略访问修饰符
• execution(public 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..*(..)) 

3.5.2 @annotation

结合代码学习

准备测试代码

3.5.2.1 ⾃定义注解 @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

3.5.2.2 切⾯类

3.5.2.3 添加⾃定义注解 

4.Spring AOP的实现⽅式(常⻅⾯试题)

1. 基于注解 @Aspect (参考上述课件内容)

2. 基于⾃定义注解 (参考⾃定义注解 @annotation 部分的内容)

3. 基于Spring API (通过xml配置的⽅式, ⾃从SpringBoot ⼴泛使⽤之后, 这种⽅法⼏乎看不到了, 课

下⾃⼰了解下即可)

4. 基于代理来实现(更加久远的⼀种实现⽅式, 写法笨重, 不建议使⽤)

 5.Spring AOP 原理

5.1 代理模式

⽐如房屋租赁

Subject 就是提前定义了房东做的事情, 交给中介代理, 也是中介要做的事情

RealSubject: 房东

Proxy: 中介

UML类图如下:

5.1.1 静态代理

静态代理: 在程序运⾏前, 代理类的 .class⽂件就已经存在了. (在出租房⼦之前, 中介已经做好了相关的⼯作, 就等租⼾来租房⼦了)

我们通过代码来加深理解. 以房租租赁为例

1. 定义接⼝(定义房东要做的事情, 也是中介需要做的事情)

2.实现接⼝(房东出租房⼦)

 3.代理(中介, 帮房东出租房⼦)

 4.使用

接下来新增需求:

中介⼜新增了其他业务: 代理房屋出售

我们需要对上述代码进⾏修改

 

5.1.2 动态代理

Java也对动态代理进⾏了实现, 并给我们提供了⼀些API, 常⻅的实现⽅式有两种

1. JDK动态代理

2. CGLIB动态代理

5.1.2.1 JDK动态代理 

5.1.2.1.1 JDK 动态代理类实现步骤

1.定义JDK动态代理类 

2.创建⼀个代理对象并使用

3.代码详解

通过实现 InvocationHandler 接⼝的方法, 可以对被代理对象的⽅法进⾏功能增强. 

这个⽅法⼀共有 3 个参数：

Loader: 类加载器, ⽤于加载代理对象.

interfaces : 被代理类实现的⼀些接⼝(这个参数的定义, 也决定了JDK动态代理只能代理实现了接⼝的⼀些类)

h : 实现了 InvocationHandler 接⼝的对象

5.1.2.2 CGLIB动态代理  

JDK 动态代理有⼀个最致命的问题是其只能代理实现了接⼝的类.

有些场景下, 我们的业务代码是直接实现的, 并没有接⼝定义.

为了解决这个问题, 我们可以⽤ CGLIB 动 态代理机制来解决.

CGLIB(Code Generation Library)是⼀个基于ASM的字节码⽣成库，它允许我们在运⾏时对字节码进⾏修改和动态⽣成.

CGLIB 通过继承⽅式实现代理, 很多知名的开源框架都使⽤到了CGLIB. 例如 Spring中的 AOP 模块中: 如果⽬标对象实现了接⼝，则默认采⽤ JDK 动态代理, 否则采⽤ CGLIB 动态代理.

5.1.2.2.1 CGLIB 动态代理类实现步骤

1.添加依赖

< dependency >

< groupId >cglib</ groupId >

< artifactId >cglib</ artifactId >

< version >3.3.0</ version >

</ dependency >

2.⾃定义MethodInterceptor（⽅法拦截器）

3.创建代理类, 并使⽤ 

4.代码详解