Spring框架爆gan一万七千字,超详细的AOP技术详解,你真的不来看看吗?

Posted Hhzzy99

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Spring框架爆gan一万七千字,超详细的AOP技术详解,你真的不来看看吗?相关的知识,希望对你有一定的参考价值。

✅作者简介:热爱Java后端开发的一名学习者,大家可以跟我一起讨论各种问题喔。
🍎个人主页:Hhzzy99
🍊个人信条:坚持就是胜利!
💞当前专栏:【Spring】
🥭本文内容:Spring框架中AOP的深入学习,带你搞透这门技术!

Spring


文章目录


前言

这篇文章是上一篇文章(IoC和DI)🚩的后续,感兴趣的朋友们可以去看看(●’◡’●)


AOP简介

什么是AOP?它的作用是什么?
上一篇文章中,我们在介绍Spring的时候说过,Spring有两个核心的概念,一个是IOC/DI,一个是AOPIOC/DI已经学习过了,
那么AOP又是什么呢?
AOP(Aspect Oriented Programming) 面向切面编程,它是一种编程范式,指导开发者如何组织程序结构。我们学Java的都知道OOP(Object Oriented Programming) 面向对象编程,它是一种编程思想,AOP也是一种编程思想。
AOP的作用是什么呢?
它的作用通俗点讲,就是在不惊动原来设计的基础上,对其进行功能上的增强

AOP的核心概念

AOP的核心概念可以总结如下:

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

  • SpringAOP中,可以理解为方法的执行

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

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

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

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

通知类: 定义通知的类

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

简单入门案例

我们先做一个简单案例来入门=》
设定: 在方法执行前输出当前系统时间
思路分析:

1.导入坐标(pom.xml)
2.制作连接点(原始操作,Dao接口与实现类)
3.制作共性功能(通知类与通知)
4.定义切入点
5.绑定切入点与通知关系(切面)

环境搭建

创建一个maven环境(这个大家都会吧)
在pom.xml中添加Spring依赖:

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

添加BookDaoBookDaoImpl

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.hzy")
public class SpringConfig 

最后编写Application运行类

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

下面是创建好后的结构目录

我们所需要的基础环境搭建好了,现在我们就开始实现AOP吧!

AOP实现步骤

步骤一:在pom.xml中添加所需要的依赖

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


我们所需要的spring-aop依赖在前面的spring-context中已经包含了,我们只需要导入AspectJ就可以。AspectJ是AOP思想的一个具体实现,Spring有自己的AOP实现,但是相比于AspectJ来说比较麻烦,所以我们直接采用Spring整合ApsectJ的方式进行AOP开发。

步骤二:定义接口与实现类

我们在环境准备时已经做好了,不用做任何修改

步骤三:定义通知类和通知
通知就是将共性功能抽取出来后形成的方法,共性功能指的就是当前系统时间的打印。

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

步骤四:定义切入点
我们在前面定义的BookDaoImpl中有两个方法,分别是save和update,我们要增强的是update方法,该如何定义呢?

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

注意:

  • 切入点定义依托一个不具有实际意义的方法进行,即无参数、无返回值、方法体无实际逻辑。
  • execution及后面编写的内容,后面我会给大家讲到。

步骤五:制作切面

还是在MyAdvice类中:

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

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

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

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

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

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

@Configuration
@ComponentScan("com.hzy")
@EnableAspectJAutoProxy
public class SpringConfig 

步骤八:运行程序

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

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

下面是几个要认识的点:
知识点1:@EnableAspectJAutoProxy

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

知识点2:@Aspect

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

知识点3:@Pointcut

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

知识点4:@Before

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

AOP的工作流程

我们已经做完了AOP的入门案例,对于刚才案例的执行过程,我们来分析分析。由于AOP是基于Spring容器管理的bean做的增强,所以整个工作过程需要从Spring加载bean说起:

首先是第一步:Spring容器启动
Spring容器的启动需要去加载bean,比如需要被增强的BookServerImpl类,或者是通知类MyAdvice。
==注意:==此时的bean对象还没有被创建出来。
第二步:读取所有切面配置中的切入点
图片中有两个切入点配置,圈出来的那一个因为并没有被使用到,所以它不会被读取。

