Spring实现`aop`过程

已于 2022-05-14 20:47:03 修改
阅读量465 收藏 3
点赞数 1
分类专栏： Spring家庭 文章标签： spring java 后端
于 2022-05-14 20:41:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47267628/article/details/124772619
版权

对AOP术语进行解释

1.连接点
类里面哪些方法可以被增强，这些方法称为连接点【如下面Student类中的study review note方法都可以被增强，所以都可以称为连接点】

public class Student {
    public void study(){
        System.out.println("海康学习aop。。。");
    }

    public void review(){
        System.out.println("海康aop。。。");
    }
    
    public void note(){
        System.out.println("做aop笔记。。。");
    }
}

2.切入点
实际被真实增强的方法，称为切入点【表示要增强那个方法，例如：增强study方法，那么study就是切入点】

3.通知（增强）
(1)实际增强的逻辑部分称为通知（增强）
(2)通知多种类型：

  1. 前置通知：就是在增强该方法前执行：使用@Before注解
  2. 后置通知：就是在增强该方法后执行：使用@AfterReturning注解，如果出现异常则不会该增强方法
  3. 环绕通知：就是在该方法前后都会执行：@Around注解，需要传入ProceedingJoinPoint类调用proceed()方法表示调用需要增强的方法
  4. 异常通知：就是该方法出现异常才会执行：@AfterThrowing注解
  5. 最终通知：就是该方法不管是否出现异常都会执行【相当于try中的finally】@After注解

4.切面
把通知的行为应用到切入点过程中

例如：对`study`方法进行增强，
在`study`执行前先执行`paly方法`，
这一过程就可以理解为切面

AOP实现准备工作

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

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

2.基于AspectJ实现AOP操作有两种方式：

  1. 基于xml配置文件方式

  2. 基于注解方式实现方式（推荐）

  3. 使用AspectJ实现AOP操作第一步引入 jar包

4.切入点表达式

（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强

（2）语法结构：execution([权限修饰符][返回类型][类全路径][方法名](参数列表))

返回类型可以不写

举例1：
对com.haikang.dao.UserDao类里面的`add`方法进行增强
	execution(* com.haikang.dao.UserDao.add(..))
	
	
举例2：
对com.haikang.dao.UserDao类里面所有方法进行增强
	execution(* com.haikang.dao.UserDao.*(..) )
	
	
举例3：
对com.haikang.dao包里面所有有类，类里面所有方法进行增强
	execution(* com.haikang.*.*(..))

AOP操作AspectJ

1.创建类，在类里面定义方法
2.创建增强类（编写增强逻辑代码）【需要在该类中 @Aspect表示是增强类】
3.进行通知的配置
1.在Spring配置文件中，需要开启两个命名空间context和aop
2.开启注解扫描
3.使用注解注入被增强类和增强类的对象
4.在增强类上面添加@Aspect【表示该类为代理类】
5.Spring配置文件中开启生成代理对象
4.配置不同类型通知
在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

步骤

1.创建类，在类里面定义方法，并且在IOC容器中注入该类对象

@Component
public class Student {
    public void study(){
        System.out.println("海康学习aop。。。");
    }

    public void review(){
        System.out.println("海康aop。。。");
    }

    public void note(){
        System.out.println("做aop笔记。。。");
    }
}

2.定义增强类，并且添加@Aspect注解表示是代理类，同时并在IOC容器中注入该类对象

@Component
@Aspect
public class StudentProxy {
    // 表示在执行Study方法先打一小王者荣耀，三个小时
    @Before("execution(* com.haikang.aop.jdk2.Student.study(..))")
    public void before(){
        System.out.println("执行前增强...");
        System.out.println("表示在执行Study方法先打一小王者荣耀，三个小时");
    }
}

3.创建bean.xml文件，引入context命名空间和aop命名空间，在配置文件中开启组件扫描和开启自动生成代理对象

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">

        <!--开启组件扫描-->
        <context:component-scan base-package="com.haikang.aop.jdk2"/>
        <!--开启生成代理类-->
       <aop:aspectj-autoproxy />
</beans>

test类

public class AopTest {
    @Test
    public void testAop(){
        ClassPathXmlApplicationContext context = 
                new ClassPathXmlApplicationContext("bean1.xml");
        Student student = context.getBean("student", Student.class);
        student.study();
    }
}

前置增强
表示是在执行被增强的方法执行，不管被增强的方法是否出现异常，都会执行

