• Spring 中的 AOP

    AOP 概述

    AOP（Aspect-Oriented Programming，面向切面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

    而AOP技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即切面。所谓“切面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

    使用“横切”技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。


    AOP 相关术语

    1. Joinpoint(连接点 )

      所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。

    2. Pointcut(切入点 )

      所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。

    3. Advice(通知 /增强 )

      所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。

      通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。

    4. Introduction(引介 )

      引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。

    5. Target(目标对象 )

      代理的目标对象。

    6. Weaving(织入 )

      是指把增强应用到目标对象来创建新的代理对象的过程。

      spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。

    7. Proxy（代理）

      一个类被 AOP 织入增强后，就产生一个结果代理类。

    8. Aspect(切面 )

      是切入点和通知（引介）的结合。


    AOP maven依赖

    <dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!-- AOP -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>${aspectj.version}</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>${aspectj.version}</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>

    基于 XML 的 AOP 配置

    配置文件中的 AOP 约束

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">
</beans>

    使用 aop:config 声明 aop 配置

    作用： 用于声明开始 aop 的配置

    <aop:config>
    <!-- 配置的代码都写在此处 -->
</aop:config>

    使用 aop:aspect 配置切面

    作用：用于配置切面

    属性：

    ​ id：给切面提供一个唯一标识。

    ​ ref：引用配置好的通知类 bean 的 id。

    <aop:aspect id="XXX" ref="XXXXX">
    <!-- 配置通知的类型要写在此处 -->
</aop:aspect>

    使用 aop:pointcut 配置切入点表达式

    作用：用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强。

    属性：

    ​ expression：用于定义切入点表达式。

    ​ id：用于给切入点表达式提供一个唯一标识

    <aop:before method="printLog" pointcut="execution(
            访问修饰符 返回值 第1层包.第2层包.第3层包.类名称.方法名称(参数列表)
            )"></aop:before>

    使用 aop:xxx 配置 对应的通知类型

    aop:before

    作用：用于配置前置通知。指定增强的方法在切入点方法之前执行

    属性：

    ​ method: 用于指定通知类中的增强方法名称

    ​ ponitcut-ref：用于指定切入点的表达式的引用

    ​ poinitcut：用于指定切入点表达式

    执行时间点：切入点方法执行之前执行

    <aop:before method="增强方法" pointcut-ref="切入点的表达式的引用"/>

    <aop:before method="增强方法" pointcut="切入点表达式"/>

    aop:after-returning

    作用：用于配置后置通知

    属性：

    ​ method： 指定通知中方法的名称。

    ​ pointct： 定义切入点表达式

    ​ pointcut-ref： 指定切入点表达式的引用

    执行时间点：切入点方法正常执行之后。它和异常通知只能有一个执行

    <aop:after-returning method="增强方法" pointcut-ref="切入点的表达式的引用"/>

    <aop:after-returning method="增强方法" pointcut="切入点表达式"/>

    aop:after-throwing

    作用：用于配置异常通知

    属性：

    ​ method： 指定通知中方法的名称。

    ​ pointct： 定义切入点表达式

    ​ pointcut-ref： 指定切入点表达式的引用

    执行时间点：切入点方法执行产生异常后执行。它和后置通知只能执行一个

    <aop:after-throwing method="增强方法" pointcut-ref="切入点的表达式的引用"/>

    <aop:after-throwing method="增强方法" pointcut="切入点表达式"/>

    aop:after

    作用：用于配置最终通知

    属性：

    ​ method： 指定通知中方法的名称。

    ​ pointct： 定义切入点表达式

    ​ pointcut-ref： 指定切入点表达式的引用

    执行时间点：无论切入点方法执行时是否有异常，它都会在其后面执行。

    <aop:after method="增强方法" pointcut-ref="切入点的表达式的引用"/>

    <aop:after method="增强方法" pointcut="切入点表达式"/>

    aop:around

    作用：用于配置环绕通知

    属性：

    ​ method：指定通知中方法的名称。

    ​ pointct：定义切入点表达式

    ​ pointcut-ref：指定切入点表达式的引用

    说明：它是 spring 框架为我们提供的一种可以在代码中手动控制增强代码什么时候执行的方式。

    注意：通常情况下，环绕通知都是独立使用的

    <aop:around method="增强方法" pointcut-ref="切入点的表达式的引用" />
