Loading...
墨滴

楼仔

2021/06/04  阅读:22  主题:橙心

【Spring基础系列5】Spring AOP基础(上)

主要讲解AOP基础知识和不同的使用姿势。

前言

学习Spring AOP时,开始以为AOP的知识会很多,但是和IOC知识比起来,发现少很多,但是如果放到一篇文章,感觉还是有点长,就分上-下两个部分,来讲解这块知识。

这两天更新的有点慢,感觉身体不太好,可能是早上起太早了,效率不太高,周末会好好休息一下,把状态调整过来。

关于AOP

AOP概述

如果说 IoC 是 Spring 的核心,那么面向切面编程就是 Spring 最为重要的功能之一了。

  • 面向切面编程(AOP)和面向对象编程(OOP)类似,也是一种编程模式。Spring AOP 是基于 AOP 编程模式的一个框架,它的使用有效减少了系统间的重复代码,达到了模块间的松耦合目的。
  • AOP 的全称是“Aspect Oriented Programming”,即面向切面编程,它将业务逻辑的各个部分进行隔离,使开发人员在编写业务逻辑时可以专心于核心业务,从而提高了开发效率。
  • AOP 采取横向抽取机制,取代了传统纵向继承体系的重复性代码,其应用主要体现在事务处理、日志管理、权限控制、异常处理等方面。
  • 目前最流行的 AOP 框架有两个,分别为 Spring AOP 和 AspectJ:
    • Spring AOP 使用纯 Java 实现,不需要专门的编译过程和类加载器,在运行期间通过代理方式向目标类植入增强的代码。
    • AspectJ 是一个基于 Java 语言的 AOP 框架,从 Spring 2.0 开始,Spring AOP 引入了对 AspectJ 的支持。AspectJ 扩展了 Java 语言,提供了一个专门的编译器,在编译时提供横向代码的植入。

面向切面编程

首先,在面向切面编程的思想里面,把功能分为核心业务功能,和周边功能:

  • 所谓的核心业务,比如登陆,增加数据,删除数据都叫核心业务
  • 所谓的周边功能,比如性能统计,日志,事务管理等等

周边功能在 Spring 的面向切面编程AOP思想里,即被定义为切面。在面向切面编程AOP的思想里面,核心业务功能和切面功能分别独立进行开发,然后把切面功能和核心业务功能 "编织" 在一起,这就叫AOP。

AOP能够将那些与业务无关,却为业务模块所共同调用的逻辑或责任(例如事务处理、日志管理、权限控制等)封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可拓展性和可维护性。

AOP基础知识

基础概念

为了更好地理解 AOP,就需要对 AOP 的相关术语有一些了解,这些专业术语主要包含 Joinpoint、Pointcut、Advice、Target、Weaving、Proxy 和 Aspect,它们的含义如下表所示。

上面的讲解有点抽象,我们再进一步进行讲解:

  • 切面(Aspect):Aspect 声明类似于 Java 中的类声明,事务管理是AOP一个最典型的应用。在AOP中,切面一般使用 @Aspect 注解来使用,在XML中,可以使用 <aop:aspect> 来定义一个切面。
  • 连接点(Join Point):一个在程序执行期间的某一个操作,就像是执行一个方法或者处理一个异常。在Spring AOP中,一个连接点就代表了一个方法的执行。
  • 通知(Advice):在切面中(类)的某个连接点(方法)采取的动作,会有四种不同的通知方式: around(环绕通知),before(前置通知),after(后置通知), exception(异常通知),return(返回通知)。许多AOP框架(包括Spring)将建议把通知作为为拦截器,并在连接点周围维护一系列拦截器。
  • 切入点(Pointcut):表示一组连接点,通知与切入点表达式有关,并在切入点匹配的任何连接点处运行(例如执行具有特定名称的方法)。由切入点表达式匹配的连接点的概念是AOP的核心,Spring默认使用AspectJ切入点表达式语言。
  • 介绍(Introduction):introduction可以为原有的对象增加新的属性和方法。例如,你可以使用introduction使bean实现IsModified接口,以简化缓存。
  • 目标对象(Target Object):由一个或者多个切面代理的对象。也被称为"切面对象"。由于Spring AOP是使用运行时代理实现的,因此该对象始终是代理对象。
  • AOP代理(AOP proxy):由AOP框架创建的对象,在Spring框架中,AOP代理对象有两种:JDK动态代理和CGLIB代理
  • 织入(Weaving):是指把增强应用到目标对象来创建新的代理对象的过程,它(例如 AspectJ 编译器)可以在编译时期,加载时期或者运行时期完成。与其他纯Java AOP框架一样,Spring AOP在运行时进行织入。

