spring_aop【一】

xiatianit

已于 2022-10-31 09:28:36 修改

阅读量120

点赞数

分类专栏： spring 文章标签： spring java mybatis

于 2022-10-30 17:31:08 首次发布

本文链接：https://blog.csdn.net/xiatianit/article/details/127514683

版权

spring 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

什么是AOP?

AOP(Aspect Oriented Programming)面向切面编程，是一种编程范式，知道开发者如何组织程序结构
OOP(Object Oriented Programming)面向对象编程

AOP作用

作用:在不惊动原始设计的基础上为其进行功能增强

AOP核心概念

为了能更好的理解AOP的相关概念，我们准备了一个环境，整个环境的内容我们暂时可以不用关注，最主要的类为:AccountServiceImpl

@Repository
public class AccountServiceImpl implements AccountService {
    public void save() {
        //记录程序当前执行执行（开始时间）
        Long startTime = System.currentTimeMillis();
        //业务执行万次
        for (int i = 0;i<10000;i++) {
            System.out.println("book dao save ...");
        }
        //记录程序当前执行时间（结束时间）
        Long endTime = System.currentTimeMillis();
        //计算时间差
        Long totalTime = endTime-startTime;
        //输出信息
        System.out.println("执行万次消耗时间：" + totalTime + "ms");
    }
    public void update(){
        System.out.println("book dao update ...");
    }
    public void delete(){
        System.out.println("book dao delete ...");
    }
    public void select(){
        System.out.println("book dao select ...");
    }
}

代码的内容很简单，就是测试一下万次执行的耗时

疑问

对于计算万次执行消耗的时间只有save方法有，为什么delete和update方法也会有呢?
delete和update方法有，那什么select方法为什么又没有呢?

AOP入门案例

需求分析

案例设定：测算接口执行效率，但是这个案例稍微复杂了点，我们对其进行简化。
简化设定：在方法执行前输出当前系统时间。
那现在我们使用SpringAOP的注解方式完成在方法执行的前打印出当前系统时间。

思路分析

导入坐标
制作连接点（原始操作，Dao接口及实现类）
制作共性功能（通知类和通知）
定义切入点
绑定切入点和通知的关系（切面）

环境准备

创建一个Maven项目
pom.xml添加Spring依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

因为spring-context中已经导入了spring-aop,所以不需要再单独导入spring-aop
导入AspectJ的jar包,AspectJ是AOP思想的一个具体实现，Spring有自己的AOP实现，但是相比于AspectJ来说比较麻烦，所以我们直接采用Spring整合ApsectJ的方式进行AOP开发。
步骤二：定义接口和实现类
准备环境的时候我们已经完成了
步骤三：定义通知类和通知

通知就是将共性功能抽取出来后形成的方法，共性功能指的就是当前系统时间的打印。
类名和方法名没有要求，可以任意。

public class MyAdvice {
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

步骤四：定义切入点

AccountServiceImpl中有两个方法，分别是update()和save()，我们要增强的是update方法，那么该如何定义呢？

public class MyAdvice {
    @Pointcut("execution(void org.gz.service.AccountService.update())")
    private void pt() {
    }

    public void method() {
        System.out.println(System.currentTimeMillis());
    }
}

说明:

切入点定义依托一个不具有实际意义的方法进行，即无参数、无返回值、方法体无实际逻辑。
execution及后面编写的内容，之后我们会专门去学习。

步骤五：制作切面

切面是用来描述通知和切入点之间的关系，如何进行关系的绑定?

public class MyAdvice {

    @Pointcut("execution(void org.gz.service.AccountService.update())")
    private void pt(){}
    
    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

绑定切入点与通知关系，并指定通知添加到原始连接点的具体执行位置

说明:@Before翻译过来是之前，也就是说通知会在切入点方法执行之前执行，除此之前还有其他四种类型，后面会讲。
那这里就会在执行update()之前，来执行我们的method()，输出当前毫秒值

步骤六：将通知类配给容器并标识其为切面类

@Component
@Aspect
public class MyAdvice {

    @Pointcut("execution(void org.gz.service.impl.AccountServiceImpl.update())")
    private void pt() {
    }

