Spring AOP

1.Spring AOP

1.1 日志处理带来的问题

我们有一个Pay(接口) 然后两个实现类DollarPay和RmbPay，都需要重写pay()方法, 这时我们需要对pay方法进行性能监控，日志的添加等等怎么做？

1.1.1 最容易想到的方法

对每个字符方法均做日志代码的编写处理，如下面方式

缺点: 代码重复太多, 添加的日志代码耦合度太高（如果需要更改日志记录代码功能需求，类中方法需要全部改动，工程量浩大）

1.1.2 使用装饰器模式 /代理模式改进解决方案

装饰器模式：动态地给一个对象添加一些额外的职责。
代理模式：以上刚讲过。于是得出以下结构：

仔细考虑过后发现虽然对原有内部代码没有进行改动，对于每个类做日志处理，并引用目标类，但是如果待添加日志的业务类的数量很多，此时手动为每个业务类实现一个装饰器或创建对应的代理类，同时代码的耦合度也加大，需求一旦改变，改动的工程量也是可想而知的。

有没有更好的解决方案，只要写一次代码，对想要添加日志记录的地方能够实现代码的复用，达到松耦合的同时，又能够完美完成功能？

答案是肯定的，存在这样的技术，aop已经对其提供了完美的实现！

1.2 什么是AOP

Aspect Oriented Programing 面向切面编程，相比较 oop 面向对象编程来说，Aop关注的不再是程序代码中某个类，某些方法，而aop考虑的更多的是一种面到面的切入，即层与层之间的一种切入，所以称之为切面。联想大家吃的汉堡（中间夹肉）。那么aop是怎么做到拦截整个面的功能呢？考虑前面学到的servlet filter /* 的配置 ，实际上也是aop 的实现。

1.3 AOP能做什么

AOP主要应用于日志记录，性能统计，安全控制，事务处理等方面，实现公共功能性的重复使用。

1.4 AOP的特点

• 降低模块与模块之间的耦合度，提高业务代码的聚合度。（高内聚低耦合）
• 提高了代码的复用性。
• 提高系统的扩展性。（高版本兼容低版本）
• 可以在不影响原有的功能基础上添加新的功能

1.5 AOP的底层实现

动态代理（JDK + CGLIB）

1.6 AOP基本概念

1.6.1 Joinpoint（连接点）

被拦截到的每个点，spring中指被拦截到的每一个方法，spring aop一个连接点即代表一个方法的执行。

1.6.2 Pointcut（切入点）

对连接点进行拦截的定义（匹配规则定义 规定拦截哪些方法，对哪些方法进行处理），spring 有专门的表达式语言定义。

1.6.3 Advice（通知）

拦截到每一个连接点即（每一个方法）后所要做的操作。

1. 前置通知 （前置增强）— before() 执行方法前通知
2. 返回通知（返回增强）— afterReturn 方法正常结束返回后的通知
3. 异常抛出通知（异常抛出增强）— afetrThrow()
4. 最终通知 — after 无论方法是否发生异常，均会执行该通知。
5. 环绕通知 — around 包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

1.6.4 Aspect（切面）

切入点与通知的结合，决定了切面的定义，切入点定义了要拦截哪些类的哪些方法，通知则定义了拦截过方法后要做什么，切面则是横切关注点的抽象，与类相似，类是对物体特征的抽象，切面则是横切关注点抽象。

1.6.5 Target（目标对象）

被代理的目标对象

1.6.6 Weave（织入）

将切面应用到目标对象并生成代理对象的这个过程即为织入

1.6.7 Introduction（引入）

在不修改原有应用程序代码的情况下，在程序运行期为类动态添加方法或者字段的过程称为引入

2.Spring AOP的实现

2.1 Spring AOP环境搭建

2.1.1 坐标依赖引入

<dependency>
	 <groupId>org.aspectjgroupId>
	 <artifactId>aspectjweaverartifactId>
	 <version>1.8.9version>
dependency>

2.1.2 添加spring.xml的配置

xmlns:aop="http://www.springframework.org/schema/aop"

http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd

2.2 注解实现

2.2.1 定义切面

package com.example.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @program: spring05
 * @ClassName LogCut
 * @description: 切面：切入点和通知的抽象 定义切入点和通知
 *               切入点：定义要拦截哪些类的哪些方法
 *               通知：定义了拦截之后方法要做什么
 * @author: 
 * @create: 2023-02-12 14:27
 * @Version 1.0
 **/
@Component // 将对象交给IOC容器实例化
@Aspect // 声明当前类是一个切面
public class LogCut {

    /**
     * 切入点：定义要拦截哪些类的哪些方法
     *        匹配规则：拦截什么方法
     *        定义切入点：@Pointcut("匹配规则")
     * AOP切入点表达式
     *        1.执行所有的公共方法
     *          execution(public *(..))
     *        2.执行任意的set方法
     *          execution(* set*(..))
     *        3.设置指定包下的任意类的任意方法（指定包:com.example.service）
     *          execution(* com.example.service.*.*(..))
     *        4.设置指定包及子包下的任意类的任意方法（指定包：com.example.service）
     *          execution(* com.example.service..*.*(..))
     *        表达式中的第一个 * 代表的是方法的修饰范围（public，private，protected）
     *        如果取值为*，则表示所有范围
     *
     */
    @Pointcut("execution(* com.example.service..*.*(..))")
    public void cut() {

    }