// 表示在执行Study方法先打一小王者荣耀，三个小时
    @Before("execution(* com.haikang.aop.jdk2.Student.study(..))")
    public void before(){
        System.out.println("执行前增强...");
        System.out.println("表示在执行Study方法先打一小王者荣耀，三个小时");
    }

在这里插入图片描述

环绕增强:

	public void review(){
        System.out.println("海康复习aop两分钟。。。呵呵，够了");
    }


// 表示在执行review方法前面都需要进行增强
    @Around("execution(* com.haikang.aop.jdk2.Student.review(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("在复习`aop前打三个小时王者荣耀......`");
        joinPoint.proceed();//调用增强方法
        System.out.println("复习完`aop`刷五个小抖音......");
    }

在这里插入图片描述
注意是：环绕增强，被增强的方法如果出现了异常，只会执行前的增强，没有对被方法执行后进行增强
例如：手动模拟一个算数异常

// 表示在执行review方法前面都需要进行增强
    @Around("execution(* com.haikang.aop.jdk2.Student.review(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("在复习`aop前打三个小时王者荣耀......`");
        joinPoint.proceed();//调用增强方法
        System.out.println("复习完`aop`刷五个小抖音......");
    }

public void review(){
        int i = 10/0;
        System.out.println("海康复习aop两分钟。。。呵呵，够了");
    }

在这里插入图片描述

后置增强
特点是：后置通知，当被增强的程序出现异常时，则该增强方法则不会被执行

	public void note(){
        System.out.println("海康做aop笔记是认真的。。。");
    }

    // 表示后置对`note`增强，表示在被`note`执行后进行增强
    @AfterReturning("execution(* com.haikang.aop.jdk2.Student.note(..))")
    public void afterReturning(){
        System.out.println("对做笔记方法进行后置增强，做笔记我是认真的，哈哈。。。");
    }

在这里插入图片描述

异常通知：表示只有被增强的方法出现异常时，才会执行该增强方法

	public void study(){
        int[] arr = {1,2};
        arr[5] = 10;//数组下标越界异常
        System.out.println("海康学习aop。。。");
    }

// 异常通知，表示只有出现了异常该方法才会被执行
    @AfterThrowing("execution(* com.haikang.aop.jdk2.Student.study(..))")
    public void throwing(){
        System.out.println("被增强的方法出现异常了。。。呵呵");
    }

在这里插入图片描述

最终异常：【不管是否出现异常都会执行方法】

    public void finallyMethod(){
        System.out.println("学习。。。");
    }

    // 最终通知，不管是否出现异常都会被执行的方法
    @After("execution(* com.haikang.aop.jdk2.Student.finallyMethod(..))")
    public void after(){
        System.out.println("最终还是要好好学习的，不管是否出现异常。。。");
    }

在这里插入图片描述

综合案例

1.定义被增强类

/**
 * @Author 海康
 * @Version 1.0
 */
@Component
public class Student {
    public void study(){
        int[] arr = {1,2};
        arr[5] = 10;//数组下标越界异常
        System.out.println("海康学习aop。。。");
    }

    public void review(){
        int i = 10/0;
        System.out.println("海康复习aop两分钟。。。呵呵，够了");
    }

    public void note(){
        System.out.println("海康做aop笔记是认真的。。。");
    }

    public void finallyMethod(){
        System.out.println("学习。。。");
    }
}

2.定义增强类

/**
 * @Author 海康
 * @Version 1.0
 */
@Component
@Aspect
public class StudentProxy {
    // 表示在执行Study方法先打一小王者荣耀，三个小时
//    @Before("execution(* com.haikang.aop.jdk2.Student.study(..))")
    public void before(){
        System.out.println("执行前增强...");
        System.out.println("表示在执行Study方法先打一小王者荣耀，三个小时");
    }

    // 表示在执行review方法前面都需要进行增强
    @Around("execution(* com.haikang.aop.jdk2.Student.review(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("在复习`aop前打三个小时王者荣耀......`");
        joinPoint.proceed();//调用增强方法
        System.out.println("复习完`aop`刷五个小抖音......");
    }

    // 表示后置对`note`增强，表示在被`note`执行后进行增强
    @AfterReturning("execution(* com.haikang.aop.jdk2.Student.note(..))")
    public void afterReturning(){
        System.out.println("对做笔记方法进行后置增强，做笔记我是认真的，哈哈。。。");
    }