    @Before("pt()")
    public void method() {
        System.out.println(System.currentTimeMillis());
    }
}

步骤七：开启注解格式AOP功能
使用@EnableAspectJAutoProxy注解

@Configuration
@ComponentScan("org.gz")
@EnableAspectJAutoProxy
public class SpringConfig {
}

步骤八：运行程序
这次我们再来调用update()

。。。

知识点1：@EnableAspectJAutoProxy

名称	@EnableAspectJAutoProxy
类型	配置类注解
位置	配置类定义上方
作用	开启注解格式AOP功能

知识点2：@Aspect

名称	@Aspect
类型	类注解
位置	切面类定义上方
作用	设置当前类为AOP切面类

知识点3：@Pointcut

名称	@Pointcut
类型	方法注解
位置	切入点方法定义上方
作用	设置切入点方法
属性	value（默认）：切入点表达式

知识点4：@Before

名称	@Before
类型	方法注解
位置	通知方法定义上方
作用	设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前运行

AOP工作流程

由于AOP是基于Spring容器管理的bean做的增强，所以整个工作过程需要从Spring加载bean说起

流程一：Spring容器启动
- 容器启动就需要去加载bean,哪些类需要被加载呢?
- 需要被增强的类，如:AccountServiceImpl
- 通知类，如:MyAdvice
- 注意此时bean对象还没有创建成功
流程二：读取所有切面配置中的切入点

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void org.gz.service.impl.AccountServiceImpl.update())")
    private void ptx() {
    }

    @Pointcut("execution(void org.gz.service.impl.AccountServiceImpl.update())")
    private void pt() {
    }


    @Before("pt()")
    public void method() {
        System.out.println(System.currentTimeMillis());
    }
}

上面这个例子中有两个切入点的配置，但是第一个ptx()并没有被使用，所以不会被读取。这样设计是为了提高效率，尽可能缩小扫描范围。
流程三：初始化bean，判定bean对应的类中的方法是否匹配到任意切入点
- 注意第一步在容器启动的时候，bean对象还没有被创建成功。
- 要被实例化bean对象的类中的方法和切入点进行匹配

匹配失败，创建原始对象，如AccountServiceImpl
- 匹配失败说明不需要增强，直接调用原始对象的方法即可。
匹配成功，创建原始对象（目标对象）的代理对象，如:AccountServiceImpl
- 匹配成功说明需要对其进行增强
- 对哪个类做增强，这个类对应的对象就叫做目标对象
- 因为要对目标对象进行功能增强，而采用的技术是动态代理，所以会为其创建一个代理对象
- 最终运行的是代理对象的方法，在该方法中会对原始方法进行功能增强
流程四：获取bean执行方法
- 获取的bean是原始对象时，调用方法并执行，完成操作
- 获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作
下面我们来验证一下容器中是否为代理对象
- 如果目标对象中的方法会被增强，那么容器中将存入的是目标对象的代理对象
- 如果目标对象中的方法不被增强，那么容器中将存入的是目标对象本身
步骤一：修改App运行类，获取类的类型并输出

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        AccountService accountService = ctx.getBean(AccountService.class);
        System.out.println(accountService);
        //打印输出对象的类名
        System.out.println(accountService.getClass());
    }
}

步骤二：修改MyAdvice类，改为不增强
将定义的切入点改为updatexxx，而AccountServiceImpl类中不存在该方法，所以AccountService中的update方法在执行的时候，就不会被增强
所以此时容器中的对象应该是目标对象本身。

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void org.gz.service.impl.AccountServiceImpl.updatexxx())")
    private void pt() {
    }

    @Before("pt()")
    public void method() {
        System.out.println(System.currentTimeMillis());
    }
}

步骤三：运行程序
输出结果如下，确实是目标对象本身，符合我们的预期

org.gz.service.impl.AccountServiceImpl@bcec361
class org.gz.service.impl.AccountServiceImpl

步骤四：修改MyAdvice类，改为增强
将定义的切入点改为update，那么AccountService中的update方法在执行的时候，就会被增强
所以容器中的对象应该是目标对象的代理对象

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void org.gz.service.impl.AccountServiceImpl.update())")
    private void pt() {
    }

    @Before("pt()")
    public void method() {
        System.out.println(System.currentTimeMillis());
    }
}