    /**
     * 声明前置通知，并将通知应用到指定的切入点上
     *      目标类的目标方法执行前，执行该通知
     *
     */
    @Before(value = "cut()")
    public void before() {
        System.out.println("前置通知...");
    }

    /**
     * 声明返回通知，并将通知应用到指定的切入点上
     *      目标类的方法在无异常执行后，执行该通知
     */
    @AfterReturning(value = "cut()")
    public void afterReturn() {
        System.out.println("返回通知...");
    }

    /**
     * 声明最终通知，并将通知应用到指定的切入点上
     *     目标类的方法在执行后，执行该通知（有异常和无异常最终都会执行）
     *
     */
    @After(value = "cut()")
    public void after() {
        System.out.println("最终通知...");
    }

    /**
     * 声明异常通知，并将通知应用到指定的切入点上
     *    目标类的方法在执行异常后，执行该通知
     */
    @AfterThrowing(value = "cut()", throwing = "e")
    public void afterThrow(Exception e) {
        System.out.println("异常通知..., 异常原因：" + e.getMessage());
    }

    /**
     * 声明环绕通知，并将通知应用到指定的切入点上
     *      目标类的方法执行前后，都可通过环绕通知定义相应的处理
     *      需要显式的调用方法，否则无法访问指定方法 pjp.proceed();
     * @param pjp
     * @return
     */
    @Around(value = "cut()")
    public Object around(ProceedingJoinPoint pjp) {
        System.out.println("环绕通知-前置通知...");
        Object object = null;
        try {
            // 显式的调用对应的方法
            object = pjp.proceed();
            System.out.println(pjp.getTarget());
            System.out.println("环绕通知-返回通知...");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("环绕通知-异常通知...");
        }
        System.out.println("环绕通知-最终通知...");
        return object;
    }
}

2.2.2 配置文件（spring.xml）

<aop:aspectj-autoproxy/>

2.3 XML实现

2.3.1 定义切面

package com.example.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @program: spring05
 * @ClassName LogCut
 * @description: 切面：切入点和通知的抽象 定义切入点和通知
 *               切入点：定义要拦截哪些类的哪些方法
 *               通知：定义了拦截之后方法要做什么
 * @author: 
 * @create: 2023-02-12 14:27
 * @Version 1.0
 **/
@Component // 将对象交给IOC容器实例化
public class LogCut02 {

    public void cut() {

    }

    public void before() {
        System.out.println("前置通知...");
    }

    public void afterReturn() {
        System.out.println("返回通知...");
    }

    public void after() {
        System.out.println("最终通知...");
    }

    public void afterThrow(Exception e) {
        System.out.println("异常通知..., 异常原因：" + e.getMessage());
    }

    public Object around(ProceedingJoinPoint pjp) {
        System.out.println("环绕通知-前置通知...");
        Object object = null;
        try {
            // 显式的调用对应的方法
            object = pjp.proceed();
            System.out.println(pjp.getTarget());
            System.out.println("环绕通知-返回通知...");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("环绕通知-异常通知...");
        }
        System.out.println("环绕通知-最终通知...");
        return object;
    }
}

2.3.2 配置文件（spring.xml）

<aop:config>
    
    <aop:aspect ref="logCut02">
        
        <aop:pointcut id="cut" expression="execution(* com.xxxx.service..*.*
(..))"/>
        
        <aop:before method="before" pointcut-ref="cut"/>
        
        <aop:after-returning method="afterReturn" pointcut-ref="cut"/>
        
         <aop:after-throwing method="afterThrow" throwing="e" pointcutref="cut"/>
        
        <aop:after method="after" pointcut-ref="cut"/>
        
        <aop:around method="around" pointcut-ref="cut"/>
    aop:aspect>
aop:config>

3.Spring AOP总结

3.1 代理模式实现三要素

• 接口定义
• 目标对象与代理对象必须实现统一接口
• 代理对象持有目标对象的引用 增强目标对象行为

3.2 代理模式实现分类以及对应区别

• 静态代理：手动为目标对象制作代理对象，即在程序编译阶段完成代理对象的创建
• 动态代理：在程序运行期动态创建目标对象对应代理对象。
• jdk动态代理：被代理目标对象必须实现某一或某一组接口 实现方式 通过回调创建代理对象。
• cglib 动态代理：被代理目标对象可以不必实现接口，继承的方式实现。

动态代理相比较静态代理，提高开发效率，可以批量化创建代理，提高代码复用率。

3.3 Aop 理解

• 面向切面，相比oop 关注的是代码中的层或面
• 解耦，提高系统扩展性
• 提高代码复用

3.4 Aop 关键词

• 连接点:每一个方法
• 切入点:匹配的方法集合
• 切面：连接点与切入点的集合决定了切面，横切关注点的抽象
• 通知:几种通知
• 目标对象:被代理对象
• 织入：程序运行期将切面应用到目标对象 并生成代理对象的过程
• 引入:在不修改原始代码情况下，在程序运行期为程序动态引入方法或字段的过程