Spring AOP面向切面编程

Spring AOP面向切面编程

文章目录

  • [Spring AOP面向切面编程](#Spring AOP面向切面编程)
    • [1 面向切面编程思维(AOP)](#1 面向切面编程思维(AOP))
    • [2 Spring AOP框架介绍和关系梳理](#2 Spring AOP框架介绍和关系梳理)
    • [3 SpringAOP基于注解方式实现和细节](#3 SpringAOP基于注解方式实现和细节)
      • [3.1 Spring AOP底层技术组成](#3.1 Spring AOP底层技术组成)
      • [3.2 初步实现](#3.2 初步实现)
      • [3.3 获取通知细节信息](#3.3 获取通知细节信息)
      • [3.4 切点表达式](#3.4 切点表达式)
      • [3.5 重用(提取)切点表达式](#3.5 重用(提取)切点表达式)
      • [3.6 环绕通知](#3.6 环绕通知)
      • [3.7 切面优先级设置](#3.7 切面优先级设置)
    • [5 Spring AOP 对获取Bean的影响理解](#5 Spring AOP 对获取Bean的影响理解)

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 加入依赖

java 复制代码
<!-- 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 声明切面类

java 复制代码
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 配置类方式

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

3.3 获取通知细节信息

java 复制代码
/**
 * 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 对象获取外界调用目标方法时传入的实参列表组成的数组
java 复制代码
// @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属性获取目标方法的返回值!

java 复制代码
// @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属性获取目标方法抛出的异常对象

java 复制代码
// @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 切点表达式

java 复制代码
/**
 * 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 重用(提取)切点表达式

java 复制代码
/**
 * 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 结构,包括前面四种通知的所有功能。

java 复制代码
   /**
     * 环绕通知 需要在通知中 定义目标方法的执行
     * @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的影响理解

相关推荐
CoderIsArt40 分钟前
Redis的三种模式:主从模式,哨兵与集群模式
数据库·redis·缓存
paopaokaka_luck2 小时前
【360】基于springboot的志愿服务管理系统
java·spring boot·后端·spring·毕业设计
师太,答应老衲吧3 小时前
SQL实战训练之,力扣:2020. 无流量的帐户数(递归)
数据库·sql·leetcode
Yaml44 小时前
Spring Boot 与 Vue 共筑二手书籍交易卓越平台
java·spring boot·后端·mysql·spring·vue·二手书籍
Channing Lewis4 小时前
salesforce case可以新建一个roll up 字段,统计出这个case下的email数量吗
数据库·salesforce
aloha_7894 小时前
从零记录搭建一个干净的mybatis环境
java·笔记·spring·spring cloud·maven·mybatis·springboot
毕业设计制作和分享5 小时前
ssm《数据库系统原理》课程平台的设计与实现+vue
前端·数据库·vue.js·oracle·mybatis
ketil275 小时前
Redis - String 字符串
数据库·redis·缓存
Hsu_kk6 小时前
MySQL 批量删除海量数据的几种方法
数据库·mysql
编程学无止境6 小时前
第02章 MySQL环境搭建
数据库·mysql