    // 异常通知，表示只有出现了异常该方法才会被执行
    @AfterThrowing("execution(* com.haikang.aop.jdk2.Student.study(..))")
    public void throwing(){
        System.out.println("被增强的方法出现异常了。。。呵呵");
    }

    // 最终通知，不管是否出现异常都会被执行的方法
    @After("execution(* com.haikang.aop.jdk2.Student.finallyMethod(..))")
    public void after(){
        System.out.println("最终还是要好好学习的，不管是否出现异常。。。");
    }
}

3.定义xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">

        <!--开启组件扫描-->
        <context:component-scan base-package="com.haikang.aop.jdk2"/>
        <!--开启生成代理类-->
       <aop:aspectj-autoproxy />
</beans>

4.test类

public class AopTest {
    @Test
    public void testAop(){
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        Student student = context.getBean("student", Student.class);
//        student.study();
//        student.review();
//        student.note();
        student.finallyMethod();
    }
}
细节1：相同的切入点抽取

就是在对同一个切入点进行增强，可以将相同的切入点进行抽取

使用的@Pointcut注解

@Pointcut(value = "execution(* com.haikang.aopAnno.User.add(..))")

@Component
@Aspect
public class UserProxy {
    // 抽取相同的切入点
    @Pointcut(value = "execution(* com.haikang.aopAnno.User.add(..))")
    public void pointcutDemo(){
    }
    
    // 表示对User中的add方法在执行前进行增强
//    @Before("execution(* com.haikang.aopAnno.User.add(..))")
    @Before("pointcutDemo()")
    public void before(){
        System.out.println("before执行前方法前进行增强。。。");
    }

    // 表示对User中的add方法在执行后进行增强
//    @AfterReturning("execution(* com.haikang.aopAnno.User.add())")
    @Before("pointcutDemo()")
    public void afterReturning(){
        System.out.println("执行方法后进行增强");
    }

    // 表示对User中的add方法环绕增强
//    @Around("execution(* com.haikang.aopAnno.User.add())")
    @Before("pointcutDemo()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 注意是：add方法出现异常时，只会执行add方法执行前的操作
        System.out.println("表示对add方法执行前进行增强");
        // 表示执行add方法
        joinPoint.proceed();
        System.out.println("表示对add方法执行后进行增强");
    }
    // 表示对User中的add方法最终增强
//    @After("execution(* com.haikang.aopAnno.User.add())")
    @Before("pointcutDemo()")
    public void after(){
        System.out.println("表示对add方法进行最终增强，不管是否出现异常都会执行");
    }

    // 异常通知【只能该方法出现异常才会被执行】
    @AfterThrowing("execution(* com.haikang.aopAnno.User.add())")
    public void afterThrowing(){
        System.out.println("add方法出现异常了。。。");
    }
}
细节2：有多个增强类对同一个方法进行增强，设置增强优先级[重点]

在增强类上面添加注解@Order(数字类型值)，数字类型值越小优先级越高

就是在多个类对一个类中的一个方法都进行增强时，可以设置优先级

@Component
@Aspect
@Order(1)//数值越小优先级越高
public class PersonProxy {
    // 表示都对User中的add方法在执行前进行增强
    @Before("execution(* com.haikang.aopAnno.User.add(..))")
    public void before(){
        System.out.println("personProxy before执行前方法前进行增强。。。");
    }
}

@Component
@Aspect
@Order(2)//数值越小优先级越高
public class UserProxy {

    // 表示对User中的add方法在执行前进行增强
    @Before("execution(* com.haikang.aopAnno.User.add(..))")
    public void before(){
        System.out.println("before执行前方法前进行增强。。。");
    }
 }

表示PersonProxy增强的优先级高于UserProxy，所以PersonProxy增强方法先执行

细节3：完全使用注解开发

创建配置类，不需要创建xml配置文件

注意是：需要添加@EnableAdpectJAutoProxy(proxyTargetClass = true)注解，表示该类是一个aop代理类，就是Spring配置文件中开启生成代理对象作用

@Configuration
@ComponentScan(basePackages = "com.haikang.aopAnno")
@EnableAspectJAutoProxy(proxyTargetClass = true)// 默认是false，需要传入true
public class ConfigProxy {
}

test类

