【Java Web】-＞ Spring 5 -＞ AOP

最新推荐文章于 2022-12-15 16:42:32 发布

_为光

最新推荐文章于 2022-12-15 16:42:32 发布

阅读量391

点赞数 2

分类专栏： Java Web 文章标签： spring java aop 动态代理

本文链接：https://blog.csdn.net/qq_45627684/article/details/113755813

版权

Java Web 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

本文详细介绍了Spring AOP（面向切面编程）的概念，包括连接点、切入点、通知和切面等核心概念，并通过实例展示了如何进行基于注解的AOP操作，包括五种通知类型的使用，相同切入点的提取以及增强类优先级的设置。文章旨在帮助读者理解AOP的工作原理及其在Java Web开发中的应用。

摘要由CSDN通过智能技术生成

Ⅰ 什么是AOP

AOP（Aspect Oriented Programming），意为面向切面编程。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

比如我们现在有一个用户登录的功能。

在这里插入图片描述
这个功能做完了以后，我们现在想再添加一个功能，比如根据用户的账号权限不同给用户显示不同的页面，这个鉴权的功能怎么做？

有AOP的话，我们根本不需要修改源代码，直接单独写一个鉴权的模块，然后通过AOP 把鉴权的模块和原来的代码组合在一起就好了。
在这里插入图片描述
并且由于这个鉴权模块是单独的，所以不止能加在这里面，如果有别的代码也需要添加一个鉴权功能，我们也可以直接把这个代码拿过去。如果不想用鉴权了，也可以轻松去掉。这样耦合度就非常低了。

所以 AOP 通俗说就是，不通过修改源代码的方式，在主干功能里面添加新功能。

Ⅱ AOP 主要概念

AOP 里有几个专业一点的词，我们需要知道。主要有四个：连接点，切入点，通知，切面。

我用下面这个类来举例。
在这里插入图片描述
连接点 就是类里有哪些方法可以被增强，这些方法称为连接点。在这个类中就是所有的这四个方法，它们都可以被增强。（比如我上面举的在登录的过程中增加鉴权）。

切入点 是实际上被增强的方法。上面这四个方法虽然都可以被增强，但是我们只增强了 add()，那 add() 就是切入点，其他三个方法只是连接点。

通知是实际增强的逻辑部分，比如我们上面给登录模块增加鉴权功能，那鉴权的代码就是个通知。

通知有五种类型，我先概述一下，后面我们通过例子来细看。

前置通知：在执行方法前执行的逻辑；
后置通知：在执行方法后执行的逻辑；
环绕通知：在执行方法前后都要执行的逻辑；
异常通知：方法执行出现异常后执行的逻辑；
最终通知：无论有没有异常最终都会执行的逻辑，类似于finally。

切面是一个动作，把通知应用到切入点的过程就叫切面。比如把鉴权功能加到登录的逻辑中，这个过程就叫切面。

Ⅲ AOP 操作

A. 准备工作

如果还不会 Spring IOC 的同学，请先看一下 IOC 的用法。

Spring 框架一般都是基于 AspectJ 实现 AOP 操作。

AspectJ 并不是 Spring 的组成部分，是一个独立的 AOP 框架，一般都是把 AspectJ 和 Spring 框架一起使用，进行 AOP 操作。

和 IOC 一样，基于 AspectJ 的 AOP 操作，也有两个方式，一个是基于 xml 文件配置实现，另一个是基于注解方式实现。一般常用的还是基于注解方式，这样会方便很多。

AOP 要依赖的包，我直接贴上 Maven 配置。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.tyz</groupId>
    <artifactId>SpringDemo3</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.aopalliance/com.springsource.org.aopalliance -->
        <dependency>
            <groupId>org.aopalliance</groupId>
            <artifactId>com.springsource.org.aopalliance</artifactId>
            <version>1.0.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/net.sourceforge.cglib/com.springsource.net.sf.cglib -->
        <dependency>
            <groupId>net.sourceforge.cglib</groupId>
            <artifactId>com.springsource.net.sf.cglib</artifactId>
            <version>2.1.3</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>

		<!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>


    </dependencies>
</project>

不用 Maven 的同学可以直接去 Maven 仓库下 jar 包。

在这里插入图片描述

一共需要这几个包。

然后我们还需要熟悉一下切入点表达式。

切入点表达式作用是知道对哪个类里面的哪个方法进行增强，它的语法结构如下：

execution([权限修饰符][返回类型][类全路径][方法名称]([参数列表]))

现在我们来看一下具体的代码要怎么写。

B. 基于注解的 AOP

a. 五种通知

首先我们先建立一个需要被增强的类，写一个简单的方法。

在这里插入图片描述
然后我们再写一个增强类，在这个类中，实现上面提到的几种通知。

我先写一个前置通知作为例子。
在这里插入图片描述

接着我们需要开启注解扫描，和我的 IOC 中一样，有两种方式可以开启注解扫描，一个是在 xml 配置文件中开启，一个是写一个 @Configuration 注解下的配置类，我们这里先采用 xml 配置文件。

首先需要引入 context 和 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:context="http://www.springframework.org/schema/context"
       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/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

</beans>

注意修改下面的 xsd 结构，要将所有的 beans 改成命名空间相同的名称。

接着我们来开启组件扫描。
在这里插入图片描述
base-package属性就是你需要扫描的包名，我这里选择写得详细一点，就扫描 annotation 下的类就可以了。

