Spring AOP面向切面编程

于 2024-06-05 10:01:07 发布
阅读量722 收藏 28
点赞数 16
分类专栏： JAVA框架小知识 文章标签： spring oracle 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49429082/article/details/139462936
版权

Spring AOP面向切面编程

文章目录

1 面向切面编程思维（AOP）

AOP思想主要的应用场景

AOP（面向切面编程）是一种编程范式，它通过将通用的横切关注点（如日志、事务、权限控制等）与业务逻辑分离，使得代码更加清晰、简洁、易于维护。AOP可以应用于各种场景，以下是一些常见的AOP应用场景：

  1. 日志记录：在系统中记录日志是非常重要的，可以使用AOP来实现日志记录的功能，可以在方法执行前、执行后或异常抛出时记录日志。
  2. 事务处理：在数据库操作中使用事务可以保证数据的一致性，可以使用AOP来实现事务处理的功能，可以在方法开始前开启事务，在方法执行完毕后提交或回滚事务。
  3. 安全控制：在系统中包含某些需要安全控制的操作，如登录、修改密码、授权等，可以使用AOP来实现安全控制的功能。可以在方法执行前进行权限判断，如果用户没有权限，则抛出异常或转向到错误页面，以防止未经授权的访问。
  4. 性能监控：在系统运行过程中，有时需要对某些方法的性能进行监控，以找到系统的瓶颈并进行优化。可以使用AOP来实现性能监控的功能，可以在方法执行前记录时间戳，在方法执行完毕后计算方法执行时间并输出到日志中。
  5. 异常处理：系统中可能出现各种异常情况，如空指针异常、数据库连接异常等，可以使用AOP来实现异常处理的功能，在方法执行过程中，如果出现异常，则进行异常处理（如记录日志、发送邮件等）。
  6. 缓存控制：在系统中有些数据可以缓存起来以提高访问速度，可以使用AOP来实现缓存控制的功能，可以在方法执行前查询缓存中是否有数据，如果有则返回，否则执行方法并将方法返回值存入缓存中。
  7. 动态代理：AOP的实现方式之一是通过动态代理，可以代理某个类的所有方法，用于实现各种功能。
    综上所述，AOP可以应用于各种场景，它的作用是将通用的横切关注点与业务逻辑分离，使得代码更加清晰、简洁、易于维护。

2 Spring AOP框架介绍和关系梳理

  1. AOP一种区别于OOP的编程思维，用来完善和解决OOP的非核心代码冗余和不方便统一维护问题！
  2. 代理技术（动态代理|静态代理）是实现AOP思维编程的具体技术，但是自己使用动态代理实现代码比较繁琐！
  3. Spring AOP框架，基于AOP编程思维，封装动态代理技术，简化动态代理技术实现的框架！SpringAOP内部帮助我们实现动态代理，我们只需写少量的配置，指定生效范围即可,即可完成面向切面思维编程的实现！

3 SpringAOP基于注解方式实现和细节

3.1 Spring AOP底层技术组成

3.2 初步实现

1 加入依赖

<!-- spring-aspects会帮我们传递过来aspectjweaver -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>6.0.6</version>
</dependency>

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

2 声明切面类

package com.atguigu.advice;

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

// @Aspect表示这个类是一个切面类
@Aspect
// @Component注解保证这个切面类能够放入IOC容器
@Component
public class LogAspect {
        
