Spring核心 AOP

最新推荐文章于 2024-11-02 22:54:18 发布
最新推荐文章于 2024-11-02 22:54:18 发布
阅读量624 收藏
点赞数
分类专栏： spring注解开发 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44230693/article/details/130584685
版权

1.什么是AOP？

AOP（Aspect Orient Programming），直译过来就是面向切面编程。AOP是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。

比如，在《Spring实战（第4版）》中有如下一张图描述了AOP的大体模型。

在这里插入图片描述

可以看出：所谓切面，其实就相当于应用对象间的横切点，我们可以将其单独抽象为单独的模块

总结：AOP是指在程序的运行期间动态地将某段代码切入到指定方法、指定位置进行运行的编程方式。AOP的底层是使用动态代理实现的。

2.实战案例

2.1.导入AOP依赖

在项目的pom.xml文件中引入AOP的依赖，如下所示：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>4.3.12.RELEASE</version>
</dependency>

Spring AOP对面向切面编程做了一些简化操作，只需要加上几个核心注解，AOP就能工作起来

2.2.定义目标类

在com.tianxia.springannotation.aop包下创建一个业务逻辑类，例如MathCalculator，用于处理数学计算上的一些逻辑。比如，我们在MathCalculator类中定义了一个除法操作，返回两个整数类型值相除之后的结果，如下所示

package com.tianxia.springannotation.aop;

/**
 * 业务逻辑类
 * @author liqb
 * @date 2023-05-09 16:30
 **/
public class MathCalculator {

    /**
     * 除法
     * @author liqb
     * @date 2023-05-09 16:31
     * @param i 除数
     * @param j 被除数
     * @return
     */
    public int div(int i, int j) {
        System.out.println("MathCalculator...div...");
        return i / j;
    }
}

需求：希望在业务逻辑运行的时候将日志进行打印，而且是在方法运行之前、方法运行结束、方法出现异常等等位置，都希望会有日志打印出来。

2.3.定义切面类

在com.tianxia.springannotation.aop包下创建一个切面类，例如LogAspects，在该切面类中定义几个打印日志的方法，以这些方法来动态地感知MathCalculator类中的div()方法的运行情况。如果需要切面类来动态地感知目标类方法的运行情况，那么就需要使用Spring AOP中的一系列通知方法了。

AOP中的通知方法及其对应的注解与含义如下：

  • 前置通知（对应的注解是@Before）：在目标方法运行之前运行
  • 后置通知（对应的注解是@After）：在目标方法运行结束之后运行，无论目标方法是正常结束还是异常结束都会执行
  • 返回通知（对应的注解是@AfterReturning）：在目标方法正常返回之后运行
  • 异常通知（对应的注解是@AfterThrowing）：在目标方法运行出现异常之后运行
  • 环绕通知（对应的注解是@Around）：动态代理，我们可以直接手动推进目标方法运行（joinPoint.procced()）

一开始的写法：

package com.tianxia.springannotation.aop;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Before;

/**
 * 日志切面
 * @author liqb
 * @date 2023-05-09 16:33
 **/
public class LogAspects {

    // @Before：在目标方法（即div方法）运行之前切入
    @Before("public int com.tianxia.springannotation.aop.MathCalculator.*(..)")
    public void logStart() {
        System.out.println("除法运行......@Before，参数列表是：{}");
    }

    // 在目标方法（即div方法）结束时被调用
    @After("public int com.tianxia.springannotation.aop.MathCalculator.*(..)")
    public void logEnd() {
        System.out.println("除法结束......@After");
    }

    // 在目标方法（即div方法）正常返回了，有返回值，被调用
    @AfterReturning("public int com.tianxia.springannotation.aop.MathCalculator.*(..)")
    public void logReturn() {
        System.out.println("除法正常返回......@AfterReturning，运行结果是：{}");
    }

    // 在目标方法（即div方法）出现异常，被调用
    @AfterThrowing("public int com.tianxia.springannotation.aop.MathCalculator.*(..)")
    public void logException() {
        System.out.println("除法出现异常......异常信息：{}");
    }
}

对MathCalculator类中的div()方法进行切入，因此在每一个通知方法上都写了com.tianxia.springannotation.aop.MathCalculator.*(…)"这样一串玩意，其实它就是切入点表达式，即指定在哪个方法切入。

如果切入点表达式都一样的情况下，可以抽取出一个公共的切入点表达式，就像下面这样：

/**
 * 日志切面
 * @author liqb
 * @date 2023-05-09 16:33
 **/
public class LogAspects {

    // 如果切入点表达式都一样的情况下，那么可以抽取出一个公共的切入点表达式
    @Pointcut("execution(public int com.tianxia.springannotation.aop.MathCalculator.*(..))")
    public void pointCut() {
        
    }
}

