前言:
大家好,我是良辰丫,面向切面编程和面向对象编程是两种几乎不同的编程方式,并不是所谓的孪生兄弟,但是我们可以说面向切面编程是面向对象编程的一种补充和完善,到底是什么意思呢?请跟随良辰的步伐往下瞧! ! !💌💌💌

🧑个人主页：良辰针不戳
📖所属专栏：javaEE进阶篇之框架学习
🍎励志语句：生活也许会让我们遍体鳞伤，但最终这些伤口会成为我们一辈子的财富。
💦期待大家三连，关注，点赞，收藏。
💌作者能力有限，可能也会出错，欢迎大家指正。
💞愿与君为伴，共探Java汪洋大海。

在这里插入图片描述

1. 初识AOP
2. AOP的作用
3. AOP的组成
- 3.1 切面 (Aspect)
- 3.2 连接点（Join Point）
- 3.3 切点 (Pointcut)
- 3.4 通知（Advice）
4. Spring AOP的实现
- 4.1 创建Spring Boot项目
- 4.2 添加AOP框架支持
- 4.3 定义切面
- 4.4 定义切点
- - 4.4.1 切点
  - 4.4.2 切点参数
- 4.5 定义通知
5. Spring AOP的实现原理
- 5.1 为什么要有AOP
- 5.2 简述AOP的动态代理
- 5.3 代理的生成时机
- 5.4 动态代理
- 5.4.1 JDK 动态代理实现
- 5.4.2 CGLIB 动态代理实现
- 5.4.3 JDK 和 CGLIB 实现的区别

1. 初识AOP

我们在前面学过OOP,OOP表示面向对象编程,面向对象的主体是对象,我们在初学java的时候就研究过对象的概念,对象简单来说就是对一个事物的描述,java中万物皆是对象,一个人,一个鸟等等都可以看做是一个对象.
接下来我们有接触了一个新的概念AOP（Aspect Oriented Programming）,它表示⾯向切⾯编程，它是⼀种思想，它是对某⼀类事情的集中处理.
什么是切面呢?我们买一个西瓜,用刀切开,就会形成一个面,那就是切面,在西瓜中我们可以通过切面看到它的成熟程度.
使⽤ AOP 可以扩充多个对象的某个能⼒，所以 AOP 可以说是 OOP（Object Oriented Programming，⾯向对象编程）的补充和完善。
上面我们提到面向切面编程是对某一类事情的集中处理,刚开始我们可以这样理解,某一个功能(函数/方法)是其它方法所共享的,我们只需要用一个方法封装这个功能,只需要写一次,用的时候直接调用即可.

那么AOP和Spring AOP有什么关系呢?

AOP 是⼀种思想,只是描述了AOP具体是什么.
Spring AOP 是⼀个框架，提供了⼀种对 AOP 思想的实现，它们的关系和IoC 与 DI 类似。

看到这里大家可能会说AOP究竟是什么,我还是一头雾水,不用着急,我们还没有具体介绍 AOP呢,接下来我们首先来看一下AOP具体有什么用.

2. AOP的作用

我们需要深刻记忆面向切面编程是对某一类事情的集中处理,这句话我多次提到说明它是面向切面编程的核心思想.
对于这种功能统一并且使⽤的地⽅较多的功能，就可以考虑 AOP来统⼀处理了,这样极大的减少了代码的冗余性,并且可以做到解耦.
两块代码我们不需要让它们强加某个功能,我们通过AOP可以做到解耦,单独处理即可.那两块代码只需要处理自己的业务逻辑即可.

AOP 的常见功能如下 :

登录判断,单独处理特殊的需要登录校验的地方.
统⼀⽇志记录,我们以前在学习日志的时候,使用一次需要调用一次,通过AOP我们可以单独处理出现频率比较高的日志.
统⼀⽅法执⾏时间统计,对比方法的执行时间,方便我们发现问题.此时我们可以针对慢的方法做一定的优化.
统⼀的返回格式设置,我们前后端交互,需要有统一的返回格式,通过AOP可以简化我们的后端代码.
统⼀的异常处理
事务的开启和提交

3. AOP的组成

3.1 切面 (Aspect)