    // @Before注解：声明当前方法是前置通知方法
    // value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上
    @Before(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
    public void printLogBeforeCore() {
        System.out.println("[AOP前置通知] 方法开始了");
    }
    
    @AfterReturning(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
    public void printLogAfterSuccess() {
        System.out.println("[AOP返回通知] 方法成功返回了");
    }
    
    @AfterThrowing(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
    public void printLogAfterException() {
        System.out.println("[AOP异常通知] 方法抛异常了");
    }
    
    @After(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
    public void printLogFinallyEnd() {
        System.out.println("[AOP后置通知] 方法最终结束了");
    }
    
}

3 配置类方式

@Configuration
@ComponentScan(basePackages = "com.atguigu")
//作用等于 <aop:aspectj-autoproxy /> 配置类上开启 Aspectj注解支持!
@EnableAspectJAutoProxy
public class MyConfig {
}

3.3 获取通知细节信息

/**
 * 1.   定义方法 - 增强代码
 * 2.   使用注解指定对应的位置
 * 3.   配置切点表达式选中方法
 * 4.   切面和ioc的配置
 * 5.   开启aspectj注解的支持
 *
 * TODO:增强方法中获取目标方法信息
 *  1. 全部增强方法中，获取目标方法的信息（方法名，参数，访问修饰符，所属类的信息）
 *      (JoinPoint joinPoint)
 *      joinPoint包含目标方法的信息  import org.aspectj.lang.JoinPoint;
 *  2. 返回的结果 - 只在@AfterReturning中有效
 *      (Object 形参名) 形参名接收返回结果
 *      @AfterReturning(value = "execution(* com..impl.*.*(..))",returning = "形参名即可")
 *  3. 获取异常信息 - @AfterThrowing
 *      (Throwable 形参名) 形参名接收异常信息
 *      @AfterThrowing(value = "execution(* com..impl.*.*(..))",throwing = "形参名即可")
 */

JointPoint接口

需要获取方法签名、传入的实参等信息时，可以在通知方法声明JoinPoint类型的形参。

  • 要点1：JoinPoint 接口通过 getSignature() 方法获取目标方法的签名（方法声明时的完整信息）
  • 要点2：通过目标方法签名对象获取方法名
  • 要点3：通过 JoinPoint 对象获取外界调用目标方法时传入的实参列表组成的数组
// @Before注解标记前置通知方法
// value属性：切入点表达式，告诉Spring当前通知方法要套用到哪个目标方法上
// 在前置通知方法形参位置声明一个JoinPoint类型的参数，Spring就会将这个对象传入
// 根据JoinPoint对象就可以获取目标方法名称、实际参数列表
@Before(value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))")
public void printLogBeforeCore(JoinPoint joinPoint) {
    
    // 1.通过JoinPoint对象获取目标方法签名对象
    // 方法的签名：一个方法的全部声明信息
    Signature signature = joinPoint.getSignature();
    
    // 2.通过方法的签名对象获取目标方法的详细信息
    String methodName = signature.getName();
    System.out.println("methodName = " + methodName);
    
    //获取方法所属类的信息
    String simpleName = joinPoint.getTarget().getClass().getSimpleName();
    
    //获取访问修饰符
    int modifiers = signature.getModifiers();
    System.out.println("modifiers = " + modifiers);
    
    //获取方法名
    String name = joinPoint.getSignature().getName();
    
    String declaringTypeName = signature.getDeclaringTypeName();
    System.out.println("declaringTypeName = " + declaringTypeName);
    
    // 3.通过JoinPoint对象获取外界调用目标方法时传入的实参列表
    Object[] args = joinPoint.getArgs();
    
    // 4.由于数组直接打印看不到具体数据，所以转换为List集合
    List<Object> argList = Arrays.asList(args);
    
    System.out.println("[AOP前置通知] " + methodName + "方法开始了，参数列表：" + argList);
}

方法返回值

在返回通知中，通过 @AfterReturning注解的returning属性获取目标方法的返回值！

// @AfterReturning注解标记返回通知方法
// 在返回通知中获取目标方法返回值分两步：
// 第一步：在@AfterReturning注解中通过retur ning属性设置一个名称
// 第二步：使用returning属性设置的名称在通知方法中声明一个对应的形参
@AfterReturning(
        value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))",
        returning = "targetMethodReturnValue"
)
public void printLogAfterCoreSuccess(JoinPoint joinPoint, Object targetMethodReturnValue) {
    
    String methodName = joinPoint.getSignature().getName();
    
    System.out.println("[AOP返回通知] "+methodName+"方法成功结束了，返回值是：" + targetMethodReturnValue);
}

异常对象捕捉

在异常通知中，通过@AfterThrowing注解的throwing属性获取目标方法抛出的异常对象

// @AfterThrowing注解标记异常通知方法
// 在异常通知中获取目标方法抛出的异常分两步：
// 第一步：在@AfterThrowing注解中声明一个throwing属性设定形参名称
// 第二步：使用throwing属性指定的名称在通知方法声明形参，Spring会将目标方法抛出的异常对象从这里传给我们
@AfterThrowing(
        value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))",
        throwing = "targetMethodException"
)
public void printLogAfterCoreException(JoinPoint joinPoint, Throwable targetMethodException) {
    
    String methodName = joinPoint.getSignature().getName();
    
    System.out.println("[AOP异常通知] "+methodName+"方法抛异常了，异常类型是：" + targetMethodException.getClass().getName());
}

