• Spring框架----AOP全集

    一：AOP概念的引入

    首先我们来看一下登录的原理
    在这里插入图片描述
    如上图所示这是一个基本的登录原理图，但是如果我们想要在这个登录之上添加一些新的功能，比如权限校验
    那么我们能想到的就有两种方法：
    ①：通过对源代码的修改实现
    ②：不通过修改源代码方式添加新的功能 （AOP）
    在这里插入图片描述

    二：AOP相关的概念

    1. AOP的概述

    什么是AOP的技术？
    在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程
    AOP是一种编程范式，隶属于软工范畴，指导开发者如何组织程序结构。
    AOP最早由AOP联盟的组织提出的,制定了一套规范.Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范。
    通过预编译方式或者运行期动态代理实现程序功能的统一维护的一种技术
    AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
    利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
    AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（事务管理、安全检查、缓存）
    为什么要学习AOP，可以在不修改源代码的前提下，对程序进行增强！！

    2. AOP的优势

    运行期间，不修改源代码的情况下对已有的方法进行增强
    优势：

    1. 减少重复的代码
    2. 提供开发的效率
    3. 维护方便

    3. AOP的底层原理

    JDK的动态代理技术
    1、为接口创建代理类的字节码文件
    2、使用ClassLoader将字节码文件加载到JVM
    3、创建代理类实例对象，执行对象的目标方法
    cglib代理技术
    为类生成代理对象，被代理类有没有接口都无所谓，底层是生成子类，继承被代理类。
    在这里插入图片描述

    三：Spring的AOP技术-配置文件方式

    1. AOP相关的术语

    Joinpoint(连接点) 类里面有哪些方法可以增强这些方法称为连接点
    Pointcut(切入点) – 所谓切入点是指我们要对哪些Joinpoint进行拦截的定义
    Advice(通知/增强)-- 所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
    Aspect(切面)-- 是 切入点+通知 的结合，以后咱们自己来编写和配置的
    在这里插入图片描述

    2. 基本准备工作

    AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法,AspectJ实际上是对AOP编程思想的一个实践.

    3. AOP配置文件方式的入门

    创建maven项目，坐标依赖

    <dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!--AOP联盟-->
    <dependency>
        <groupId>aopalliance</groupId>
        <artifactId>aopalliance</artifactId>
        <version>1.0</version>
    </dependency>
    <!--Spring Aspects-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <!--aspectj-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.3</version>
    </dependency>
</dependencies>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    创建被增强的类

    // 被增强的类
