黑马Spring学习笔记（四）——面向切面编程AOP

最新推荐文章于 2024-04-20 08:14:47 发布

ReadyGo!!!

最新推荐文章于 2024-04-20 08:14:47 发布

阅读量612

点赞数

分类专栏： Java Web 文章标签： spring 学习 java

本文链接：https://blog.csdn.net/qq_45832961/article/details/129085904

版权

Java Web 专栏收录该内容

7 篇文章 1 订阅

订阅专栏

4.2.1 前置、后置、返回后、抛出异常后获取参数

4.2.2 环绕通知

一、AOP简介

AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，也是一种编程思想，编程思想主要的内容就是指导程序员该如何编写程序。

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

下面我们来看一个例子：

最主要的类BookDaoImpl内容如下：

@Repository
    public class BookDaoImpl implements BookDao {
        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()方法有计算万次执行消耗的时间。

但是，当我们从容器中获取bookDao对象后，分别对其执行save(),delete(),update(),select(),会有如下的打印结果：

为什么delete()和update()方法也执行了10000次且计算了执行时间呢？

这就是Spring的AOP，在不惊动(改动)原有设计(代码)的前提下，想给谁添加功能就给谁添加。

二、AOP核心概念

那Spring到底是如何实现AOP的呢？

连接点与切入点

连接点：执行的方法

切入点：需要被增强的方法

连接点： 程序执行过程中的任意位置，可以为方法，抛出异常，也可以为设置变量。

切入点： 一个切入点可以描述一个具体的方法，也可以匹配多个方法，一个切入点可以只匹配一个update方法，也可以匹配某个包下面所有的查询方法。

【连接点范围 > 切入点范围，切入点一定是连接点，反之未必】

通知与通知类

通知：存放共性功能的方法

通知类：定义通知的类

通知： 在切入点处执行的操作，也就是共性功能。

通知类： 通知是一个方法，方法不能独立存在，需要被写在一个类中，这个类我们也给起了个名字叫通知类

切面

切面：通知与切入点之间的关系描述

通知是要增强的内容，会有多个；切入点是需要被增强的方法，也会有多个，哪个切入点需要添加哪个通知，就需要提前将它们之间的关系描述清楚，那么对于通知和切入点之间的关系描述，我们称之为切面

三、AOP入门案例

我们使用注解来完成AOP的开发。

案例为：使用SpringAOP的注解方式完成在方法执行前打印出当前系统时间。

3.1 思路分析：

1. 导入坐标 (pom.xml)

2. 制作连接点 ( 原始操作， Dao 接口与实现类 )

3. 制作共性功能 ( 通知类与通知 )

4. 定义切入点

5. 绑定切入点与通知关系 ( 切面 )

3.2 实现步骤：

环境准备

创建一个Maven项目

pom.xml 添加 Spring 依赖

<dependencies>
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context</artifactId>
         <version>5.3.20</version>
    </dependency>
</dependencies>

添加 BookDao 和 BookDaoImpl 类

public interface BookDao {
    public void save();

    public void update();
}

@Repository
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save ...");
    }

    public void update() {
        System.out.println("book dao update ...");
    }
}

创建Spring的配置类

@Configuration
@ComponentScan("com.itheima")
public class SpringConfig {
}

项目结构如下：

AOP实现步骤

添加依赖

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

因为spring-context中已经导入了spring-aop ,所以不需要再单独导入spring-aop

定义接口与实现类
BookDaoImpl已经准备好，不需要做任何修改

定义通知类和通知

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

因类名和方法名没有要求，可以任意

定义切入点
BookDaoImpl 中有两个方法，分别是 save 和 update ，我们要增强的是 update 方法，该如何定义呢 ?
```
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt() {
    }

    public void method() {
        System.out.println(System.currentTimeMillis());
    }
}
```
切入点定义依托一个不具有实际意义的方法进行，即无参数、无返回值、方法体无实际逻辑

制作切面

public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt() {
    }

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

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

将通知类配给容器并标识其为切面类

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt() {
    }

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

开启注解格式AOP功能

@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
}

运行程序

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new
                AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.update();
    }
}

四、AOP配置管理

4.1 AOP切入点表达式

4.1.1 语法格式

execution(public User com.itheima.service.UserService.findById(int))

参数：

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

public: 访问修饰符 , 还可以是 public ， private 等，可以省略