步骤五：运行程序
结果如下

org.gz.service.impl.AccountServiceImpl@3d34d211
class com.sun.proxy.$Proxy19

至此对于刚才的结论，我们就得到了验证，这块我们需要注意的是:
不能直接打印对象，从上面两次结果中可以看出，直接打印对象走的是对象的toString方法，不管是不是代理对象，打印的结果都是一样的，原因是内部对toString方法进行了重写。

由以上例子可以看出：SpringAOP的本质或者可以说底层实现是通过代理模式。

AOP配置管理

AOP切入点表达式

对于AOP中切入点表达式，我们总共会学习三个内容，分别是语法格式、通配符和书写技巧。

对于切入点的描述，我们其实是有两中方式的，先来看下前面的例子
由于AccountServiceImpl类实现了AccountService接口，那么有如下两种方式来描述

描述方式一：执行org.gz.service包下的AccountService接口中的无参数update方法

execution(void org.gz.service.AccountService.update())

描述方式二：执行org.gz.dao.impl包下的BookDaoImpl类中的无参数update方法

execution(void org.gz.service.impl.AccountServiceImpl.update())

因为调用接口方法的时候最终运行的还是其实现类的方法，所以上面两种描述方式都是可以的。

切入点表达式标准格式：

动作关键字(访问修饰符返回值包名.类/接口名.方法名(参数) 异常名）

举例：

execution(public User org.gz.service.impl.AccountServiceImpl.findById(int))

execution：动作关键字，描述切入点的行为动作，例如execution表示执行到指定切入点

public:访问修饰符,还可以是public，private等，通常省略
User：返回值，写返回值类型
com.blog.service：包名，多级包使用点连接
UserService:类/接口名称
findById：方法名
int:参数，直接写参数的类型，多个类型用逗号隔开
异常名：方法定义中抛出指定异常，通常省略

通配符

我们使用通配符描述切入点，主要的目的就是简化之前的配置，具体都有哪些通配符可以使用?

*:单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现

匹配org.gz包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法

execution（public * org.gz.*.UserService.find*(*))

..：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写

匹配org包下的任意包中的UserService类或接口中所有名称为findById的方法

execution（public User org..UserService.findById(..))

+：专用于匹配子类类型

这个使用率较低，描述子类的，*Service+，表示所有以Service结尾的接口的子类

execution(* *..*Service+.*(..))

AOP通知类型

前置通知和后置通知

修改MyAdvice，在before方法上添加@Before注解

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void org.gz.service.impl.AccountServiceImpl.update())")
    private void pt() {
    }

    @Before("pt()")
    public void before() {
        System.out.println("before advice ...");
    }

    @After("pt()")
    public void after(){
        System.out.println("after advice ...");
    }
}

环绕通知

在方法参数中添加ProceedingJoinPoint，同时在需要的位置使用proceed()调用原始操作

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void org.gz.service.impl.AccountServiceImpl.update())")
    private void pt() {
    }

    @Around("pt()")
    public void around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("around before advice ...");
        //表示对原始操作的调用
        pjp.proceed();
        System.out.println("around after advice ...");
    }
}

通知类型总结

知识点1：@After

名称	@After
类型	方法注解
位置	通知方法定义上方
作用	设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法后运行

知识点2：@AfterReturning

名称	@AfterReturning
类型	方法注解
位置	通知方法定义上方
作用	设置当前通知方法与切入点之间绑定关系，当前通知方法在原始切入点方法正常执行完毕后执行

知识点3：@AfterThrowing

名称	@AfterThrowing
类型	方法注解
位置	通知方法定义上方
作用	设置当前通知方法与切入点之间绑定关系，当前通知方法在原始切入点方法运行抛出异常后执行

知识点4：@Around

名称	@Around
类型	方法注解
位置	通知方法定义上方
作用	设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前后运行

知识点5：@Before

名称	@Before
类型	方法注解
位置	通知方法定义上方
作用	设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前运行

环绕通知注意事项