第三步:初始化bean

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

  • 注意: 在第一步在容器启动的时候,bean对象还没有被创建成功。

  • 要被实例化bean对象的类中的方法和切入点进行匹配

  • 匹配失败,就会创建原始对象(没有增强,原始的没有任何变化的)

    • 匹配失败说明不需要增强,直接调用原始对象的方法即可。
  • 匹配成功,创建原始对象(目标对象)的代理对象,

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

第四步:获取bean执行方法

  • 如果获取的bean是原始对象时,则调用方法并执行,完成操作
  • 如果获取的bean是代理对象时,则根据代理对象的运行模式运行原始方法与增强的内容,完成操作

AOP配置管理

现在我们来讲解前面用到的切入点表达式和通知类型

AOP切入点表达式


对于AOP中切入点表达式,我主要给大家讲解三个内容,分别是语法格式通配符书写技巧
语法格式
首先我们先要明确两个概念:

  • 切入点:要进行增强的方法
  • 切入点表达式:要进行增强的方法的描述方式
    对于切入点的描述,我们其实是有两中方式的,先来看下前面的例子

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

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

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

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

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

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

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

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

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

切入点表达式就是要找到需要增强的方法,所以它就是对一个具体方法的描述,但是方法的定义会有很多,所以如果每一个方法对应一个切入点表达式,想想这块就会觉得将来编写起来会比较麻烦,有没有更简单的方式呢?
当然有了,前提就是用到下面我们要学习的通配符
通配符
我们使用通配符描述切入点,主要的目的就是简化之前的配置,具体都有哪些通配符可以使用?
*:单个独立的任意符号,可以独立出现,也可以作为前缀或者后缀的匹配符出现

  execution(public * com.hzy.*.UserService.find*(*))

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

  • ..:多个连续的任意符号,可以独立出现,常用于简化包名与参数的书写
  execution(public User com..UserService.findById(..))

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

  • +:专用于匹配子类类型
  execution(* *..*Service+.*(..))

这个使用率较低,描述子类的,咱们做JavaEE开发,继承机会就一次,使用都很慎重,所以很少用它。*Service+,表示所有以Service结尾的接口的子类。

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

execution(void com.hzy.dao.BookDao.update())
匹配接口,能匹配到
execution(void com.hzy.dao.impl.BookDaoImpl.update())
匹配实现类,能匹配到
execution(* com.hzy.dao.impl.BookDaoImpl.update())
返回值任意,能匹配到
execution(* com.hzy.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.hzy.*.*Service.find*(..))
将项目中所有业务层方法的以find开头的方法匹配
execution(* com.hzy.*.*Service.save*(..))
将项目中所有业务层方法的以save开头的方法匹配

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

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

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

AOP通知类型

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

它所代表的含义是将通知添加到切入点方法执行的前面
除了这个注解外,还有其他四个注解,下面我来为大家讲解。
类型
我们先来说一下下AOP通知:

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

这里一共提供了5种通知类型:

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

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

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

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

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

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

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

我们准备实验环境:
老规矩,第一步创建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 ...");
    
    public int select() 
        System.out.println("book dao select is running ...");
        return 100;
    

创建Spring的配置类

@Configuration
@ComponentScan("com.hzy")
@EnableAspectJAutoProxy
public class SpringConfig 

创建通知类

@Component
@Aspect
public class MyAdvice 
    @Pointcut("execution(void com.hzy.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 ...");
    

编写Application运行类

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

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

AOP通知类型详解

前置通知
修改MyAdvice,在before方法上添加@Before注解

@Component
@Aspect
public class MyAdvice 
    @Pointcut("execution(void com.hzy.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.hzy.dao.BookDao.update())")
    private void pt()
    
    @Before(Spring AOP源码—<aop:config/>AOP配置标签解析一万字

Java面试题超详细整理《Spring篇》

Java面试题超详细整理《Spring篇》

Java面试题超详细整理《Spring篇》

猿创征文|基于反事实的因果推理Causal inference based on counterfactuals--一万六千字文献详细解读(因果关系的推理应用)全文总结

阅读量爆表-最全Spring常见面试题总结(超详细回答)