切⾯（Aspect）由切点（Pointcut）和通知（Advice）组成，它既包含了横切逻辑的定义，也包括了连接点的定义。
我们可以理解为切面就是一个处理某方面问题的一个类,类里面包含了许多方法,这些方法就是切点和通知.
切面其实就是AOP实现某个功能的集合.

3.2 连接点（Join Point）

从字面意思来说,连接点就是连接几个东西(大于1),连接点相当于一个桥梁,通过这个桥梁把几个东西建立一定的联系.
接下来我们说明一下我们AOP里面的连接点,我们可以理解为应⽤执⾏过程中能够插⼊切⾯的⼀个点，这个点可以是⽅法调⽤时，抛出异常时，甚⾄修改字段时的点。切⾯代码可以利⽤这些点插⼊到应⽤的正常流程之中，并添加新的⾏为。
连接点相当于需要被增强的某个 AOP 功能的所有⽅法,连接点的作用是触发AOP规则的所有点(所有请求),概念有点抽象,我们只需要简单的理解为连接点可以把所有的请求联系在一起(调用AOP规则,通过AOP规则处理相关的事情,最大的作用就是减少冗余性)

3.3 切点 (Pointcut)

切点Pointcut 是匹配连接点Join Point 的谓词,我们通过切点才能处理连接点.
那么如何理解切点呢?Pointcut 的作⽤就是提供⼀组规则（使⽤ AspectJ pointcut expression language 来描述）来匹配 Join Point，给满⾜规则的 Join Point 添加 Advice(下面会详细介绍)。
切点相当于保存了众多连接点的⼀个集合（如果把切点看成⼀个表，⽽连接点就是表中⼀条⼀条的数据.
我们只需要把切点简单的理解为用来进行主动拦截的规则(说白了就是通过配置来进行制定规则)

3.4 通知（Advice）

通知是通过 Advice 这个单词直接翻译过来的,可能理解起来比较困难,我们在这里把通知理解为做的某个事情(或者工作).
通知定义了切⾯是什么，何时使⽤，描述了切⾯要完成的⼯作，还解决何时执⾏这个⼯作的
问题。
通俗来讲,程序中被拦截请求触发的具体动作(做的事情)就是在通知中实现具体的业务代码,这也是AOP所做的事情.

Spring 切⾯类中，可以在⽅法上使⽤以下注解，会设置⽅法为通知⽅法，在满⾜条件后会通知本⽅法进⾏调⽤：

前置通知使⽤ @Before：通知⽅法会在⽬标⽅法调⽤之前执⾏,也就是执行目标方法之前的方法就叫做前置通知.
后置通知使⽤ @After：通知⽅法会在⽬标⽅法返回或者抛出异常后调⽤,也就是执行目标方法之后执行的方法叫做后置通知.
返回通知使⽤ @AfterReturning：通知⽅法会在⽬标⽅法返回后调⽤,也就是目标方法执行了返回数据的时候执行了的通知叫做返回通知.
抛异常后通知使⽤ @AfterThrowing：通知⽅法会在⽬标⽅法抛出异常后调⽤,也就是在执行目标方法出现异常的时候执行的通知叫做异常通知.
环绕通知使⽤ @Around：通知包裹了被通知的⽅法，在被通知的⽅法通知之前和调⽤之后执⾏⾃定义的⾏为,也就是在目标方法执行的周期范围内(执行之前,执行中,执行后)都可以执行的方法叫做环绕通知.

看到这里,大家还会对通知的概念比较模糊,没关系,我们稍微举一个例子,就拿我们访问服务器进行举例吧.

如果没有任何通知,我们是直接访问服务器的.

如果有前置通知,我们先进行访问前置通知,随后再进行访问服务器.

AOP的基本概念已经结束了,我还是对AOP有点生疏,这是什么嘛,一会写代码的时候不是要整死我嘛?上面已经说了,这些概念比较抽象,我在说完了官方的理解之后会加一句自己的理解,我们只需要理解最基本的就可以,是大家想的复杂了,其实没有那么难,接下来我们通过一个简单的图来再次认识一下AOP的工作原理.

在这里插入图片描述

4. Spring AOP的实现

4.1 创建Spring Boot项目