pointCut()方法就是抽取出来的一个公共的切入点表达式，其实该方法的方法名随便写啥都行，但是方法体中啥都别写

如何在每一个通知方法上引用这个公共的切入点表达式呢？

得分两种情况来讨论，第一种情况，如果是本类引用，那么可以像下面这样写：

/**
 * 日志切面
 * @author liqb
 * @date 2023-05-09 16:33
 **/
public class LogAspects {

    // 如果切入点表达式都一样的情况下，那么可以抽取出一个公共的切入点表达式
    @Pointcut("execution(public int com.tianxia.springannotation.aop.MathCalculator.*(..))")
    public void pointCut() {

    }

    // @Before：在目标方法（即div方法）运行之前切入
    @Before("pointCut()")
    public void logStart() {
        System.out.println("除法运行......@Before，参数列表是：{}");
    }
}

第二种情况，如果是外部类（即其他的切面类）引用，那么就得在通知注解中写方法的全名了，例如：

package com.tianxia.springannotation.aop;

import org.aspectj.lang.annotation.*;

/**
 * 日志切面
 * @author liqb
 * @date 2023-05-09 16:33
 **/
public class LogAspects {

    // 如果切入点表达式都一样的情况下，那么可以抽取出一个公共的切入点表达式
    @Pointcut("execution(public int com.tianxia.springannotation.aop.MathCalculator.*(..))")
    public void pointCut() {

    }

    // @Before：在目标方法（即div方法）运行之前切入
    @Before("com.tianxia.springannotation.aop.LogAspects.pointCut()")
    public void logStart() {
        System.out.println("除法运行......@Before，参数列表是：{}");
    }

    // 在目标方法（即div方法）结束时被调用
    @After("com.tianxia.springannotation.aop.LogAspects.pointCut()")
    public void logEnd() {
        System.out.println("除法结束......@After");
    }

    // 在目标方法（即div方法）正常返回了，有返回值，被调用
    @AfterReturning("com.tianxia.springannotation.aop.LogAspects.pointCut()")
    public void logReturn() {
        System.out.println("除法正常返回......@AfterReturning，运行结果是：{}");
    }

    // 在目标方法（即div方法）出现异常，被调用
    @AfterThrowing("com.tianxia.springannotation.aop.LogAspects.pointCut()")
    public void logException() {
        System.out.println("除法出现异常......异常信息：{}");
    }
}

必须告诉Spring哪个类是切面类，只需要给切面类上加上一个@Aspect注解即可

/**
 * 日志切面
 * @author liqb
 * @date 2023-05-09 16:33
 **/
@Aspect
public class LogAspects {
}

2.4.将目标类和切面类加入到IOC容器

在com.tianxia.springannotation.config包中，新建配置类MainConfigOfAOP，并使用@Configuration注解标注这是一个Spring的配置类，同时使用@EnableAspectJAutoProxy注解开启基于注解的AOP模式。在MainConfigOfAOP配置类中，使用@Bean注解将业务逻辑类（目标方法所在类）和切面类都加入到IOC容器中，如下所示：

package com.tianxia.springannotation.config;

import com.tianxia.springannotation.aop.LogAspects;
import com.tianxia.springannotation.aop.MathCalculator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * AOP配置类
 * @author liqb
 * @date 2023-05-09 16:57
 **/
@Configuration
@EnableAspectJAutoProxy
public class MainConfigOfAOP {

    /**
     * 将业务逻辑类（目标方法所在类）加入到容器中
     * @author liqb
     * @date 2023-05-09 16:58
     * @return
     */
    @Bean
    public MathCalculator calculator() {
        return new MathCalculator();
    }

    /**
     * 将切面类加入到容器中
     * @author liqb
     * @date 2023-05-09 16:58
     * @return
     */
    @Bean
    public LogAspects logAspects() {
        return new LogAspects();
    }
}

2.5.测试

运行测试方法方法，输出的结果信息如下所示：

package com.tianxia.springannotation;

import com.tianxia.springannotation.aop.MathCalculator;
import com.tianxia.springannotation.config.MainConfigOfAOP;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * aop测试类
 * @author liqb
 * @date 2023-05-09 17:03
 **/
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class AopTest {

    /**
     * 测试类
     * @author liqb
     * @date 2023-05-09 17:04
     */
    @Test
    public void test01() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);

        // 我们要使用Spring容器中的组件
        MathCalculator mathCalculator = applicationContext.getBean(MathCalculator.class);
        mathCalculator.div(1, 1);

        // 关闭容器
        applicationContext.close();
    }
}

在这里插入图片描述

并打印出了相关信息，但是并没有打印参数列表和运行结果

要想打印出参数列表和运行结果，就需要对LogAspects切面类中的方法进行优化，优化后的结果如下所示：

package com.tianxia.springannotation.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;