<aop:pointcut id="切入点表达式唯一标识" expression="execution(切入点的表达式)"/>

    切入点表达式说明

    表达式语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数))

    1. 表达式标准格式

      访问修饰符 返回值 包名称.类名称.方法名称(参数列表)

      <aop:before method="printLog" pointcut="execution(
            public void pers.stringbug.service.impl.AccountServiceImpl.saveAccount()
            )"></aop:before>

    2. 省略访问修饰符

      返回值 包名称.类名称.方法名称(参数列表)

      <aop:before method="printLog" pointcut="execution(
            void pers.stringbug.service.impl.AccountServiceImpl.saveAccount()
            )"></aop:before>

    3. 返回值使用通配符

      访问修饰符 * 包名称.类名称.方法名称(参数列表)

      <aop:before method="printLog" pointcut="execution(
            * pers.stringbug.service.impl.AccountServiceImpl.saveAccount()
            )"></aop:before>

    4. 包名使用通配符：包名可以使用通配符 * 表示任意包，但是有多少级包，就要对应多少哥通配符

      访问修饰符 返回值 第1层包.第2层包.第3层包.类名称.方法名称(参数列表)

      • 写法1

        访问修饰符 返回值 *.*.*.类名称.方法名称(参数列表)

      • 写法2：有的时候包的层数很多，可以用 .. 表示多层子包

        访问修饰符 返回值 *..类名称.方法名称(参数列表)

      <aop:before method="printLog" pointcut="execution(
            * *..AccountServiceImpl.saveAccount()
            )"></aop:before>

    5. 类名使用通配符

      访问修饰符 返回值 包名称.*.方法名称(参数列表)

      <!-- 返回值使用通配符、包名使用通配符、类名使用通配符 -->
<aop:before method="printLog" pointcut="execution(
            * *..*.saveAccount()
            )"></aop:before>

    6. 方法名使用通配符

      访问修饰符 返回值 包名称.类名称.*(参数列表)

      <!-- 返回值使用通配符、包名使用通配符、类名使用通配符、方法名使用通配符 -->
<aop:before method="printLog" pointcut="execution(
            * *..*.*(int, String)
            )"></aop:before>

    7. 参数列表使用通配符

      • 只有一个参数时

        访问修饰符 返回值 包名称.类名称.方法名称(*)

      • 有多个参数时

        访问修饰符 返回值 包名称.类名称.方法名称(*, *, *)

      • 有 0 或多个参数时：可以使用 .. 表示参数列表

        访问修饰符 返回值 包名称.类名称.方法名称(..)

      <!-- 返回值使用通配符、包名使用通配符、类名使用通配符、方法名使用通配符、参数使用通配符 -->
<aop:before method="printLog" pointcut="execution(
            * *..*.*(..)
            )"></aop:before>

    8. 全通配写法

      返回值使用通配符、包名使用通配符、类名使用通配符、方法名使用通配符、参数使用通配符

      * *..*.*(..)

    基于注解的 AOP 配置

    配置文件夹中的 AOP 约束和 Context 约束

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
</beans>

    @Aspect 注解

    注解 @Aspect 表示当前类是一个切面类

    如：

    @Component(value="logger")