因为现在绝大多数的项目都是基于Spring Boot的,因此我们就在Spring Boot的基础上去研究Spring AOP.
因此我们首先创一个Spring Boot项目,在前面Spring Boot的文章中我已经具体提到,在这里就不做详细描述了哈.

在这里插入图片描述

4.2 添加AOP框架支持

打开maven中央仓库搜索AOP,下面我故意写的大小写版本的AOP,都可以识别,大家不用纠结哈.

在这里插入图片描述
2. 注意要选择Spring Boot版本的,以前我们总是选择用的最多的.Spring 出现很多年了,之前一直在用,后来Spring Boot逐渐求取代了Spring Boot的地位,尽管这样,Spring Boot的AOP框架还是没有Spring用的多(这里的用的多不是指的当前,而是maven中央仓库的点击量,因为Spring 有额二十年的历史,Spring Boot只有不到十年)

选择相应的AOP版本,注意这个版本也不是随便选择的,要和我们的Spring Boot框架版本一致,比如我的Spring Boot框架是2.7.9,在这里的AOP 也要选择2.7.9.否则就可能会出现版本不匹配的问题.

在这里插入图片描述

复制框架依赖到我们的pom.xml文件中

在这里插入图片描述

maven刷新,有的idea版本会自动刷新,但是很多idea版本不会自动刷新,我们还是手动刷新一下比较好.

在这里插入图片描述

4.3 定义切面

我们在上面提到切面其实就是一个类,多次提及就是为了帮助大家理解.

切面需要随着项目的启动而启动,因此就需要添加五大注解,在这里我们把切面定义为一个组件,就使用注解@Component.
我们还需要告诉我们的程序这是一个切面,这个时候要使用注解@Aspect.
还是我们以前说的,Spring Boot的学习其实就是学习注解的过程.

package com.example.demo;

import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
//该注解表示这个类是一个切面
@Aspect
//该注解表示该类随着项目的启动而启动
@Component
public class UserAspect {
    
}

4.4 定义切点

4.4.1 切点

我们在切点中需要写一个空方法,它不需要有方法体,此方法名只是起到一个标识的作用,为什么Spring AOP这样设计呢?因为是一对多,切点可能有很多个,在空方法中只是标识通知中的方法具体指的哪个切点.要实现多个功能,具体的实现要在通知中进行.
切点说白了就是具体要处理的某⼀类问题，⽐如⽤户登录权限验证就是⼀个具体的问题.
在切点中我们定义一定的规则,比如拦截规则,密码错误进行拦截,无法正常登录.

package com.example.demo;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
//该注解表示这个类是一个切面
@Aspect
//该注解表示该类随着项目的启动而启动
@Component
public class StuAspect {
    //定义切点,配置拦截规则
@Pointcut("execution(* com.example.demo.controller.*.*(..))")
    public void pointcut() {
        
    }
}

4.4.2 切点参数

切点的注解Pointcut中的execution是固定写法,表示切点函数,用来匹配方法,里面的第一个号表示返回值, 号表示返回值可以是任意的.
两个点号也是匹配任意字符,可以匹配多个元素,在表示类时,必须和*好联合使用.
*号后面加一个空格,空格后面表示的路径,路径为包名+类名.
*号为通配符,在这里我们先简单说明.
加号表示按照类型匹配指定类的所有类,必须在类名后面,com.liangchen+表示继承该类的所有子类包括自身.
修饰符合异常可以省略,在这里我们先简单了解.

修饰符一般会省略
public 表示公共方法.
*号表示任意.
返回值不能省略
void表示没有返回值.
String表示返回值为字符串.
*号表示返回值为任意.
关于包
com.chen表示固定包.
com.chen.*表示com.chen包下的任意文件
com.chen..表示com.chen包下面的所有子包,包含自身.
com.chen.*.表示chen下面的任意子包
关于类
User表示指定的类
*user表示以user结尾的类
*表示任意类
方法名不能省略
user表示固定方法
user*表示以user开头的方法名
*user表示以user结尾的方法名.
*表示任意的方法名.
参数
()表示无参
(int)表示一个整型参数
(int,int)表示两个整型参数
(..)表示参数为任意
throws可省略,一般不写.