import java.util.Arrays;

/**
 * 日志切面
 * @author liqb
 * @date 2023-05-09 16:33
 **/
@Aspect
public class LogAspects {

    // 如果切入点表达式都一样的情况下，那么可以抽取出一个公共的切入点表达式
    @Pointcut("execution(public int com.tianxia.springannotation.aop.MathCalculator.*(..))")
    public void pointCut() {

    }

    // @Before：在目标方法（即div方法）运行之前切入
    @Before("pointCut()")
    public void logStart(JoinPoint joinPoint) {
        // System.out.println("除法运行......@Before，参数列表是：{}");

        Object[] args = joinPoint.getArgs(); // 拿到参数列表，即目标方法运行需要的参数列表
        System.out.println(joinPoint.getSignature().getName() + "运行......@Before，参数列表是：{" + Arrays.asList(args) + "}");
    }

    // 在目标方法（即div方法）结束时被调用
    @After("com.tianxia.springannotation.aop.LogAspects.pointCut()")
    public void logEnd(JoinPoint joinPoint) {
        // System.out.println("除法结束......@After");

        System.out.println(joinPoint.getSignature().getName() + "结束......@After");
    }

    // 在目标方法（即div方法）正常返回了，有返回值，被调用
    @AfterReturning(value = "com.tianxia.springannotation.aop.LogAspects.pointCut()", returning="result") // returning来指定我们这个方法的参数谁来封装返回值
    public void logReturn(JoinPoint joinPoint, Object result) { // 一定要注意：JoinPoint这个参数要写，一定不能写到后面，它必须出现在参数列表的第一位，否则Spring也是无法识别的，就会报错
        // System.out.println("除法正常返回......@AfterReturning，运行结果是：{}");

        System.out.println(joinPoint.getSignature().getName() + "正常返回......@AfterReturning，运行结果是：{" + result + "}");
    }

    // 在目标方法（即div方法）出现异常，被调用
    @AfterThrowing(value = "com.tianxia.springannotation.aop.LogAspects.pointCut()", throwing = "exception")
    public void logException(JoinPoint joinPoint, Exception exception) {
        System.out.println(joinPoint.getSignature().getName() + "出现异常......异常信息：{" + exception + "}");
    }
}

需要注意的是，JoinPoint参数一定要放在参数列表的第一位，否则Spring是无法识别的，那自然就会报错了

运行测试方法，输出结果如下所示：

在这里插入图片描述

3.小结

搭建AOP测试环境时，虽然步骤繁多，但是我们只要牢牢记住以下三点，就会无往而不利了

  1. 将切面类和业务逻辑组件（目标方法所在类）都加入到容器中，并且要告诉Spring哪个类是切面类（标注了@Aspect注解的那个类）
  2. 在切面类上的每个通知方法上标注通知注解，告诉Spring何时何地运行，当然最主要的是要写好切入点表达式，这个切入点表达式可以参照官方文档来写
  3. 开启基于注解的AOP模式，即加上@EnableAspectJAutoProxy注解，这是最关键的一点