@Aspect
public class Logger { }

    @Pointcut 注解

    注解 @Pointcut 配置切入点表达式

    属性值：

    ​ value：切入点表达式

    如：

    public class Logger {
    @Pointcut(value="execution(* pers.stringbug.service.*.*(..))")
    private void loggerExpression() { }
}

    @Before 注解

    注解 @Before 指定前置通知

    属性值：

    ​ value：用于指定切入点表达式，还可以指定切入点表达式的引用

    如：

    public class Logger {
    @Pointcut(value="execution(* pers.stringbug.service.*.*(..))")
    private void loggerExpression() { }
    
    @Before(value="loggerExpression()")
    public void beforePrintLog() {
        System.out.println(
                "前置通知：Logger 类中的 beforePrintLog 方法开始记录日记信息了");
    }
}

    @AfterReturning 注解

    注解 @AfterReturning 指定后置通知

    属性值：

    ​ value：用于指定切入点表达式，还可以指定切入点表达式的引用

    如：

    public class Logger {
    @Pointcut(value="execution(* pers.stringbug.service.*.*(..))")
    private void loggerExpression() { }
    
    @AfterReturning(value="loggerExpression()")
    public void afterReturningPrintLog() {
        System.out.println(
                "后置通知：Logger 类中的 afterReturningPrintLog 方法开始记录日记信息了");
    }
}

    @AfterThrowing 注解

    注解 @AfterThrowing 指定异常通知

    属性值：

    ​ value：用于指定切入点表达式，还可以指定切入点表达式的引用

    如：

    public class Logger {
    @Pointcut(value="execution(* pers.stringbug.service.*.*(..))")
    private void loggerExpression() { }
    
    @AfterThrowing(value="loggerExpression()")
    public void afterThrowingPrintLog() {
        System.out.println(
                "异常通知：Logger 类中的 afterThrowingPrintLog 方法开始记录日记信息了");
    }
}

    @After 注解

    注解 @After 指定最终通知

    属性值：

    ​ value：用于指定切入点表达式，还可以指定切入点表达式的引用

    如：

    public class Logger {
    @Pointcut(value="execution(* pers.stringbug.service.*.*(..))")
    private void loggerExpression() { }
    
    @After(value="loggerExpression()")
    public void afterPrintLog() {
        System.out.println(
                "最终通知：Logger 类中的 afterPrintLog 方法开始记录日记信息了");
    }
}

    @Around 注解

    注解 @Around 指定环绕通知

    属性值：

    ​ value：用于指定切入点表达式，还可以指定切入点表达式的引用

    • Spring 框架为我们提供了一个接口（ProceedingJoinPoint），该接口有一个 Proceed 方法，可以明确切入点方法。
    • **ProceedingJoinPoint** 接口可作为环绕通知的方法参数，在执行程序的时候，Spring 框架会为我们提供该接口的实现类来使用。

    如：

    public class Logger {
    @Pointcut(value="execution(* pers.stringbug.service.*.*(..))")
    private void loggerExpression() { }
    
    @Around(value="loggerExpression()")
    public Object aroundPrintLog(ProceedingJoinPoint joinPoint) {
        try {
            // 获取方法执行所需的参数
            Object[] args = joinPoint.getArgs();
            System.out.println(
                    "前置通知：Logger 类中的 beforePrintLog 方法开始记录日记信息了");
            // 明确要调用的业务层方法（即切入点方法）
            Object returnValue = joinPoint.proceed(args);
            System.out.println(
                    "后置通知：Logger 类中的 afterReturningPrintLog 方法开始记录日记信息了");
            return returnValue;
        } catch (Throwable e) {
            System.out.println(
                    "异常通知：Logger 类中的 afterThrowingPrintLog 方法开始记录日记信息了");
            throw new RuntimeException(e);
        } finally {
            System.out.println(
                    "最终通知：Logger 类中的 afterPrintLog 方法开始记录日记信息了");
        }
    }
}

    开启注解 AOP 的支持

    XML 方式

    aspectj-autoproxy

    <aop:aspectj-autoproxy />

    注解方式

    @EnableAspectJAutoProxy

    @Configuration
@ComponentScan(basePackages="pers.stringbug")
@EnableAspectJAutoProxy
public class SpringConfiguration { }

    参考文献

    1. 十分钟全面理解Spring AOP
    Good Good Write Bug, Day Day Up
  • 相关阅读:
    Logback的配置说明
    BAT批处理修改MSDOS窗口标题、大小、字体及背景颜色
    Java修饰符public，private，protected及默认的区别
    Class loading problem regarding ear's lib directory
    MySQL开发规范
    学习如何用自己的 appender 来扩展 log4j 框架
    指令重排、内存屏障概念解析
    高性能线程间队列 DISRUPTOR 简介
    Log4j2的性能为什么这么好？
    java多线程
  • 原文地址：https://www.cnblogs.com/liyihua/p/14482456.html
Copyright © 2020-2023  润新知