什么?还是有点蒙圈?可以看看下面这位大神的总结,言简意赅,如果还不懂,那楼哥也没办法了。

  • 切入点(Pointcut):在哪些类,哪些方法上切入(where)
  • 通知(Advice):在方法执行的什么实际(when:方法前/方法后/方法前后)做什么(what:增强的功能)
  • 切面(Aspect):切面 = 切入点 + 通知,通俗点就是:在什么时机,什么地方,做什么增强!
  • 织入(Weaving):把切面加入到对象,并创建出代理对象的过程。(由 Spring 来完成)

通知的分类

  • 前置通知(Before Advice): 在目标方法被调用前调用通知功能;相关的类org.springframework.aop.MethodBeforeAdvice
  • 后置通知(After Advice): 在目标方法被调用之后调用通知功能;相关的类org.springframework.aop.AfterReturningAdvice
  • 返回通知(After-returning): 在目标方法成功执行之后调用通知功能;
  • 异常通知(After-throwing): 在目标方法抛出异常之后调用通知功能;相关的类org.springframework.aop.ThrowsAdvice
  • 环绕通知(Around): 把整个目标方法包裹起来,在被调用前和调用之后分别调用通知功能相关的类org.aopalliance.intercept.MethodInterceptor

AOP织入的三种时期

  • 编译期: 切面在目标类编译时被织入,这种方式需要特殊的编译器。AspectJ 的织入编译器就是以这种方式织入切面的。
  • 类加载期: 切面在目标类加载到 JVM 时被织入,这种方式需要特殊的类加载器( ClassLoader ),它可以在目标类引入应用之前增强目标类的字节码。
  • 运行期: 切面在应用运行的某个时期被织入。一般情况下,在织入切面时,AOP容器会为目标对象动态创建一个代理对象,Spring AOP 采用的就是这种织入方式。

AOP简单示例

学习语言最好的方式就是实战,其它的介绍我们就先不进行,直接看一个具体的使用示例,我们先定义一个实现类:

@Component("customerDao")
public class CustomerDaoImpl {
    public void add() {
        System.out.println("添加客户...");
    }
    public void update() {
        System.out.println("修改客户...");
    }
    public void delete() {
        System.out.println("删除客户...");
    }
    public void find() {
        System.out.println("修改客户...");
    }
}

然后再定义一个切面类:

@Component
public class MyAspect {
    // 前置通知
    public void myBefore(JoinPoint joinPoint) {
        System.out.println("前置通知,方法名称:" + joinPoint.getSignature().getName());
    }
    // 后置通知
    public void myAfterReturning(JoinPoint joinPoint) {
        System.out.println("后置通知,方法名称:" + joinPoint.getSignature().getName());
    }
    // 环绕通知
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕开始"); // 开始
        Object obj = proceedingJoinPoint.proceed(); // 执行当前目标方法
        System.out.println("环绕结束"); // 结束
        return obj;
    }
    // 异常通知
    public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
        System.out.println("异常通知,出错了");
    }
    // 最终通知
    public void myAfter() {
        System.out.println("最终通知");
    }
}

下面这个非常重要,就是在applicationContext.xml文件中增加相应配置:

<!-- 用于注解扫描 -->
<context:component-scan base-package="com.java.spring.aop.xml2" />
<context:component-scan base-package="com.java.spring.aop.customer" />
<!-- 使切面开启自动代理 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<!--AOP 编程 -->
<aop:config>
    <aop:aspect ref="myAspect">
        <!-- 配置切入点,通知最后增强哪些方法 -->
        <aop:pointcut expression="execution (* com.java.spring.aop.customer.*.* (..))" id="myPointCut" />
        <!--前置通知,关联通知 Advice和切入点PointCut -->
        <aop:before method="myBefore" pointcut-ref="myPointCut" />
        <!--后置通知,在方法返回之后执行,就可以获得返回值returning 属性 -->
        <aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="returnVal" />
        <!--环绕通知 -->
        <aop:around method="myAround" pointcut-ref="myPointCut" />
        <!--抛出通知:用于处理程序发生异常,可以接收当前方法产生的异常 -->
        <!-- *注意:如果程序没有异常,则不会执行增强 -->
        <!-- * throwing属性:用于设置通知第二个参数的名称,类型Throwable -->
        <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e" />
        <!--最终通知:无论程序发生任何事情,都将执行 -->
        <aop:after method="myAfter" pointcut-ref="myPointCut" />
    </aop:aspect>
</aop:config>

这里必须要开启“使切面开启自动代理”,否则AOP不生效,因为我都是通过注解扫描自动注入,所以不要忘记“用于注解扫描”中的内容,因为我的CustomerDaoImpl和MyAspect分别放到xml2和customer这两个包下面,所以需要扫描这两个包。

对于下面这个,我估计很多同学看到这个,第一时间处于蒙圈状态:

execution (* com.java.spring.aop.customer.*.* (..))

这个其实是Spring AOP表达式的写法:

任意公共方法的执行:
execution(public * *(..))
##public可以省略, 第一个* 代表方法的任意返回值 第二个参数代表任意包+类+方法 (..)表示任意参数
 
