0
0

【Spring篇】AOP

🍓系列专栏:Spring系列专栏

🍉个人主页:个人主页

一、AOP简介

前面我们在介绍Spring的时候说过，Spring有两个核心的概念，一个是IOC/DI，一个是AOP。

前面已经对IOC/DI进行了系统的学习，接下来要学习它的另一个核心内容，就是AOP。

对于AOP,我们前面提过一句话是:*AOP***是在不改原有代码的前提下对其进行增强。 **

对于下面的内容，我们主要就是围绕着这一句话进行展开学习，主要学习两方面内容AOP核心概

念, AOP作用

1.*什么是***AOP? **

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

我们都知道OOP是一种编程思想，那么AOP也是一种编程思想，编程思想主要的内容就是指导程序员该如何编写程序，所以它们两个是不同的编程范式。

2.AOP****作用

作用:在不惊动原始设计的基础上为其进行功能增强，前面咱们有技术就可以实现这样的功能即代

理模式。

3.AOP****核心概念

为了能更好的理解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方法中有计算万次执行消耗的时间。

当在App类中从容器中获取bookDao对象后，分别执行其save , delete , update和select方法后会

有如下的打印结果:

这个时候，我们就应该有些疑问?

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

这个案例中其实就使用了Spring的AOP，在不惊动(改动)原有设计(代码)的前提下，想给谁添加功能就给谁添加。这个也就是Spring的理念：

  • 无入侵式/无侵入式

说了这么多，Spring到底是如何实现的呢?

(1)前面一直在强调，Spring的AOP是对一个类的方法在不进行任何修改的前提下实现增强。对于上面的案例中BookServiceImpl中有save , update , delete和select方法,这些方法我们给起了一

个名字叫**连接点 **

(2)在BookServiceImpl的四个方法中，update和delete只有打印没有计算万次执行消耗时间，

但是在运行的时候已经有该功能，那也就是说update和delete方法都已经被增强，所以对于需要增

强的方法我们给起了一个名字叫**切入点 **

(3)执行BookServiceImpl的update和delete方法的时候都被添加了一个计算万次执行消耗时间的功能，将这个功能抽取到一个方法中，换句话说就是存放共性功能的方法，我们给起了个名字叫**通 ****知 **

(4)通知是要增强的内容，会有多个，切入点是需要被增强的方法，也会有多个，那哪个切入点需要添加哪个通知，就需要提前将它们之间的关系描述清楚，那么对于通知和切入点之间的关系描述，我们给起了个名字叫**切面 **

(5)通知是一个方法，方法不能独立存在需要被写在一个类中，这个类我们也给起了个名字叫通知类至此AOP中的核心概念就已经介绍完了，总结下:

**连接点(JoinPoint)**：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等

  • 在SpringAOP中，理解为方法的执行

切入点(Pointcut):匹配连接点的式子

  • 在SpringAOP中，一个切入点可以描述一个具体方法，也可也匹配多个方法
  • 一个具体的方法:如com.itheima.dao包下的BookDao接口中的无形参无返回值的save方法
  • 匹配多个方法:所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法
  • 连接点范围要比切入点范围大，是切入点的方法也一定是连接点，但是是连接点的方法就不一 定要被增强，所以可能不是切入点。

**通知(Advice):**在切入点处执行的操作，也就是共性功能

  • 在SpringAOP中，功能最终以方法的形式呈现

通知类：定义通知的类

**切面(Aspect):**描述通知与切入点的对应关系。

二、AOP入门案例

1.需求分析

案例设定：测算接口执行效率，但是这个案例稍微复杂了点，我们对其进行简化。

简化设定：在方法执行前输出当前系统时间。

对于SpringAOP的开发有两种方式，XML 和 注解，我们使用哪个呢?

因为现在注解使用的比较多，所以本次课程就采用注解完成AOP的开发。

总结需求为:使用SpringAOP的注解方式完成在方法执行的前打印出当前系统时间。

2.思路分析

需求明确后，具体该如何实现，都有哪些步骤，我们先来分析下:

1.导入坐标(pom.xml)

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

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

4.定义切入点

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

3.环境准备

创建一个Maven项目

pom.xml添加Spring依赖