然后我们需要使用注解创建 User 和 UserProxy 类的对象，即在它们的类上加@Component 就可以了。
在这里插入图片描述

接下来我们需要在增强类上增加 @Aspect 注解，创建代理对象。

在这里插入图片描述
在配置文件中，开启 Aspect，生成代理对象

这句代码的意思就是在扫描到的类上找 @Aspect 注解，如果找到了，就将这个类生成一个代理对象。

接着，我们需要配置不同类型的通知，在前面我们写了一个增强方法before()，我们想让它作为前置通知，所以必须先让这个方法知道，我们需要它作为一个前置通知。

我们要使用切入点表达式来进行配置。
在这里插入图片描述
对照着前面说的切入点表达式，第一个 * 就是任何权限修饰符，后面方法中的 .. 表示任意参数。

这样我们就配置好了一个前置通知。

在这里插入图片描述
测试结果如上图，可以看到在 add 方法前，先执行了我们的前置通知方法。

同样的，我直接把其他四个通知写上，我们来看一下运行效果。

package com.tyz.aop.annotation;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 增强类
 *
 * @author tyz
 */
@Component
@Aspect
public class UserProxy {

    /**
     * 前置通知
     */
    @Before(value = "execution(* com.tyz.aop.annotation.User.add(..))")
    public void before() {
        System.out.println("[----Before----]");
    }

    /**
     * 后置通知
     */
    @After(value = "execution(* com.tyz.aop.annotation.User.add(..))")
    public void after() {
        System.out.println("[----After----]");
    }

    /**
     * 最终通知
     */
    @AfterReturning(value = "execution(* com.tyz.aop.annotation.User.add(..))")
    public void afterReturning() {
        System.out.println("[----AfterReturning----]");
    }

    /**
     * 异常通知
     */
    @AfterThrowing(value = "execution(* com.tyz.aop.annotation.User.add(..))")
    public void afterThrowing() {
        System.out.println("[----AfterThrowing----]");
    }

    /**
     * 环绕通知
     */
    @Around(value = "execution(* com.tyz.aop.annotation.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("[----Around before----]");

        proceedingJoinPoint.proceed();

        System.out.println("[----Around after----]");
    }
}

这里的环绕通知，我着重说一下。

在这里插入图片描述
由于环绕通知是在方法前后执行的，所以这里有一个参数，ProceedingJoinPoint ，它就代表了要增强的方法，通过在 proceed 前后执行相应的操作，就等价于在原需要增强的方法前后执行操作，就是环绕的。

最终的执行结果如下：
在这里插入图片描述
环绕通知一定是在方法执行的前后执行的，这里的顺序其实是不一定的，方法执行前有环绕之前的通知，前置通知，之后有最终通知，后置通知，这些通知能确定的是一定是在方法前后，但是它们之间谁先谁后可能每次运行结果都不太一样。

注意这里的后置通知，也就是AfterReturning，它是在方法返回一个值之后才会执行的，而After 就是在方法执行之后执行。

由于方法没有异常。所以这里没有执行异常通知，我们来手动写一个异常，看看结果。

在这里插入图片描述
结果如下

可以看到，环绕之后的通知没有执行，AfterReturning 的通知也没有执行，但是 After 依旧执行了，所以After 被称作最终通知，就是不管有没有异常都会执行，而AfterReturning 是后置通知。

以上就是五种通知的用法。

b. 相同切入点提取

在上面我们每个通知，都写了一个一模一样的切入点表达式，非常麻烦，那么如果很多个通知要对相同的方法进行增强，我们怎么把相同的切入点抽取出来呢？

在这里插入图片描述
我们可以写一个方法，没有内容，使用 @Pointcut 注解，将切入点的方法写到里面，再其他通知调用的时候，直接调用这个方法就可以了。

c. 设置增强类优先级

如果有多个增强类对同一个方法进行增强，我们要怎么设置增强类优先级呢？

比如我这里再定义一个AnotherProxy 类，写一个同样的对 add 方法的前置通知。
在这里插入图片描述

我们可以在增强类上面添加 @Order 注解（数字类型值），数字类型值越小，优先级越高。

在这里插入图片描述

我们设置的 AnotherProxy 类的 Order 更小，也就是它会被更早执行。运行结果如下：

在这里插入图片描述

C. 基于配置文件的 AOP

同样的，我们写 AOP 也是用的比较多的是基于注解，而不是基于配置文件。这里简单演示一下基于配置文件的 AOP 操作。

我先定义两个类，Book 类为被增强类，BookProxy 类为增强类。

在被增强类中我定义了一个简单的方法作为切入点。

在这里插入图片描述
在增强类中我写一个增强方法，一个前置通知。

在这里插入图片描述
那么首先，我们需要在 xml 配置文件中创建两个类的对象。

在这里插入图片描述
注意哦，这里的配置文件还是和注解的一样，需要引入 aop 和 context 的命名空间。

<aop:before method="before" pointcut-ref="p"/>

这行代码就是选择用什么通知（aop:before），具体是增强类中的哪个方法（method=“before”），以及上面配置的切点。

这样就完成了前置通知的一个配置。

结果如下：
在这里插入图片描述

D. 完全注解开发

最后我们再来看一下不写配置文件的AOP 方法，具体就是看配置类要怎么写。

在这里插入图片描述
1 是告诉 Spring 这个类是一个注解类，2 是告诉 Spring 需要扫描的包， 3 是开启 Aspect，就相当于xml文件中的下面这个语句👇

以上就是 Spring AOP 的相关内容。

_为光

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录