任何一个以“get”开始的方法的执行:
execution(* get*(..))
 
UserService接口的任意方法:
execution(* com.einblatt.service.UserService.*(..))
 
定义在com.einblatt.service包里的任意方法的执行:
execution(* com.einblatt.service.*.*(..))
#第一个 .* 代表任意类, 第二个 .* 代表任意方法
 
定义在service包和所有子包里的任意类的任意方法的执行:
execution(* com.einblatt.service..*.*(..))
# ..* 代表任意包或者子包
 
定义在com.einblatt包和所有子包里的UserService类的任意方法的执行:
execution(* com.einblatt..UserService.*(..))

我们再回顾一下上面的这个表达式,第一个“星号”表示任意返回值,com.java.spring.aop.custome是需要加强对象的包路径,第二个“星号”表示这个包路径下所有的文件,第三个“星号”表示文件中类的所有的方法,最后的两个“..”,表示可以是任意参数。

编辑器不能直接打“*”符号,会被当做排版符号,我就用“星号”代替。

对于applicationContext.xml文件中的其它内容,我们配置了切面myAspect,定义切面的切入点myPointCut,然后针对该切入点,配置了前置、后置、环绕、抛出异常和最终通知等功能,所以我们执行切入点中的方法时,都会通过切面中的方法进行增强,下面的示例:

public class XMLTest {
    @Test
    public void test() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        CustomerDaoImpl customerDao = (CustomerDaoImpl) applicationContext.getBean("customerDao");
        // 执行方法
        customerDao.add();
    }
}
// 输出:
// 前置通知,方法名称:add
// 环绕开始
// 添加客户...
// 最终通知
// 环绕结束
// 后置通知,方法名称:add

我们的核心方法输出的是“添加客户...”,这里AOP给我们增加了前置通知、环绕通知、最终通知和后置通知,大家可以看一下调用顺序,下面测试一下抛出通知,我们修改CustomerDaoImpl内容如下:

@Component("customerDao")
public class CustomerDaoImpl {
    public void add() throws Exception {
        System.out.println("添加客户...");
        throw new Exception("抛出异常测试");
    }
    // ...
}

还是通过上面的示例测试,输出结果如下:

前置通知,方法名称:add
环绕开始
添加客户...
最终通知
异常通知,出错了

可以看到抛出异常加强输出“异常通知,出错了”,但是后面的“环绕结束”和“后置通知”就没有了。

通过这个简单的示例,大家应该多AOP有一个初步的了解,这个示例其实是基于AspectJ的XML实现方式。其实JAVA中实现AOP的方式有很多种,下面我们对现有的实现方式,进行一个整体的介绍,让大家有一个宏观的认识。

AOP的两种实现方式

AOP 采用了两种实现方式:静态织入(AspectJ 实现)和动态代理(Spring AOP实现)

  • 静态织入(AspectJ 实现):又可以分为基于XML的声明式,基于Annotation的声明式。(上面的示例,是AspectJ基于XML的声明式)
  • 动态代理(Spring AOP实现):又可以分为JDK动态代理和CGLib 动态代理。

所以准确来说,实现AOP其实有4种实现姿势。

AspectJ

  • AspectJ 是一个采用Java 实现的AOP框架,它能够对代码进行编译(一般在编译期进行),让代码具有AspectJ 的 AOP 功能。
  • AspectJ 是目前实现 AOP 框架中最成熟,功能最丰富的语言。
  • ApectJ 主要采用的是编译期静态织入的方式。在这个期间使用 AspectJ 的 acj 编译器(类似 javac)把 aspect 类编译成 class 字节码后,在 java 目标类编译时织入,即先编译 aspect 类再编译目标类。

Spring AOP 实现

Spring AOP 是通过动态代理技术实现的,而动态代理是基于反射设计的。Spring AOP 采用了两种混合的实现方式:JDK 动态代理和 CGLib 动态代理,分别来理解一下:

  • JDK动态代理:Spring AOP的首选方法。 每当目标对象实现一个接口时,就会使用JDK动态代理。目标对象必须实现接口
  • CGLIB代理:如果目标对象没有实现接口,则可以使用CGLIB代理。

因为文章篇幅原因,AOP的4种实现姿势,还有3种未给出示例,我将会在下一篇文章中给出完整的示例描述。

总结

通过这篇文章,你可以掌握AOP的基础知识,以及对AOP的使用有一个初步的认识,目前项目中用的最多的其实是AspectJ基于Annotation的声明式,下一篇文章会给出完整的示例,然后对于AOP,我理解内部是通过代理和装饰器模式来实现的,我们也会在下一篇文章中和大家进行探讨。

欢迎大家多多点赞,更多文章,请关注微信公众号“楼仔进阶之路”,点关注,不迷路~~

楼仔

2021/06/04  阅读:22  主题:橙心

作者介绍

楼仔