3.4 切点表达式

/**
 * TODO:切点表达式
 *  固定语法 execution(1 2 3.4.5(6))
 *  1. 访问修饰符
 *      public / private
 *  2. 方法的返回参数类型
 *      String int void
 *     如果不考虑访问修饰符和返回值 那么这两位整合成一起写 *
 *     如果要是不考虑 必须两个都不考虑 不能出现 * String
 *  3. 包的位置
 *      具体包：com.atguigu.service.impl
 *      单层模糊：com.atguigu.service.*  *单层模糊
 *      多层模糊：com..impl  ..是任意层的模糊
 *      细节：..不能开头
 *      例如 找所有impl包：com..impl  不能写..impl  写成:*..impl
 *   4. 类的名称
 *      具体：CalculatorPureImpl
 *      模糊：*
 *      部分模糊：*Impl 即以Impl结尾的类名
 *   5. 方法名 语法和类名一致
 *   6. (6)型参数列表
 *      没有参数:()
 *      有具体参数：(String) (String,int)有顺序要求
 *      模糊参数：(..)有没有参数都可以 有多个也可以
 *      部分模糊：(String..) String后面有没有无所谓
 *              (..int)     最后一个参数是int
 *              (String..int) 第一个是String 最后一个是int
 *   TODO:实战
 *      1.查询某包某类下，访问修饰符是公有，返回值是int的全部方法
 *          public int 包名.类名.*(..)
 *      2.查询某包下类中第一个参数是String的方法
 *          * 包名.*.*(String..)
 *      3.查询全部包下，无参数的方法！
 *          * *..*.*()
 *      4.查询com包下，以int参数类型结尾的方法
 *          * com..*.*(..int)
 *      5.查询指定包下，Service开头类的私有返回值int的无参数方法
 *          private int 包名.Service*.*()
 */

3.5 重用（提取）切点表达式

/**
 * TODO:切点表达式的提取和复用
 *      1. 当前类中提取
 *         定义一个空方法
 *         注解 @Pointcut()
 *         增强注解中引用切点表达式的方法即可    直接调用方法名
 *      2. 创建一个存储切点的类
 *          单独维护切点表达式
 *          其它类的切点方法 类的全限定符号 方法名()
 */

@Pointcut("execution(* com.atguigu.service.impl.*.*(..))")
public void pc(){}

//别的类中的切点表达式引用：包+类名+函数名 比如"com.atguigu.pointcut.MyPointCut.pc()"
@Before("pc()")
public void start(){
    System.out.println("方法开始了");
}

@After("pc()")
public void after(){
    System.out.println("方法结束了");
}

@AfterThrowing("pc()")
public void error(){
    System.out.println("方法报错了");
}

3.6 环绕通知

环绕通知对应整个 try…catch…finally 结构，包括前面四种通知的所有功能。

   /**
     * 环绕通知 需要在通知中 定义目标方法的执行
     * @param joinPoint 目标方法（获取目标方法信息 多了一个执行方法）
     * @return  目标方法的返回值
     */
// 使用@Around注解标明环绕通知方法
@Around(value = "com.atguigu.aop.aspect.AtguiguPointCut.transactionPointCut()")
public Object manageTransaction(
    
        // 通过在通知方法形参位置声明ProceedingJoinPoint类型的形参，
        // Spring会将这个类型的对象传给我们
        ProceedingJoinPoint joinPoint) {
    
    // 通过ProceedingJoinPoint对象获取外界调用目标方法时传入的实参数组
    Object[] args = joinPoint.getArgs();
    
    // 通过ProceedingJoinPoint对象获取目标方法的签名对象
    Signature signature = joinPoint.getSignature();
    
    // 通过签名对象获取目标方法的方法名
    String methodName = signature.getName();
    
    // 声明变量用来存储目标方法的返回值
    Object targetMethodReturnValue = null;
    
    try {
    
        // 在目标方法执行前：开启事务（模拟）
        log.debug("[AOP 环绕通知] 开启事务，方法名：" + methodName + "，参数列表：" + Arrays.asList(args));
    
        // 过ProceedingJoinPoint对象调用目标方法
        // 目标方法的返回值一定要返回给外界调用者
        targetMethodReturnValue = joinPoint.proceed(args);
    
        // 在目标方法成功返回后：提交事务（模拟）
        log.debug("[AOP 环绕通知] 提交事务，方法名：" + methodName + "，方法返回值：" + targetMethodReturnValue);
    
    }catch (Throwable e){
    
        // 在目标方法抛异常后：回滚事务（模拟）
        log.debug("[AOP 环绕通知] 回滚事务，方法名：" + methodName + "，异常：" + e.getClass().getName());
    
    }finally {
    
        // 在目标方法最终结束后：释放数据库连接
        log.debug("[AOP 环绕通知] 释放数据库连接，方法名：" + methodName);
    
    }
    
    return targetMethodReturnValue;
}

