Spring实现AOP简单实例

2021-11-18

Spring实现AOP简单实例

AOP简介

AOP(Aspect-Oriented Programming)即 面向切面编程，与 OOP(Object-Oriented Programming，面向对象编程)相辅相成，提供了与 OOP 不同的抽象软件结构视角。
在 OOP 中，以类(class)为基本单元，而 AOP 中的基本单元是 **Aspect(切面)**。

Aspect(切面)

Aspect 由 point cut 和 advice 组成，既包含了横切逻辑的定义，也包括了连接点的定义。
Spring AOP作为负责实施切面的框架，将切面所定义的横切逻辑织入到切面所指定的连接点中。
AOP将增强织入到目标对象的连接点上时，包含两个工作：1）如何通过 point cut 和 advice 定位到特定的 join point；2）如何在 advice 中编写切面代码。

可以简单地认为，使用 @Aspect 注解的类就是切面。

advice(增强)

advice(增强)是由 aspect 添加到特定的 join point (即满足 point cut 规则的 join point) 的一段代码。
Spring AOP会将 advice 模拟为一个拦截器(interceptor)，并且在 join point 上维护多个 advice，进行层层拦截。

advice 的类型：
1）before advice，在 join point 前被执行的 advice。虽然 before advice 是在 join point 前被执行，但它并不能够阻止 join point 的执行，除非发生了异常(即在 before advice 代码中，不能人为地决定是否继续执行 join point 中的代码)。
2）after return advice，在一个 join point 正常返回后执行的 advice。
3）after throwing advice，在一个 join point 抛出异常后执行的 advice。
4）after(final) advice，无论一个 join point 是正常退出还是发生了异常，都会被执行的 advice。
5）around advice，在 join point 前和 joint point 退出后都执行的 advice，是最常用的 advice。

对应Spring注解：

连接点(join point)

连接点是程序运行中的一些时间点，例如一个方法的执行，或者是一个异常的处理。
在 Spring AOP 中，join point 总是方法的执行点。

切点(point cut)

切点匹配 join point 的谓词(a predicate that matches join points)。
Advice 是和特定的 point cut 关联的，并且在 point cut 相匹配的 join point 中执行。
在 Spring 中，所有的方法都可以认为是 join point。而 AOP 一般不在方法上添加 Advice， point cut 恰恰提供了一组规则(使用 AspectJ pointcut expression language 来描述) 来匹配 join point，给满足规则的 join point 添加 Advice。

Advice 在 join point 上执行，而 point cut 规定了哪些 join point 可以执行哪些 advice。

引入(introduction)

introduction是一个类型添加的额外方法或字段。
Spring AOP 允许为目标对象引入新的接口和对应的实现。
例如可以使用 introduction 来为一个 bean 实现 IsModified 接口，并以此来简化 caching 的实现。

目标对象(Target)

Target是织入 advice 的目标对象，也被称为 advised object。
因为 Spring AOP 使用运行代理的方式来实现 aspect，因此 adviced object 总是一个代理对象(proxied object)。
adviced object 指的不是原来的类，而是织入 advice 后所产生的代理类。

AOP proxy

一个类被 AOP 织入 advice，就会产生一个结果类，它是融合了原类和增强逻辑的代理类。
在 Spring AOP 中，一个 AOP 代理就是一个 JDK 动态代理对象或 CGLIB 代理对象。

Spring AOP 默认使用标准的 JDK 动态代理(dynamic proxy)技术来实现 AOP 代理，可以为任意的接口实现代理。
如果需要为一个类实现代理，可以使用 CGLIB 代理。当一个业务逻辑对象没有实现接口时，Spring AOP 默认使用 CGLIB 来作为 AOP 代理。
鉴于此，Spring AOP 建议基于接口编程，对接口进行 AOP 而不是类。

各代理类别比较：

织入(Weaving)

织入(Weaving)指将 aspect 和其他对象连接起来，并创建 adviced object 的过程。
根据不同的实现技术，AOP织入有三种方式：
1）编译器织入，要求有特殊的Java编译器；
2）类装载期织入，需要有特殊的类装载器；
3）动态代理织入，在运行期为目标类添加增强(Advice)生成子类的方式。
Spring 采用动态代理织入，而 AspectJ 采用编译器织入和类装载期织入。

aspect, join point, point cut, advice

join point：所有的接口；
point cut：切面编程的条件；
advice：满足切面编程条件的所有接口；
aspect：处理所有增加切面编程的接口；

引入依赖

// https://mvnrepository.com/artifact/org.springframework/spring-context
implementation group: 'org.springframework', name: 'spring-context', version: '5.2.18.RELEASE'
// https://mvnrepository.com/artifact/org.springframework/spring-aspects
implementation group: 'org.springframework', name: 'spring-aspects', version: '5.2.18.RELEASE'

切面接口类：IBuy

package com.demo;

public interface IBuy {

    String buy(double price);
}

切面接口实现类：Boy

package com.demo;

import org.springframework.stereotype.Component;

@Component
public class Boy implements IBuy {

    @Override
    public String buy(double price) {

        System.out.println(String.format("男孩花了%s元买了一个游戏机", price));

        return "男孩";
    }
}

切面接口实现类：Girl

package com.demo;

import org.springframework.stereotype.Component;

@Component
public class Girl implements IBuy {

    @Override
    public String buy(double price) {

        System.out.println(String.format("女孩花了%s元买了一件漂亮的衣服", price));

        return "女孩";
    }
}

AOP配置类：AOPConfig

package com.demo;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan(basePackageClasses = {com.demo.IBuy.class})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AOPConfig {
}

切面处理类：BuyAspectJ

package com.demo;

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

/**
 * 切面类实现
 */
@Aspect
@Component
public class BuyAspectJ {

    /**
     * 注解声明切点表达式
     */
    @Pointcut("execution(* com.demo.IBuy.buy(..))")
    public void point() {
    }

    /**
     * girl的切点表达式
     *
     * @param price
     */
    @Pointcut("execution(String com.demo.IBuy.buy(double)) && args(price) && bean(girl)")
    public void girlPoint(double price) {
    }

    /**
     * 目标方法调用之前执行
     */
    @Before("execution(* com.demo.IBuy.buy(..))")
    public void beforeBuyAspect() {
        System.out.println("before ...");
    }

    /**
     * 目标方法调用之后执行
     * 传入切点表达式
     */
    @AfterReturning("point()")
    public void afterBuyAspect() {
        System.out.println("AfterReturning ...");
    }

    /**
     * 封装整个目标方法
     * 增加切点参数处理逻辑
     *
     * @param pj
     */
    @Around("girlPoint(price)")
    public String aroundBuyAspect(ProceedingJoinPoint pj, double price) {
        try {
            pj.proceed();
            if (price > 60) {
                System.out.println("消费超出预算，下次注意");
                return "女孩";
            }
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }

        return "女孩";
    }
}

切面测试类：AOPTest

package com.demo;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class AOPTest {

    public static void main(String args[]) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AOPConfig.class);

        Boy boy = context.getBean("boy", Boy.class);
        Girl girl = (Girl) context.getBean("girl");

        String boyStr = boy.buy(55);
        System.out.println(boyStr + "------end");
        String girlStr = girl.buy(66);
        System.out.println(girlStr + "------end");
    }
}

运行结果

before ...
男孩花了55.0元买了一个游戏机
AfterReturning ...
男孩------end
before ...
女孩花了66.0元买了一件漂亮的衣服
AfterReturning ...
消费超出预算，下次注意
女孩------end