User ：返回值，写返回值类型

com.itheima.service ：包名，多级包使用点连接

UserService: 类 / 接口名称

findById ：方法名

int: 参数，直接写参数的类型，多个类型用逗号隔开

异常名：方法定义中抛出指定异常，可以省略

切入点表达式就是要找到需要增强的方法，所以它就是对一个具体方法的描述，但是方法的定义会有很多，所以如果每一个方法对应一个切入点表达式，想想这块就会觉得将来编写起来会比较麻烦，就需要用到下面所学习的通配符。

4.2.2 通配符

* ：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现
```
execution（public * com.itheima.*.UserService.find*(*))
```
.. ：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写
```
execution（public User com..UserService.findById(..))
```
+ ：专用于匹配子类类型
```
execution(* *..*Service+.*(..))
```
这个使用率较低，描述子类的，JavaEE开发，继承机会就一次，使用都很慎重，所以很少用它。*Service+，表示所有以Service结尾的接口的子类

例如：

execution(void com..*())

返回值为void，com包下的任意包任意类任意方法，能匹配，*代表的是方法

execution(* com.itheima.*.*Service.find*(..))

将项目中所有业务层方法的以find开头的方法匹配

execution(* com.itheima.*.*Service.save*(..))

将项目中所有业务层方法的以save开头的方法匹配

4.2.3 书写技巧

所有代码按照标准规范开发，否则以下技巧全部失效
描述切入点通常描述接口，而不描述实现类,如果描述到实现类，就出现紧耦合了
访问控制修饰符针对接口开发均采用public描述（可省略访问控制修饰符描述）
返回值类型对于增删改类使用精准类型加速匹配，对于查询类使用*通配快速描述
包名书写尽量不使用..匹配，效率过低，常用*做单个包描述匹配，或精准匹配
接口名 / 类名书写名称与模块相关的采用 * 匹配，例如 UserService 书写成 *Service ，绑定业务

层接口名
方法名 书写以动词进行 精准匹配 ，名词采用匹配，例如 getById 书写成 getBy ,selectAll 书写成

selectAll
参数规则较为复杂，根据业务方法灵活调整
通常不使用异常作为匹配规则

4.2 AOP通知类型

AOP提供了5种通知类型：

前置通知
后置通知
环绕通知(重点)
返回后通知(了解)
抛出异常后通知(了解)

我们来看一张图：

4.2.1 前置、后置、返回后、抛出异常后获取参数

目前有执行方法（连接点、切入点）findName()如下：

@Repository
public class BookDaoImpl implements BookDao {

     public String findName(int id) {
         return "itcast";
     }
}

共性方法（通知类）如下：

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    private void pt() {
    }

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

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

那么当对findName()进行增强的时候，通知类中的共性方法如何才能获取findName中的参数id呢？

使用JoinPoint

通知作如下修改：

@Before("pt()")
public void before(JoinPoint jp)
    Object[] args = jp.getArgs();
    System.out.println(Arrays.toString(args));

    System.out.println("before advice ..." );
}

我们在执行类执行findName(100)时，输出如下：

可见，共性方法成功得到了执行方法中的id参数，并且以数组的形式进行了输出（因为方法中的形参可能有多个）

如果执行方法为findName(id, password)，在执行类执行findName(100,itheima)，那么输出为：

4.2.2 环绕通知

1. 环绕通知不能像前置和后置通知一样，简单地写成

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

【❌❌❌❌❌】

而应该写成

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

通过proceed()函数可以区分环绕前面和后面的通知

2. 如果我们使用环绕通知的话，要根据原始方法的返回值来设置环绕通知的返回值

代码示例：

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

为什么返回的是 Object 而不是 int 的主要原因是 Object 类型更通用。

3. 环绕通知获取参数

与非环绕通知的JoinPoint类似，环绕通知使用ProceedingJoinPoint，示例：

@Around("pt()")
public Object around(ProceedingJoinPoint pjp)throws Throwable {
    Object[] args = pjp.getArgs();
    System.out.println(Arrays.toString(args));

    Object ret = pjp.proceed();
    return ret;
}

同时，我们还可修改原始方法的参数，通过 args[0] = 666，我们就可以在环绕通知中对原始方法的参数进行拦截过滤，避免由于参数的问题导致程序无法正确运行，保证代码的健壮性。