3.7 切面优先级设置

相同目标方法上同时存在多个切面时，切面的优先级控制切面的内外嵌套顺序。

  • 优先级高的切面：外面
  • 优先级低的切面：里面

使用 @Order 注解可以控制切面的优先级：

  • @Order(较小的数)：优先级高
  • @Order(较大的数)：优先级低

5 Spring AOP 对获取Bean的影响理解

小小低头哥
关注
  • 16
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Aop的基础思维导图
06-16
刚学习的Spring Aop的一些基础知识的总结，有需要的可以看一下。
面向切面编程思维（AOP）
YingHuaBuRuTa的博客
03-11 896
Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。
简单介绍aop思想
caoPengFlying的博客
12-24 1031
什么是aop？ aop(Aspect Oriented Programming) 即面向切面编程。aop是一种编程思想，比如过滤器和拦截器。 解决的问题： 面向对象的特点是，封装、继承和多态。虽然方便了我们对类的使用，但是会多了一些重复代码，比如在servlet中。每个servlet都要设置编码问题，那么一般情况下有多少个servlet类就要写多少个解决编码的代码。增加了很多的重复代码。有
AOP思维导图
Big Bird's blogs
03-22 316
这是AOP的UML图 想看源码的同学请访问：https://download.csdn.net/download/ruren1/11049415
Spring的AOP思想的全面讲解（包含概念、注解和xml两种方式的实现）_chenjie的博客
chenjie的博客
08-12 2万+
一、Spring的AOP AOP的思想：是Aspect oritention programming面想切面编程的简写。把一个个横切关注点（零散存在于业务方法中的功能代码）放进某一个模块中去，我们称这个模块为一个切面。每一个切面都能影响业务的某一个功能，切面的目的就是为了增强。 AOP的目的：AOP能将与业务无关、但是又为业务模块所共同调用的逻辑或其他内容进行封装；减少代码重复率，降低模块之间的耦合度，提高后期的可维护性。 AOP的优势：降低模块的耦合度、让系统更容易扩展、提高后期可维护度。换句话说就是，
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
Spring 面向切面编程AOP实现详解
08-25
Spring 面向切面编程AOP实现详解 面向切面编程（AOP）是一种编程技术，旨在将横切关注点从业务逻辑中分离出来，提高系统的可扩展性和可维护性。Spring 作为一个流行的 Java 框架，提供了完备的 AOP 实现机制。 1. ...
16.2 Spring框架-AOP面向切面编程
最新发布
04-12
面向切面编程（AOP，Aspect Oriented Programming）是Spring框架中的一个重要组成部分，它提供了一种模块化和声明式的方式来处理程序中的横切关注点，如日志、事务管理、性能监控等。在传统的OOP（面向对象编程）中...
SpringBoot整合aop面向切面编程过程解析
08-24
SpringBoot整合AOP面向切面编程过程解析 AOP（Aspect Oriented Programming），即面向切面编程，是一种编程技术，通过预编译方式和运行期动态代理实现程序功能的统一维护。AOP是Spring框架中的一个重要内容，它通过...
Spring4AOP 面向切面编程实例之方法拦截
10-13
Spring4AOP 面向切面编程实例之方法拦截实例 一下利用Spring4的最后一个版本Spring4.3.9，实现简单的方法拦截实例。 Eclipse 建立java工程,导入必要的jar包，工程目录如下:
AOP_JointPoint的基本知识及常用方法
weixin_38446891的博客
10-09 5759
常用方法 JoinPoint 对象 JoinPoint对象封装了SpringAop中切面方法的信息,在切面方法中添加JoinPoint参数,就可以获取到封装了该方法信息的JoinPoint对象. 1、常用api 方法名 功能 Signature getSignature(); 获取封装了署名信息的对象,在该对象中可以获取到目标方法名,所属类的Class等信息 Object[] getArgs(); 获取传入目标方法的参数对象 Object getTarget(); 获取被代理的对象
获取通知方法参数、返回值、异常等细节信息
Kaiser__的博客
03-09 501
在异常通知中，通过@AfterThrowing注解的throwing属性获取目标方法抛出的异常对象。需要获取方法签名、传入的实参等信息时，可以在通知方法声明JoinPoint类型的形参。注解的returning属性获取目标方法的返回值！步骤与获取方法返回值类似。
JoIntPoint常用方法
Tssit的个人博客
04-28 5085
在常见的切面中，常用的参数有：JointPoint和ProceedingJoinPoint，其中ProceedingJoinPoint继承JointPoint，ProceedingJoinPoint用在@Arround注解的方法参数里，下面分开谈 1.JointPoint的常用方法 public void invoke(JoinPoint joinPoint) throws Throwab...
SpringAOP中的JointPoint和ProceedingJoinPoint使用总结
huluwa10526的博客
12-09 4552
一、Joint Point JointPoint是程序运行过程中可识别的点，这个点可以用来作为AOP切入点。JointPoint对象则包含了和切入相关的很多信息。比如切入点的对象，方法，属性等。我们可以通过反射的方式获取这些点的状态和信息，用于追踪tracing和记录logging应用信息。 二、Pointcut pointcut 是一种程序结构和规则，它用于选取join point并收集这些point的上下文信息。 pointcut通常包含了一系列的Joint Point，我们可以通过pointcut来同
Spring思维导图，让Spring不再难懂（aop篇）
weixin_33805992的博客
08-07 302
2019独角兽企业重金招聘Python工程师标准>>> ...
轻松理解AOP(面向切面编程)
热门推荐
登高而望远
02-24 3万+
Spring如此流行，当我第一次接触Spring的时候，到网上看了一些文章，都讲得神乎其乎，最后我篇也没看懂，我当时就是认为这个东西一定很高深，于是我就遇到做WEB开发的人就会打听一下。得到最多的一个回答就是“Spring是一个框架”，然后我就会问框架是什么，但都没有一种说法不让我感觉玄乎乎的，同时也没有听懂，于是，我更感觉Spring很神了，这可能叫做朦胧美。还有一种说法就是“Spring两个首
如何运用Aop切面思维进行编程
纯情呆萌大宝剑
09-27 126
看过七月老师的文章，对AOP切面编程有了一些自我运用 什么是AOP切面编程 AOP为Aspect Oriented Programming的缩写，意为：面向切面编程 通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术 说到AOP，就会提起OOP（面向对象编程） AOP是OOP技术的延续，AOP、OOP在字面上虽然非常类似，但却是面向不同领域的两种设计思想。OOP（面向对象编程）针对业务...
Spring AOP（一）知识点及思维导图
Sadlay的博客
10-25 4125
Spring AOP（一）思维导图 Spring Aop思维导图 Spring Aop目录 Spring AOP（一）思维导图 Spring AOP（二）约定编程 Spring AOP（三）AOP概念 Spring AOP（四）AOP的引入 Spring AOP（五）AOP通知获取参数 Spring AOP（六）AOP代理jdk和cglib Spring AOP（七）AOP多切面 ...
spring aop面向切面编程
08-15
对的，Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一个重要特性。它允许开发者通过在应用程序中定义横切关注点（cross-cutting concerns），将这些关注点与核心业务逻辑分离开来。 在传统的面向对象编程中，我们通常将核心业务逻辑集中在一个或多个类中，然后通过在这些类中调用其他类或方法来实现特定功能。这样做的问题是，横切关注点（如日志记录、事务管理、安全检查等）会被散布在各个类和方法中，导致代码的重复性和难以维护性。 而使用Spring AOP，我们可以通过定义切面（Aspect）来集中处理这些横切关注点。切面是一个模块化单元，它包含了一组通知（Advice），以及定义了切入点（Pointcut）的规则。通知定义了在切入点执行前、执行后、抛出异常时等不同时间点要执行的逻辑。 通过将切面与核心业务逻辑进行织入（Weaving），即将切面的逻辑插入到核心业务逻辑中，我们可以实现横切关注点的功能，并且不需要修改原有的业务逻辑代码。 总结来说，Spring AOP提供了一种解耦横切关注点与核心业务逻辑的方式，使得应用程序的代码更加清晰、模块化，同时也提高了代码的可重用性和可维护性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值