@Test
    public void proxyAnno(){
        ApplicationContext context =
                new AnnotationConfigApplicationContext(ConfigProxy.class);
        // 注意：获取是被增强的类
        User user = context.getBean("user", User.class);
        user.add();
    }
昱晟168
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring AOP实现原理解析
08-28
Spring AOP实现原理解析 Spring AOP（Aspect-Oriented Programming）是一种面向方面编程的技术，它可以将公共行为封装到一个可重用模块中，以减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可...
Spring AOP 的实现过程
进击的豌豆的博客
07-14 3842
原文：Spring AOP 的实现过程aop 的作用是在书写上将辅助业务逻辑从主业务的逻辑中拆出来，实现主业务和辅助业务的，但在执行主业务逻辑的时候，辅助业逻辑业也会执行。从而保证拆前拆后功能不变。那辅助业务拆出来放在哪里？辅助业务封装在切面中，所以 。什么是切面？切面就是一个类，并且被 注释。辅助业务在切面的哪里？辅助业务封装在切面的方法里，不同的方法封装不同的辅助业务逻辑。切面中的方法是怎么触发的呢？给封装辅助业务逻辑所在的方法标注 其中一个或几个注解。这样当主业务方法执行时，辅助业务的逻辑所在的方法就
【Spring】Spring AOP 初识及实现原理解析
xyk：的博客
08-05 2341
AOP（Aspect Oriented Programming）：面向切面编程，它是⼀种思想，它是对某⼀类事情的集中处理。在我们想要对某一件事情进行集中处理，就可以使用到AOP，它提供一种将程序中的横切关注点模块化的方式。在 AOP 中，我们将这些横切关注点称为“切面”，它们独立于业务逻辑模块，但是可以在程序运行的不同阶段被织入到业务逻辑中。简单来说，AOP 就是对某一件事进行集中处理的思想方式~使用@Aspect@Component // 随着框架的启动而启动。
SpringAOP的实现与原理
m0_73413202的博客
12-13 1539
SpringAOP的细节总结，非常清晰易懂！！！
Spring——AOP原理及流程详解
共勉
11-28 8012
基于5.3.9 版本的Spring源码，对AOP原理及流程详解，AOP是在Bean生成流程中什么位置介入处理的？各个通知方法又是怎么组装的？AOP真的只是动态代理这么简单吗？
【Spring全家桶系列】SpringAOP的实现步骤与工作流程
未见花闻的博客
05-13 1290
如果目标对象中的方法会被增强，那么容器中将存入的是目标对象的代理对象，如果目标对象中的方法不被增强，那么容器中将存入的是目标对象本身。 要验证也很简单，在验证程序获取对象后，调用getClass()方法就能获取到它的类型了。
Spring框架实现AOP添加日志记录功能过程详解
08-25
Spring框架实现AOP添加日志记录功能过程详解 本文主要介绍了使用Spring框架实现AOP添加日志记录功能的过程详解。通过示例代码，详细介绍了如何在业务方法的前面和后面添加日志记录功能。 首先，需要了解什么是AOP...
基于spring@aspect注解的aop实现过程代码实例
08-24
Spring AOP实现过程代码实例基于@Aspect注解 基于Spring @Aspect注解的AOP实现过程代码实例是指通过使用Spring框架中的AOP（Aspect-Oriented Programming）机制来实现面向切面编程的代码实例。在这个实例中，我们将...
SpringAOP实例.docx
05-14
Spring AOP 实现日志记录功能 在软件开发中，日志记录是非常重要的一环，能够帮助开发者追踪应用程序...使用 Spring AOP 实现日志记录功能能够提高代码的可维护性和可读性，帮助开发者更好地追踪应用程序的执行过程。
Spring使用AspectJ注解和XML配置实现AOP
09-01
本主题将深入探讨如何使用AspectJ注解和XML配置在Spring中实现AOP。 首先，我们要了解AOP的基本概念。AOP的核心是切面（Aspect），它将分散在多个对象中的横切关注点（如日志、性能监控）提取出来，形成独立的模块...
如何实现Spring AOP以及Spring AOP的实现原理
crazy_xieyi的博客
04-24 1849
本文主要讲解了如何实现Spring AOP以及Spring AOP的实现原理。AOP 是对某⽅⾯能⼒的统⼀实现，它是⼀种实现思想，Spring AOP 是对 AOP 的具体实现，Spring AOP 可通过 @Aspect（注解）的⽅式来实现 AOP 的功能。Spring AOP 是通过动态代理的⽅式，在运⾏期将 AOP 代码织⼊到程序中的，它的实现⽅式有两种： JDK Proxy 和 CGLIB。
Spring实现AOP之四种方式详解
LittleByte1的博客
06-22 2888
AOP:Aspect Oriented Programming 面向切面编程 在不改变业务方法的同时可以对方法进行功能增强,Spring的两大特色IOC(Inversion of Controler控制反转)和AOP之一. Spring中提供了四种实现AOP的方式:实现Spring提供的AOP接口   1.使用JDK提供的代理方式(又分为静态和动态)   2.使用原生Spring API接口   3.使用Spring纯配置实现   4.使用Spring注解 一.使用JDK提供的代理方式(此种方式不依赖于Sp
Spring Aop 执行流程
@Bean
07-26 2095
闲聊 在Spring Bean的生命周期中，处理aop的流程只有第一步处理通知和最后一步创建代理对象。 可以说只要去掉第一步和最后一步，也不会影响SpringBean的生命周期。可见在生命周期中处理aop 和aop的理念是完全符合解耦的思想。 切面的组成 一个简单的切面AspectJ 通常可以由多个切入点Pointcut 和多个通知Advice 组成。 切入点：切入点和切入点表达式相辅相成的存在，通常由切入点表达式决定切入点需要切入的位置 通知：在切面里面，通知通常分为五种。分别是前置通知，环绕
AOP工作流程
Eumenides_Suki的博客
03-30 624
SpringAOP是在不改变原有设计(代码)的前提下对其进行增强的，它的底层采用的是代理模式实现的，所以要对原始对象进行增强，就需要对原始对象创建代理对象，在代理对象中的方法把通知[如:MyAdvice中的method方法]内容加进去，就实现了增强,这就是我们所说的代理(Proxy)。不能直接打印对象，从上面两次结果中可以看出，直接打印对象走的是对象的toString方法，不管是不是代理对象打印的结果都是一样的，原因是内部对toString方法进行了重写。所以容器中的对象应该是目标对象的代理对象。
spring之AOP实现步骤详解
10-29 1342
简要记录一下spring下实现面向切面编程的步骤 目录 一、 AOP的helloWorld步骤 1.1、加入 jar 包 1.2、在 Spring 的配置文件中加入 aop 的命名空间 1.3、基于注解/配置的方式来使用 AOP 1.4、编写切面类 1. 5. 配置切面 二、注解方式代码 2.1、bean文件配置 2.2、目标类 3.3、切面类 3.4、测试类...
详解AOP的实现（五种增强方式）及执行流程
wang_da_bing的博客
07-16 3238
文章目录AOP的简单介绍建立AOP实例工程工程结构如下图所示代码注解释义application.xml配置文件释义AOP 的执行流程 AOP的简单介绍 AOP（Aspect Oriented Programming 面向切面编程）是一种通过运行期动态代理实现代码复用的机制，是对传统OOP(Object Oriented Programming，面向对象编程 )的补充。目前，Aspectj是Java...
Spring3之AOP动态代理的实现
少年闰土
02-14 161
动态代理是通过指一个代理对象来创建需要的业务对象，然后在这个代理对象中统一进行各种需求的处理；使用动态代理需要如下 4 个步骤：(1) 创建一个类，实现 InvocationHandler 接口(2) 创建代理对象(3) 创建一个方法来生成对象，这个方法的参数是要代理对象(4) 有了代理对象后，不管这个代理对象执行什么方法，都会调用 Invoke 方法。
【spring系列】之17:spring aop工程流程
licwzy的博客
10-20 290
AOP：【动态代理】 * 指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式； * * 1、导入aop模块；Spring AOP：(spring-aspects) * 2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx） * 3、定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知MathCalculator.div运行到哪里然后执行； * 通知方法： * .
cgb2007-京淘day13
qq_16804847的博客
11-12 5773
1.redis其他数据类型 2.SpringBoot整合jedis对象 3.对象与JSON转化的方法 4.缓存实现商品分类查询 5.AOP优化redis缓存
spring aop实现
最新发布
03-23
Spring AOP的实现主要依赖于以下几个核心概念： 1. 切面（Aspect）：切面是一个模块化的单元，它封装了与横切关注点相关的行为。在Spring AOP中，切面可以包含通知（Advice）和切点（Pointcut）。 2. 通知（Advice...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值