接下来我们举几个常用的例子来进行说明.

//1.匹配 User 类⾥的所有⽅法。
execution(* com.cad.demo.User.*(..)) 
//2.匹配该类的⼦类包括该类的所有方法
execution(* com.cad.demo.User+.*(..)) 
//3.匹配 com.cad 包下的所有类的所有⽅法。
execution(* com.cad.*.*(..)) 
//4.匹配 com.cad 包下、⼦孙包下所有类的方法
execution(* com.cad..*.*(..))
//5.匹配 addUser ⽅法，且第⼀个参数为String,第二个为int
execution(* addUser(String, int))

4.5 定义通知

通知定义的是被拦截的⽅法具体要执⾏的业务.
我们经常使用的通知有前置通知,后置通知和环绕通知,我们首先来看一下前置通知和后置通知,代码如下.

    @Before("pointcut()")
    public void beforeAdvice() {

        System.out.println("我是前置通知");
    }
    @After("pointcut()")
    public void afterAdvice() {
        
        System.out.println("我是后置通知");
    }

那么我们首先写一个controller层类,用来测试我们的AOP代码.

package com.example.demo.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/stu")
public class StuController {
    @RequestMapping("/hi")
    public String sayHi(String name) {
        System.out.println("执行了sayHi方法");
        return "Hi," + name;
    }
}

接下来我们启动我们的Spring Boot项目,然后通过浏览器访问我们的controller类.

在这里插入图片描述

然后我们观察我们的控制台.

在这里插入图片描述

sayHi是我们的目标方法,我们在上面介绍了前置通知和后置通知,在目标方法之前执行的通知叫做前置通知,在目标方法之后执行的通知叫做后置通知,我们可以用通知来进行登录校验.

接下来我们再写一个环绕通知.

    @Around("pointcut()")
    public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("进入环绕通知");
        Object obj = null;
        // 执行目标方法
        obj = joinPoint.proceed();
        System.out.println("退出环绕通知");
        return obj;
    }

接下来我们再次进行访问我们的页面.

在这里插入图片描述

随后我们观察我们的控制台,我们会发现环绕通知会在前置通知之前执行.

在这里插入图片描述

5. Spring AOP的实现原理

5.1 为什么要有AOP

看到这里大家明白为什么要有AOP了嘛?

我们以前写代码,程序员自己制定代码规则,写一块代码需要写一个规则;但是现在我们有了AOP,如果有通用的规则,我们只要写一次即可.
于是乎AOP的作用显而易见了,AOP其实就是通过某种匹配规则去匹配方法,然后再添加对应的日志处理.
AOP的实现原理是什么呢?不要着急,我们下面会进行介绍.

5.2 简述AOP的动态代理

Spring AOP 是构建在动态代理基础上，因此 Spring 对 AOP 的⽀持局限于⽅法级别的拦截.
Spring AOP ⽀持 JDK Proxy 和 CGLIB ⽅式实现动态代理。默认情况下，实现了接⼝的类，使⽤ AOP 会基于 JDK ⽣成代理类，没有实现接⼝的类，会基于 CGLIB ⽣成代理类.
调用者通过代理来调用目标对象.

5.3 代理的生成时机

织⼊（Weaving）是代理的⽣成时机.
织⼊是把切⾯应⽤到⽬标对象并创建新的代理对象的过程，切⾯在指定的连接点被织⼊到⽬标对象中。

在⽬标对象的⽣命周期⾥有多个点可以进⾏织⼊操作:

编译期：切⾯在⽬标类编译时被织⼊。这种⽅式需要特殊的编译器。AspectJ的织⼊编译器就是以这种⽅式织⼊切⾯的。
类加载期：切⾯在⽬标类加载到JVM时被织⼊,这种⽅式需要特殊的类加载器（ClassLoader）,它可以在⽬标类被引⼊应⽤之前增强该⽬标类的字节码。AspectJ5的加载时织⼊（load-time weaving. LTW）就⽀持以这种⽅式织⼊切⾯。
运⾏期：切⾯在应⽤运⾏的某⼀时刻被织⼊。⼀般情况下，在织⼊切⾯时，AOP容器会为⽬标对象动态创建⼀个代理对象。SpringAOP就是以这种⽅式织⼊切⾯的。