<dependencies>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context</artifactId> 
<version>5.2.10.RELEASE</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 {
}

编写App运行类 

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

    }
}

最终创建好的项目结构如下:

说明**: **

  • 目前打印save方法的时候，因为方法中有打印系统时间，所以运行的时候是可以看到系统时间
  • 对于update方法来说，就没有该功能
  • 我们要使用SpringAOP的方式在不改变update方法的前提下让其具有打印系统时间的功能。

4.AOP****实现步骤

*步骤***1:****添加依赖 **

pom.xml

<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开发。

*步骤***2:**定义接口与实现类

环境准备的时候，BookDaoImpl已经准备好，不需要做任何修改

*步骤***3:****定义通知类和通知 **

通知就是将共性功能抽取出来后形成的方法，共性功能指的就是当前系统时间的打印。 

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

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

*步骤***4:****定义切入点 **

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());
}
}

说明**: **

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

*步骤***5:****制作切面 **

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

public class MyAdvice {
@Pointcut("execution(void com.itheima.dao.BookDao.update())")
private void pt(){}
@Before("pt()")
public void method(){
System.out.println(System.currentTimeMillis());
}
}

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

说明:@Before翻译过来是之前，也就是说通知会在切入点方法执行之前执行，除此之前还有其他四种类型，后面会讲。

*步骤***6:**将通知类配给容器并标识其为切面类

@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());
}
}

*步骤*7:开启注解格式AOP*功能*

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

*步骤***8:**运行程序

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

看到在执行update方法之前打印了系统时间戳，说明对原始方法进行了增强，AOP编程成功。

三、AOP工作流程

AOP的入门案例已经完成，对于刚才案例的执行过程，我们就得来分析分析，这一节我们主要讲解两个知识点: AOP工作流程和AOP核心概念。其中核心概念是对前面核心概念的补充。

1.AOP****工作流程

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

*流程1:Spring*容器启动 **

  • 容器启动就需要去加载bean,哪些类需要被加载呢?
  • 需要被增强的类，如:BookServiceImpl
  • 通知类，如:MyAdvice
  • 注意此时bean对象还没有创建成功

*流程***2:**读取所有切面配置中的切入点

上面这个例子中有两个切入点的配置，但是第一个ptx()并没有被使用，所以不会被读取。

*流程*3:初始化bean**， **

判定bean对应的类中的方法是否匹配到任意切入点

  • 注意第1步在容器启动的时候，bean对象还没有被创建成功。
  • 要被实例化bean对象的类中的方法和切入点进行匹配

匹配失败，创建原始对象,如UserDao

  • 匹配失败说明不需要增强，直接调用原始对象的方法即可。

匹配成功，创建原始对象（目标对象）的代理对象,如: BookDao

  • 匹配成功说明需要对其进行增强
  • 对哪个类做增强，这个类对应的对象就叫做目标对象
  • 因为要对目标对象进行功能增强，而采用的技术是动态代理，所以会为其创建一个代理对象
  • 最终运行的是代理对象的方法，在该方法中会对原始方法进行功能增强

*流程*4:获取bean**执行方法 **

获取的bean是原始对象时，调用方法并执行，完成操作

获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

**验证容器中是否为代理对象 **

为了验证IOC容器中创建的对象和我们刚才所说的结论是否一致，首先先把结论理出来:

如果目标对象中的方法会被增强，那么容器中将存入的是目标对象的代理对象

如果目标对象中的方法不被增强，那么容器中将存入的是目标对象本身。

验证思路

1.要执行的方法，不被定义的切入点包含，即不要增强，打印当前类的getClass()方法

2.要执行的方法，被定义的切入点包含，即要增强，打印出当前类的getClass()方法

3.观察两次打印的结果

*步骤*1:修改App*类***,**获取类的类型

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

*步骤*2:修改MyAdvice**类，不增强 **

因为定义的切入点中，被修改成update1 ,所以BookDao中的update方法在执行的时候，就不会被增强， 所以容器中的对象应该是目标对象本身。

@Component
//设置当前类为切面类类
@Aspect
public class MyAdvice {
    //设置切入点，要求配置在方法上方
    @Pointcut("execution(void com.itheima.dao.BookDao.update1())")
    private void pt(){}