怀梦
关注
专栏目录
Spring核心之AOP的两种实现方式
好记性不如烂笔头
03-13 481
前言 AOP是一种思想，并不是Spring独有的，所有符合AOP思想都可以看作AOP的实现。在进入Spring AOP之前，先对它的一些术语做一个了解，它们是构成Spring AOP的基本组成部分。 名称 说明 切面(Aspect) 切面是对象操作过程中的截面，实际上"切面"是一段程序代码，这段代码将被"植入"到程序本身的流程中去，所谓的"面向切面编程"正是指这个。 连接点...
spring-aop-jar
12-14
"spring-aop-jar"这个主题涉及到Spring框架中的核心组件之一——Spring AOP。这里我们将深入探讨Spring AOP、相关jar文件以及它们在实际开发中的作用。 首先，我们来看一下提供的文件： 1. aopalliance.jar：这是一...
Spring核心-AOP
ggggggzzzzz的博客
05-22 92
1.AOP概念2.AOP的相关术语3.AOP的作用4.基于注解的AOP实现-AspectJ注解
【Spring】AOP之面向切面编程
HR的博客
05-12 530
AOP之面向切面编程AOP概述AOP编程术语AspectJ 对 AOP 的实现@Before@AfterReturning@Around@AfterThrowing@After AOP概述 AOP（Aspect Orient Programming），面向切面编程。面向切面编程是从动态角度考虑程 序运行过程。 AOP 底层，就是采用动态代理模式实现的。采用了两种代理：JDK 的动态代理，与 CGLIB 的动态代理。 AOP 为 Aspect Oriented Programming 的缩写，意为
Spring核心特性—— AOP（面向切面编程）
战斧的博客
04-26 5074
我们曾经在谈到Spring 的Transactional 注解时提到了AOP，并言明了AOP是该注解实现的基础。但是说到底，还没有系统的介绍过AOP，讲Spring不提AOP总归是缺了点什么的。而且，相信大家在面试的时候也经历过不少AOP相关的提问，例如什么是SpringAop？Spring通知有哪些类型？动态代理的两种方式？本次我们就好好来讲讲
Spring3：AOP
weixin_34130389的博客
10-29 645
AOP AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对...
SpringBoot之Spring核心AOP详解
Young_深情不及里子的博客
11-09 2650
一篇万字文章带你从底层详细了解Spring的核心功能之一------AOP在SpringBoot中的的具体实现过程与简单应用，打牢基础同时助你在项目开发中提高效率！赶紧学起来吧~
Spring AOP 详解
2301_80035594的博客
10-19 2528
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
Spring核心AOP（面向切面编程）总结
热门推荐
冷血之心的博客
07-16 3万+
（尊重劳动成果，转载请注明出处：http://blog.csdn.net/qq_25827845/article/details/75208354冷血之心的博客） 目录 1、AOP概念： 2、AOP特点： 3、AOP底层实现： JDK动态代理实现： cglib动态代理实现： 代理方式的选择： 静态代理和动态代理的区别： 4、AOP原理 5、AOP操作术语： 6、AOP操作案例...
spring_aop.rar_spring_aop
09-19
1. **切面（Aspect）**：切面是Spring AOP的核心，它封装了系统中的关注点，比如日志记录就是一个关注点。一个切面可以包含多个通知（advice）和切点（pointcut）。 2. **通知（Advice）**：通知是在特定切点执行的...
spring-aop-5.1.0.RELEASE.jar
03-09
spring-**core**-4.3.6.RELEASE.jar ：包含spring框架基本的核心工具类，spring其他组件都要用到这个包里的类，其他组件的基本核心 spring-**beans**-4.3.6.RELEASE.jar：所有应用都要用到的jar包，它包含访问配置...
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
Spring AOP 是一种面向切面编程的技术，它允许我们在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行增强。在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态...
spring-boot aop
01-23
AOP的核心是切面（Aspect），它封装了跨越多个对象的行为或关注点，如日志记录。切点（Pointcut）定义了在何处应用切面，通常通过方法签名或注解来指定。通知（Advice）是切面实际执行的动作，例如在方法调用前后...
SpringMVC入门详解
ning的博客
11-02 549
SpringMVC是一个基于Java的实现了MVC设计模式的Web框架，它通过将Web层进行模块化，使得Web应用程序的开发变得更加灵活和可维护。简化开发：通过注解的方式简化了配置，减少了代码量。强大的集成能力：可以很容易地与其他Spring模块集成。灵活的配置：支持零配置启动，也支持通过XML或Java配置进行详细配置。可重用性高：可以轻松地将一个项目中的代码重用到另一个项目中。
在Springboot中更好的打印日志
最新发布
nullPoninter的博客
11-02 132
1
基于SSM+VUE历史车轮网站JAVA|VUE|Springboot计算机毕业设计源代码+数据库+LW文档+开题报告+答辩稿+部署教+代码讲解
卓越软件开发的博客
11-01 746
源代码+数据库+LW文档（1万字以上）+开题报告+答辩稿部署教程+代码讲解+代码时间修改教程。
SpringSession源码分析
lkr_lkr的博客
11-01 199
默认对常规Session的理解和使用，如何使用Set-Cookie。
spring 学习路线梳理(三)AOP
xiweihao的博客
11-02 466
通知类：定义一个类为切面类通知方法：需要在那个方法里面做增强需求描述：在每个实现方法执行前打印当前的系统时间连接点和切入点的理解： 在接口里面定义的方法是连接点，需要在哪些方法里面增强功能是切入点//定义实现类@Slf4j@Service@Autowired@Override!!@Override@Override@Component 将通知类交由spirng来管理@Aspect 将此类定义为切面类。
SpringBoot starter机制
路漫漫其修远兮，吾将上下而求索
10-30 270
在spring boot之前，想要在spring中集成redis，需要做的事情包括：（1）引入jar包：包括redis的jar包，redis依赖的jar包，相应的版本，与spring版本是否兼容等（2）在配置文件中配置连接地址、端口号等（3）以Jedis为例，增加增加JedisConnectionFactory、RedisTemplate 的bean初始化代码（4）使用RedisTemplate可以看到，集成过程比较复杂，而这些过程跟业务开发没有任何关系。
spring的核心aop详细
06-18
Spring AOP基于Java的动态代理机制，主要包含以下几个核心组件： 1. **切面（Aspect）**：AOP的核心概念，它是业务逻辑和横切关注点的结合。切面由一组通知（advice）组成，通知可以是前置通知（Before）、后置通知...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值