5.4 动态代理

AOP的实现在设计模式上称为动态代理模式，在实现的技术⼿段上，都是在 class 代码运⾏期，动态的织⼊字节码。
我们学习 Spring 框架中的AOP，主要基于两种⽅式：JDK 及 CGLIB 的⽅式。这两种⽅式的代理⽬标都是被代理类中的⽅法，在运⾏期，动态的织⼊字节码⽣成代理类。
CGLIB是Java中的动态代理框架，主要作⽤就是根据⽬标类和⽅法，动态⽣成代理类。
Java中的动态代理框架，⼏乎都是依赖字节码框架（如 ASM，Javassist 等）实现的。
字节码框架是直接操作 class 字节码的框架。可以加载已有的class字节码⽂件信息，修改部分信息，或动态⽣成⼀个 class。

接下来我们简单认识一下两种动态代理的实现方式.

5.4.1 JDK 动态代理实现

JDK 实现时，先通过实现 InvocationHandler 接⼝创建⽅法调⽤处理器，再通过 Proxy 来创建代理类。

//import org.example.demo.service.AliPayService;
//import org.example.demo.service.PayService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//动态代理：使⽤JDK提供的api（InvocationHandler、Proxy实现），
//此种⽅式实现，要求被代理类必须实现接⼝
    public class PayServiceJDKInvocationHandler implements InvocationHandler {
        //⽬标对象即就是被代理对象
        private Object target;

        public PayServiceJDKInvocationHandler( Object target) {
            this.target = target;
        }

        //proxy代理对象
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //1.安全检查
            System.out.println("安全检查");
            //2.记录⽇志
            System.out.println("记录⽇志");
            //3.时间统计开始
            System.out.println("记录开始时间");
            //通过反射调⽤被代理类的⽅法
            Object retVal = method.invoke(target, args);
            //4.时间统计结束
            System.out.println("记录结束时间");
            return retVal;
        }
        public static void main(String[] args) {
            PayService target= new AliPayService();
            //⽅法调⽤处理器
            InvocationHandler handler =
                    new PayServiceJDKInvocationHandler(target);
            //创建⼀个代理类：通过被代理类、被代理实现的接⼝、⽅法调⽤处理器来创建
            PayService proxy = (PayService) Proxy.newProxyInstance(
                    target.getClass().getClassLoader(),
                    new Class[]{PayService.class},
                    handler
            );
            proxy.pay();
        }
    }

5.4.2 CGLIB 动态代理实现

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.example.demo.service.AliPayService;
import org.example.demo.service.PayService;
import java.lang.reflect.Method;
    public class PayServiceCGLIBInterceptor implements MethodInterceptor {
        //被代理对象
        private Object target;

        public PayServiceCGLIBInterceptor(Object target){
            this.target = target;
        }

        @Override
        public Object intercept(Object o, Method method, Object[] args, Method
                Proxy methodProxy) throws Throwable {
            //1.安全检查
            System.out.println("安全检查");
            //2.记录⽇志
            System.out.println("记录⽇志");
            //3.时间统计开始
            System.out.println("记录开始时间");
            //通过cglib的代理⽅法调⽤
            Object retVal = methodProxy.invoke(target, args);
            //4.时间统计结束
            System.out.println("记录结束时间");
            return retVal;
        }

        public static void main(String[] args) {
            PayService target= new AliPayService();
            PayService proxy= (PayService) Enhancer.create(target.getClass(),n
                    ew PayServiceCGLIBInterceptor(target));
            proxy.pay();
        }
    }

5.4.3 JDK 和 CGLIB 实现的区别

JDK 实现，要求被代理类必须实现接⼝，之后是通过 InvocationHandler 及 Proxy，在运⾏时动态的在内存中⽣成了代理类对象，该代理对象是通过实现同样的接⼝实现（类似静态代理接⼝实现的⽅式），只是该代理类是在运⾏期时，动态的织⼊统⼀的业务逻辑字节码来完成。
CGLIB 实现，被代理类可以不实现接⼝，是通过继承被代理类，在运⾏时动态的⽣成代理类对象。