    //设置在切入点pt()的前面运行当前操作（前置通知）
     @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

*步骤***3:**运行程序

*步骤*4:修改MyAdvice**类，增强 **

因为定义的切入点中，被修改成update ,所以BookDao中的update方法在执行的时候，就会被增

强，所以容器中的对象应该是目标对象的代理对象

@Component
//设置当前类为切面类类
@Aspect
public class MyAdvice {
    //设置切入点，要求配置在方法上方
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}

    //设置在切入点pt()的前面运行当前操作（前置通知）
     @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

*步骤***5:****运行程序 **

至此对于刚才的结论，我们就得到了验证，这块大家需要注意的是:

不能直接打印对象，从上面两次结果中可以看出，直接打印对象走的是对象的toString方法，不管是不是代理对象打印的结果都是一样的，原因是内部对toString方法进行了重写。

2.*AOP***核心概念 **

在上面介绍AOP的工作流程中，我们提到了两个核心概念，分别是:

  • 目标对象(Target)：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的
  • 代理(Proxy)：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现

上面这两个概念比较抽象，简单来说，目标对象就是要增强的类[如:BookServiceImpl类]对应的对象，也叫原始对象，不能说它不能运行，只能说它在运行的过程中对于要增强的内容是缺失的。

SpringAOP是在不改变原有设计(代码)的前提下对其进行增强的，它的底层采用的是代理模式实现

的，所以要对原始对象进行增强，就需要对原始对象创建代理对象，在代理对象中的方法把通知

[如:MyAdvice中的method方法]内容加进去，就实现了增强,这就是我们所说的代理(Proxy)。

四、AOP配置管理

1.AOP****切入点表达式

前面的案例中，有涉及到如下内容:

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

1，**语法格式 **

首先我们先要明确两个概念:

  • 切入点:要进行增强的方法
  • 切入点表达式:要进行增强的方法的描述方式

对于切入点的描述，我们其实是有两中方式的，先来看下前面的例子

描述方式一：执行com.itheima.dao包下的BookDao接口中的无参数update方法

 execution(void com.itheima.dao.BookDao.update())

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

 execution(void com.itheima.dao.impl.BookDaoImpl.update())

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

对于切入点表达式的语法为:

  • 切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常 名）

对于这个格式，我们不需要硬记，通过一个例子，理解它:

execution(public User com.itheima.service.UserService.findById(int))
  • execution：动作关键字，描述切入点的行为动作，例如execution表示执行到指定切入点
  • public:访问修饰符,还可以是public，private等，可以省略
  • User：返回值，写返回值类型
  • com.itheima.service：包名，多级包使用点连接
  • UserService:类/接口名称
  • findById：方法名
  • int:参数，直接写参数的类型，多个类型用逗号隔开
  • 异常名：方法定义中抛出指定异常，可以省略

切入点表达式就是要找到需要增强的方法，所以它就是对一个具体方法的描述，但是方法的定义会有很多，所以如果每一个方法对应一个切入点表达式，想想这块就会觉得将来编写起来会比较麻烦，有没有更简单的方式呢?

就需要用到下面所学习的通配符。

2.通配符

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

  • :单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现
execution（public * com.itheima.*.UserService.find*(*))

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

方法

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

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

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

+：专用于匹配子类类型

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

这个使用率较低，描述子类的，咱们做JavaEE开发，继承机会就一次，使用都很慎重，所以很少

用它。*Service+，表示所有以Service结尾的接口的子类。

接下来，我们把案例中使用到的切入点表达式来分析下:

execution(void com.itheima.dao.BookDao.update())
匹配接口，能匹配到
execution(void com.itheima.dao.impl.BookDaoImpl.update())
匹配实现类，能匹配到
execution(* com.itheima.dao.impl.BookDaoImpl.update())
返回值任意，能匹配到
execution(* com.itheima.dao.impl.BookDaoImpl.update(*))
返回值任意，但是update方法必须要有一个参数，无法匹配，要想匹配需要在update接口和实现类添加
参数
execution(void com.*.*.*.*.update())
返回值为void,com包下的任意包三层包下的任意类的update方法，匹配到的是实现类，能匹配
execution(void com.*.*.*.update())
返回值为void,com包下的任意两层包下的任意类的update方法，匹配到的是接口，能匹配
execution(void *..update())
返回值为void，方法名是update的任意包下的任意类，能匹配
execution(* *..*(..))
匹配项目中任意类的任意方法，能匹配，但是不建议使用这种方式，影响范围广
execution(* *..u*(..))
匹配项目中任意包任意类下只要以u开头的方法，update方法能满足，能匹配
execution(* *..*e(..))
匹配项目中任意包任意类下只要以e结尾的方法，update和save方法能满足，能匹配
execution(void com..*())
返回值为void，com包下的任意包任意类任意方法，能匹配，*代表的是方法
execution(* com.itheima.*.*Service.find*(..))
将项目中所有业务层方法的以find开头的方法匹配
execution(* com.itheima.*.*Service.save*(..))
将项目中所有业务层方法的以save开头的方法匹配

后面两种更符合我们平常切入点表达式的编写规则

3.**书写技巧 **

对于切入点表达式的编写其实是很灵活的，那么在编写的时候，有没有什么好的技巧让我们用用:

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

2.AOP****通知类型

前面的案例中，有涉及到如下内容:

 @Before("pt()")

它所代表的含义是将通知添加到切入点方法执行的前面。

除了这个注解外，还有没有其他的注解，换个问题就是除了可以在前面加，能不能在其他的地方加?

1.类型介绍

我们先来回顾下AOP通知:

AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合 理的位置

通知具体要添加到切入点的哪里?

共提供了5种通知类型:

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

为了更好的理解这几种通知类型，我们来看一张图

(1)前置通知，追加功能到方法执行前,类似于在代码1或者代码2添加内容

(2)后置通知,追加功能到方法执行后,不管方法执行的过程中有没有抛出异常都会执行，类似于在代

码5添加内容

(3)返回后通知,追加功能到方法执行后，只有方法正常执行结束后才进行,类似于在代码3添加内容，如果方法执行抛出异常，返回后通知将不会被添加

(4)抛出异常后通知,追加功能到方法抛出异常后，只有方法执行出异常才进行,类似于在代码4添加内容，只有方法抛出异常后才会被添加

(5)环绕通知,环绕通知功能比较强大，它可以追加功能到方法执行的前后，这也是比较常用的方式，它可以实现其他四种通知类型的功能，具体是如何实现的，需要我们往下学习。

2.**环境准备 **

  • 创建一个Maven项目
  • pom.xml添加Spring依赖
  <dependencies>
    <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>
  </dependencies>

添加BookDao和BookDaoImpl类 

public interface BookDao {
    public void update();

    public int select();
}

@Repository
public class BookDaoImpl implements BookDao {

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

    public int select() {
        System.out.println("book dao select is running ...");

        return 100;
    }
}

创建Spring的配置类 

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

创建通知类

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

 public void before() {
 System.out.println("before advice ...");
}
 public void after() {
 System.out.println("after advice ...");
}
 public void around(){
 System.out.println("around before advice ...");
 System.out.println("around after advice ...");
}
 public void afterReturning() {
 System.out.println("afterReturning advice ...");
}
 public void afterThrowing() {
 System.out.println("afterThrowing advice ...");
}
}

编写App运行类 

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

最终创建好的项目结构如下:

3.**通知类型的使用 **

**前置通知 **

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

@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(void com.itheima.dao.BookDao.update())")
private void pt(){}
@Before("pt()")
//此处也可以写成 @Before("MyAdvice.pt()"),不建议
public void before() {
System.out.println("before advice ...");
}
}

**后置通知 **

@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(void com.itheima.dao.BookDao.update())")
private void pt(){}
@Before("pt()")
public void before() {
System.out.println("before advice ...");
}
@After("pt()")
public void after() {
System.out.println("after advice ...");
}
}

**环绕通知 **

**基本使用 **

@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(void com.itheima.dao.BookDao.update())")
private void pt(){}
@Around("pt()")
public void around(){
System.out.println("around before advice ...");
System.out.println("around after advice ...");
}
}

运行结果中，通知的内容打印出来，但是原始方法的内容却没有被执行。