public class User {
    //连接点/切入点
    public void add(){
        System.out.println("add......");
    }
    public void update(){
        System.out.println("update......");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    将目标类配置到Spring中

    <bean id="user" class="com.aopImpl.User"></bean>

    • 1

    定义切面类

    public class UserProxy {
    //增强/通知  ---》前置通知
    public void before(){
        System.out.println("before.............");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    在配置文件中定义切面类

    <bean id="userProxy" class="com.aopImpl.UserProxy"></bean>

    • 1

    在配置文件中完成aop的配置

    <!--配置切面-->
<aop:config>
    <!--配置切面 = 切入点 + 通知组成-->
    <aop:aspect ref="userProxy">
        <!--前置通知：UserServiceImpl的save方法执行前，会增强-->
        <!--pointcut：后边是切入点表达式，作用是知道对对面的那个方法进行增强-->
        <aop:before method="before" pointcut="execution(public void com.aopImpl.User.add())"/>
    </aop:aspect>
</aop:config>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    完成测试

    public class DemoTest {
    @Test
    public void aopTest1(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = (User) applicationContext.getBean("user");
        user.add();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    4. 切入点的表达式

    再配置切入点的时候，需要定义表达式，具体展开如下：
    切入点表达式的格式如下：

    execution([修饰符] [返回值类型] [类全路径] [方法名 ( [参数] )])
    修饰符可以省略不写，不是必须要出现的。
    返回值类型是不能省略不写的，根据你的方法来编写返回值，可以使用 * 代替。

    包名，类名，方法名，参数的规则如下：

    例如：com.qcby.demo3.BookDaoImpl.save()
首先包名，类名，方法名是不能省略不写的，但是可以使用 * 代替
中间的包名可以使用 * 号代替
类名也可以使用 * 号代替，也有类似的写法：*DaoImpl
方法也可以使用 * 号代替
参数如果是一个参数可以使用 * 号代替，如果想代表任意参数使用 ..


比较通用的表达式：execution(* com.qcby.*.ServiceImpl.save(..))
举例2：com.qcby.demo3.BookDaoImpl当中所有的方法进行增强
execution(* com.qcby.*.ServiceImpl.*(..))
举例3：com.qcby.demo3包当中所有的方法进行增强
execution(* com.qcby.*.*.*(..))

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    <!--配置切面-->
<aop:config>
    <!--配置切面 = 切入点 + 通知组成-->
    <aop:aspect ref="userProxy">
        <!--切入点的表达式
        execution() 固定的写法
        public 是可以省略不写的
        方法的返回值 int String 通用的写法，可以编写 * 不能省略不写的
        包名+类名 不能省略不写的，编写 * com.*
        方法名称 add() 可以写 *
        参数列表 (..) 表示任意类型和个数的参数
        比较通用的表达式：execution(* com.*.User.add(..))-->
        <aop:before method="before" pointcut="execution(* com.*.User.add(..))"/>
    </aop:aspect>
</aop:config>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    5. AOP的通知类型

    ①: 前置通知 目标方法执行前，进行增强。

    如上配置案例就是前置通知

    ② 环绕通知 目标方法执行前后，都可以进行增强。目标对象的方法需要手动执行。

    // 环绕通知
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    System.out.println("before.............");
    //  执行被增强的方法
    proceedingJoinPoint.proceed();
    
    System.out.println("after.............");
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    xml配置

    <aop:around method="around" pointcut="execution(* com.*.User.add(..))"/>

    • 1

    ③. 最终通知 目标方法执行成功或者失败，进行增强。

    // 最终通知
public void after() {
    System.out.println("after.............");
}

    • 1
    • 2
    • 3
    • 4

    xml配置

    <aop:after method="after" pointcut="execution(* com.*.User.add(..))"/>

    • 1

    ④. 后置通知 目标方法执行成功后，进行增强。

    //后置通知
public void afterReturning() {
    System.out.println("afterReturning.............");
}

    • 1
    • 2
    • 3
    • 4

    xml配置

    <aop:after-returning method="afterReturning" pointcut="execution(public void com.aopImpl.User.add())"/>

    • 1

    ⑤. 异常通知 目标方法执行失败后，进行增强。(发生异常的时候才会执行，否则不执行)

    //异常通知
public void afterThrowing() {

    System.out.println("afterThrowing.............");
}

    • 1
    • 2
    • 3
    • 4
    • 5

    需要改动一下切点

    //连接点/切入点
public void add(){
    int a = 10 / 0;
    System.out.println("add......");
}

    • 1
    • 2
    • 3
    • 4
    • 5

    xml配置

    <aop:after-throwing method="afterThrowing" pointcut="execution(public void com.aopImpl.User.add())"/>

    • 1

    4.Spring的AOP技术-注解方式

    1. AOP注解方式入门程序

    创建maven工程，导入坐标。编写接口，完成IOC的操作。步骤略。
    编写切面类
    给切面类添加注解 @Aspect，编写增强的方法，使用通知类型注解声明
    ①.配置xml扫描注解

    <?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">

    <!--开启注解扫描-->
    <context:component-scan base-package="com.aopImpl"></context:component-scan>
    
</beans>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    ②.配置注解

    @Component
public class User {
    //连接点/切入点
    public void add(){
        System.out.println("add......");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    给切面类添加注解 @Aspect，编写增强的方法，使用通知类型注解声明

    @Component
@Aspect  //生成代理对象
public class UserProxy {

}

    • 1
    • 2
    • 3
    • 4
    • 5

    ③.配置文件中开启自动代理

    <?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">

    <!--开启注解扫描-->
    <context:component-scan base-package="com.aopImpl"></context:component-scan>
    <!--开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    ④.通知类型注解
    @Before – 前置通知
    @AfterReturing – 后置通知
    @Around – 环绕通知（目标对象方法默认不执行的，需要手动执行）
    @After – 最终通知
    @AfterThrowing – 异常抛出通知

    @Component
@Aspect  //生成代理对象
public class UserProxy {
    //增强/通知  ---》前置通知
    @Before(value = "execution(* com.*.User.add(..))")
    public void before(){
        System.out.println("before.............");

    }

    // 环绕通知
    @Around(value = "execution(* com.*.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("before.............");
        //  执行被增强的方法
        proceedingJoinPoint.proceed();
        System.out.println("after.............");
    }

    // 最终通知
    @After(value = "execution(* com.*.User.add(..))")
    public void after() {

        System.out.println("after.............");
    }

    //异常通知
    @AfterThrowing(value = "execution(* com.*.User.add(..))")
    public void afterThrowing() {

        System.out.println("afterThrowing.............");
    }

    //后置通知
    @AfterReturning(value = "execution(* com.*.User.add(..))")
    public void afterReturning() {

        System.out.println("afterReturning.............");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    ⑤.测试类

    @Test
public void aopTest1(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    
    user.add();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
  • 相关阅读:
    汽车网络安全渗透测试概述
    python中的装饰器（基础装饰器）
    【时间序列预测】Informer论文笔记
    配置路由器支持Telnet操作 计网实验
    【Linux】软件包管理器 yum
    INTERSPEECH 2022｜CALM: 基于对比学习的表现力语音合成跨模态说话风格建模【语音之家】
    3D双目跟踪瞳孔识别
    umich cv-2-1
    ChatGPT：突破写作限制，开启论文写作新境界
    【NOI模拟赛】背包（优先队列，贪心）
  • 原文地址：https://blog.csdn.net/weixin_39038328/article/details/136695029