因为环绕通知需要在原始方法的前后进行增强，所以环绕通知就必须要能对原始操作进行调用，具体如何实现? 

@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(void com.itheima.dao.BookDao.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 ...");
}
}

说明**:**proceed()为什么要抛出异常?

再次运行，程序可以看到原始方法已经被执行了

**注意事项 **

(1)原始方法有返回值的处理

修改MyAdvice,对BookDao中的select方法添加环绕通知， 

@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(void com.itheima.dao.BookDao.update())")
private void pt(){}
@Pointcut("execution(int com.itheima.dao.BookDao.select())")
private void pt2(){}
@Around("pt2()")
public void aroundSelect(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("around before advice ...");
//表示对原始操作的调用
pjp.proceed();
System.out.println("around after advice ...");
}
}

修改App类，调用select方法 

public class App {
 public static void main(String[] args) {
 ApplicationContext ctx = new
AnnotationConfigApplicationContext(SpringConfig.class);
 BookDao bookDao = ctx.getBean(BookDao.class);
 int num = bookDao.select();
 System.out.println(num);
 }
 }

运行后会报错，错误内容为:

Exception in thread "main" org.springframework.aop.AopInvocationException:

**Null return value from advice does not match primitive return type for: **

**public abstract int com.itheima.dao.BookDao.select() **at

org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopP

roxy.java:226) at com.sun.proxy.$Proxy19.select(Unknown Source) at

com.itheima.App.main(App.java:12)

错误大概的意思是:空的返回不匹配原始方法的int返回

  • void就是返回Null
  • 原始方法就是BookDao下的select方法

所以如果我们使用环绕通知的话，要根据原始方法的返回值来设置环绕通知的返回值，具体解决方案为

public Object around(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类型更通用。

在环绕通知中是可以对原始方法返回值就行修改的。

**返回后通知 **

@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(void com.itheima.dao.BookDao.update())")
private void pt(){}
@Pointcut("execution(int com.itheima.dao.BookDao.select())")
private void pt2(){}
@AfterReturning("pt2()")
public void afterReturning() {
System.out.println("afterReturning advice ...");
}
}

注意：返回后通知是需要在原始方法select正常执行后才会被执行，如果select()方法执行的过程

中出现了异常，那么返回后通知是不会被执行。后置通知是不管原始方法有没有抛出异常都会被执

行。

异常后通知

@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(void com.itheima.dao.BookDao.update())")
private void pt(){}
@Pointcut("execution(int com.itheima.dao.BookDao.select())")
private void pt2(){}
@AfterReturning("pt2()")
public void afterThrowing() {
System.out.println("afterThrowing advice ...");
}
}

注意：异常后通知是需要原始方法抛出异常，可以在select()方法中添加一行代码int i = 1/0即

可。如果没有抛异常，异常后通知将不会被执行。

学习完这5种通知类型，我们来思考下环绕通知是如何实现其他通知类型的功能的?

因为环绕通知是可以控制原始方法执行的，所以我们把增强的代码写在调用原始方法的不同位置就可以实现不同的通知类型的功能，如:

**环绕通知注意事项 **

  1. 环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用，进而实现原始方法

调用前后同时添加通知

  1. 通知中如果未使用ProceedingJoinPoint对原始方法进行调用将跳过原始方法的执行

  2. 对原始方法的调用可以不接收返回值，通知方法设置成void即可，如果接收返回值，最好设定为

Object类型

  1. 原始方法的返回值如果是void类型，通知方法的返回值类型可以设置成void,也可以设置成

Object

  1. 由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须要处理Throwable异常 

              笔记来自： 
         黑马程序员SSM框架教程
标签： spring java 后端
本文转载自: https://blog.csdn.net/Javascript_tsj/article/details/130187161
版权归原作者 热爱编程的小白白 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【Spring篇】AOP”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

用Rust TypeMap安全存储多种类型数据

Linux JDK1.8 安装包下载

解决 VScode 每次打开都是上次打开的文件问题

2024-如何在低版本Mac OS安装合适的xcode-详细的技术篇

Nginx 前端必会

通过Web Service与WinCC交互数据

渗透测试之Web基础之Linux基础（上）——泷羽sec

文章导航