第五章SpringFramework之AOP

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6

文章目录

AOP概念及相关术语

概述

AOPAspect Oriented Programming是一种设计思想是软件设计领域中的面向切面编程它是面向对象编程的一种补充和完善它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。

  • 能将哪些与核心业务无关的却为业务模块所共同调用的逻辑或者责任事务管理日志管理权限控制等封装起来这些是不能依靠面对对象的思想进行封装复用的便于减少系统的重复代码降低模块间的耦合度

比如用户获奖权限的效验没学 AOP 之前我们所有需要判断用户获奖权限的页面中的方法都要各自实现或调用用户验证的方法然而有了 AOP 之后我们只需要在某一处配置一下所有需要判断用户中将权限页面中的方法就全部可以实现用户用户中将权限验证了不再需要每个方法中都写相同的用户登录验证了。

img

为什要用 AOP

为什要用 AOP想象一个场景我们在做后台系统时除了登录和注册等几个功能不需要做用户登录验证之外其他几乎所有页面调用的前端控制器 Controller都需要先验证用户登录的状态那这个时候我们要怎么处理呢

我们之前的处理方式是每个 Controller 都要写一遍用户登录验证然而当你的功能越来越多那么你要写的登录验证也越来越多而这些方法又是相同的这么多的方法就会代码修改和维护的成本。那有没有简单的处理方案呢答案是有的对于这种功能统一且使用的地方较多的功能就可以考虑 AOP来统一处理了。在不惊动原始设计的基础上进行功能增强
除了统一的用户登录判断之外AOP 还可以实现

  • 统一日志记录
  • 统一方法执行时间统计
  • 统一的返回格式设置
  • 统一的异常处理
  • 事务的开启和提交等

也就是说使用 AOP 可以扩充多个对象的某个能力所以 AOP 可以说是 OOPObject OrientedProgramming面向对象编程的补充和完善。

相关术语

横切关注点

从每个方法中抽取出来的同一类非核心业务。在同一个项目中我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。

  • 比如我们前面举例子的计算机加减乘除是核心业务其中的日志功能是非核心功能也就是横切关注点

这个概念不是语法层面天然存在的而是根据附加功能的逻辑上的需要有十个附加功能就有十个横切关注点。

关注点和横切关注点的区别

  • 关注点是应用中一个模块的行为一个关注点可能会被定义成一个我们想实现的一个功能
  • 横切关注点也是一个关注点此关注点是整个应用都会使用的功能并影响整个应用比如日志几乎每个模块都需要的功能因此属于横切关注点

Advice通知

每一个横切关注点上要做的事情都需要写一个方法来实现这样的方法就叫通知方法。

  • 通知也就是在切入点执行的操作也就是我们的抽取出来的公共业务也就是程序执行时通过SpringAOP框架触发的代码段

    • 在目标对象中被称为横切关注点 在切面中被封装成方法称为通知方法

  • @ before 前置通知在被代理的目标方法前执行

  • @after-returning 返回通知在被代理的目标方法成功结束后执行寿终正寝

  • @after-throwing 异常通知在被代理的目标方法异常结束后执行死于非命

  • @after 后置通知在被代理的目标方法最终结束后执行盖棺定论

  • @around 环绕通知使用try…catch…finally结构围绕整个被代理的目标方法包括上面四种通知对应的所有位置

image-20230117223945790

Join Point连接点

这也是一个纯逻辑概念不是语法定义的。

  • 连接点代表程序的某个位置在这个位置能够插入切面Aspect的一个点
    • 也就是我们抽取横切关注点的地方因为我们要抽取出来还是要套回去的
    • 程序执行过程中的任意位置粒度为执行方法抛出异常设置变量等
  • Spring AOP中仅支持方法的这一个连接点所以在使用Spring AOP的时候不太提这个概念
  • 把方法排成一排每一个横切位置看成x轴方向把方法从上到下执行的顺序看成y轴x轴和y轴的交叉点就是连接点。

image-20230117231402242

Point CUT 切入点

  • 其实就是一个表达式切入点定位一个或者一组连接点通知将会在这些位置执行可以通过表达式或者匹配方式指明切入点

​ 定位连接点的方式。

每个类的方法中都包含多个连接点所以连接点是类中客观存在的事物从逻辑上来说。
如果把连接点看作数据库中的记录那么切入点就是查询记录的 SQL 语句。Spring 的 AOP 技术可以通过切入点定位到特定的连接点。

切点通过org.springframework.aop.Pointcut 接口进行描述它使用类和方法作为连接点的查询条件。

  • 也就是说哪些方法被切入,也就是哪些方法需要添加公共业务进行功能增强

切面

封装通知方法横切关注点的类

  • 逻辑概念指的就是放置各种公共业务的以及公共业务如何和具体的业务产生关系的配置的地方
  • 封装通知方法的类
  • 切面Aspect由切入点Pointcut和通知Advice组成它既包含了横切逻辑我们的通知的定义也包括了切入点的定义。

image-20230117224841331

目标

被代理的目标对象。

代理

向目标对象应用通知之后创建的代理对象。

作用

  • 简化代码把方法中固定位置的重复的代码抽取出来让被抽取的方法更专注于自己的核心功能提高内聚性。
  • 代码增强把特定的功能封装到切面类中看哪里有需要就往上套被套用了切面逻辑的方法就被切面给增强了。

基于注解的SpringAOP

AOP 是一种思想而 Spring AOP 是一个框架提供了一种对 AOP 思想的实现

  • Spring下的AOP,Java AOP做的比较早的AspectJ库是相当于做的比较早Spring的AOP的在使用方式的时候很多也延续了AspectJ的方式技术说明

image-20230117200718347

Spring AOP是基于动态代理的

  • 如果它要代理的对象实现了某个接口那么Spring AOP就会使用JDK的动态代理去创建代理对象

    • 因为这个技术要求代理对象和目标对象实现同样的接口兄弟两个拜把子模式。

  • 而对没有实现接口的对象就无法使用JDK的动态代理 转而使用CGLIB动态代理生成一个被代理对象子类来作为代理

    • 通过继承被代理的目标类认干爹模式)实现代理所以不需要目标类实现接口

  • AspectJ本质上是静态代理将代理逻辑“织入”被代理的目标类编译得到的字节码文件所以最终效果是动态的。weaver就是织入器。

    • Spring只是借用了AspectJ中的注解

img

  • Aspectl是Java的AOP领域的领头羊所以它的方案基本就称为Java AOP的标准存在了所以AspectJ定义了一组表达式的语法来描述Pointcut切入点,所以Spring AOP也使用这种表达式Spring AOP和AspectJ也是一种AOP框架之间其实是没有关系的
  • 就像我们很多聊天软件都采用了这种聊天框

准备工作

在IOC所需依赖基础上再加入下面依赖即可

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

准备被代理的目标资源

接口

public interface Calculator {

    int add(int i, int j);

    int sub(int i, int j);

    int mul(int i, int j);

    int div(int i, int j);

}

实现类

@Component
public class CalculatorImpl implements Calculator {
    @Override
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("方法内部result"+result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("方法内部result"+result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("方法内部result"+result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        System.out.println("方法内部result"+result);
        return result;
    }
}

对应的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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--
        AOP的注意事项
        切面类和目标类都需要交给IOC容器管理
        切面类必须通过@Aspect注解标识为一个切面
        在Spring的配置文件中设置<aop:aspectj-autoproxy />开启基于注解的AOP
    -->
    <context:component-scan base-package="com.lsc.spring.aop.annotation"></context:component-scan>

    <!--开启基于注解的AOP-->
    <aop:aspectj-autoproxy />
</beans>
  • 我们的Spring AOP功能还是基于我们的IOC容器IOC容器是我们最核心的功能
    • 我们的切面类和目标类都需要交给我们的IOC容器进行管理
  • 需要在xml中开启注解AOP的功能

切入点表达式语法

作用

image-20230118125533597

语法细节

  • 用*号代替“权限修饰符”和“返回值”部分表示“权限修饰符”和“返回值”不限

  • 在包名的部分一个“*”号只能代表包的层次结构中的一层表示这一层是任意的。

    • 例如*.Hello匹配com.Hello不匹配com.lsc.Hello
    • 在包名的部分使用“*…”表示包名任意、包的层次深度任意

  • 在类名的部分类名部分整体用*号代替表示类名任意

    • 在类名的部分可以使用*号代替类名的一部分
      • 例如*Service匹配所有名称以Service结尾的类或接口

  • 在方法名部分可以使用*号表示方法名任意

    • 在方法名部分可以使用*号代替方法名的一部分
      • 例如*Operation匹配所有方法名以Operation结尾的方法

  • 在方法参数列表部分使用(…)表示参数列表任意

    • 在方法参数列表部分使用(int,…)表示参数列表以一个int类型的参数开头
    • 在方法参数列表部分基本数据类型和对应的包装类型是不一样的
      • 切入点表达式中使用 int 和实际方法中 Integer 是不匹配的

  • 在方法返回值部分如果想要明确指定一个返回值类型那么必须同时写明权限修饰符

    • 例如execution(public int …Service.*(…, int)) 正确
    • 例如execution(* int …Service.*(…, int)) 错误

image-20230118125615330

AspectJ 支持三种通配符

  • *匹配任意字符只匹配一个元素包类或方法方法参数。
  • … 匹配任意字符可以匹配多个元素 在表示类时必须和 * 联合使用。
  • +: 表示按照类型匹配指定类的所有类必须跟在类名后面如 com.cad.Car+ ,表示继承该类的所有子类包括本身

重用切入点表达式

声明

@Pointcut("execution(* com.atguigu.aop.annotation.*.*(..))")
public void pointCut(){}

在同一个切面中使用

@Before("pointCut()")
public void beforeMethod(JoinPoint joinPoint){
	String methodName = joinPoint.getSignature().getName();
	String args = Arrays.toString(joinPoint.getArgs());
	System.out.println("Logger-->前置通知方法名"+methodName+"参数"+args);
}

在不同切面中使用

@Before("com.atguigu.aop.CommonPointCut.pointCut()")
public void beforeMethod(JoinPoint joinPoint){
	String methodName = joinPoint.getSignature().getName();
	String args = Arrays.toString(joinPoint.getArgs());
	System.out.println("Logger-->前置通知方法名"+methodName+"参数"+args);
}

对应的切面

前置通知

  • 前置通知使用@Before注解标识在被代理的目标方法前执行
@Component//保证这个切面类能够放入IOC容器
@Aspect//将当前组件标识为切面
public class LoggerAspect {
    @Pointcut("execution(* com.lsc.spring.aop.annotation.CalculatorImpl.*(..))")
    public void pointCut(){}
    //@Before("execution(public int com.lsc.spring.aop.annotation.CalculatorImpl.add(int, int))")
    //@Before("execution(* com.lsc.spring.aop.annotation.CalculatorImpl.*(..))")
    @Before("pointCut()")
    public void beforeAdviceMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature=joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect方法"+signature.getName()+"参数"+ Arrays.toString(args));
    }
}

测试

public class Test {
    public static void main(String[] args) {
        ApplicationContext ioc=new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator bean = ioc.getBean(Calculator.class);
        bean.add(1,2);
    }
}
//输出结果
LoggerAspect方法add参数[1, 2]
方法内部result3

返回通知

  • @after-returning 返回通知在被代理的目标方法成功结束后执行寿终正寝

测试

  @AfterReturning(value = "execution(* com.lsc.spring.aop.annotation.CalculatorImpl.*(..))",
    returning = "result")
    public void afterReturnMethod(JoinPoint joinPoint,Object result){
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect方法"+signature.getName()+"参数"+ Arrays.toString(args)+
                "结果为"+result);

    }
//结果    
方法内部result3
LoggerAspect方法add参数[1, 2]结果为3
  • returning = “result”,将方法返回的结果存储到result

异常通知

  • 在被代理的目标方法异常结束后执行死于非命
  @AfterThrowing(value = "pointCut()" ,throwing = "ex")
    public void afterThrowMethod(JoinPoint joinPoint,Exception ex){
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect方法"+signature.getName()+"参数"+ Arrays.toString(args)+
                "异常为"+ex);
    }
  • throwing表示发生的异常类型
public class Test {
    public static void main(String[] args) {
        ApplicationContext ioc=new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator bean = ioc.getBean(Calculator.class);
        bean.div(1,0 );//1/0会爆出异常
    }
}
LoggerAspect方法div参数[1, 0]异常为java.lang.ArithmeticException: / by zero

后置通知

  • 后置通知在被代理的目标方法最终结束后执行盖棺定论类似我们在finally里面的语句
public class Test {
    public static void main(String[] args) {
        ApplicationContext ioc=new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator bean = ioc.getBean(Calculator.class);
        bean.div(1,0 );
    }
}
//输出结果
Logger-->后置通知方法名div
  • 虽然报了异常但是还是会输出
    • 不管是正常结束还是异常结束都会执行

环绕通知

  • 使用try…catch…finally结构围绕整个被代理的目标方法能用一个环绕通知实现上面四个类型
 @Around("pointCut()")
    public Object aroundMethod(ProceedingJoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        String args = Arrays.toString(joinPoint.getArgs());
        Object result = null;
        try {
            System.out.println("环绕通知-->目标对象方法执行之前——>这个位置类似@before");
            //目标对象连接点方法的执行
            result = joinPoint.proceed();
            System.out.println("环绕通知-->目标对象方法返回值之后——>这个位置类似@afterReturning");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("环绕通知-->目标对象方法出现异常时——>这个位置类似@afterThrowing");
        } finally {
            System.out.println("环绕通知-->目标对象方法执行完毕——>这个位置类似@after");
        }
        return result;
    }

测试

public class Test {
    public static void main(String[] args) {
        ApplicationContext ioc=new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator bean = ioc.getBean(Calculator.class);
        bean.add(1,2);
    }
}
//输出结果
环绕通知-->目标对象方法执行之前——>这个位置类似@before
方法内部result3
环绕通知-->目标对象方法返回值之后——>这个位置类似@afterReturning
环绕通知-->目标对象方法执行完毕——>这个位置类似@after

切面的优先级

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

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

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

  • @Order(较小的数)优先级高
  • @Order(较大的数)优先级低
  • 默认是int的最大值

ValidateAspect切面

@Component
@Order(1)
@Aspect
public class ValidateAspect {
    @Pointcut("execution(* com.lsc.spring.aop.annotation.CalculatorImpl.*(..))")
    public void pointCut(){}
    @Before("pointCut()")
    public void beforeAdviceMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature=joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("ValidateAspect方法"+signature.getName()+"参数"+ Arrays.toString(args));
    }
    @After("pointCut()")
    public void afterMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("ValidateAspect-->后置通知方法名"+methodName);
    }
}

LoggerAspect切面

@Component
@Aspect//将当前组件标识为切面
public class LoggerAspect {
    @Pointcut("execution(* com.lsc.spring.aop.annotation.CalculatorImpl.*(..))")
    public void pointCut(){}
    @Before("pointCut()")
    public void beforeAdviceMethod(JoinPoint joinPoint){
        //获取连接点所对应方法的签名信息
        Signature signature=joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect方法"+signature.getName()+"参数"+ Arrays.toString(args));
    }

    @After("pointCut()")
    public void afterMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("LoggerAspect-->后置通知方法名"+methodName);
    }
}

测试

public class Test {
    public static void main(String[] args) {
        ApplicationContext ioc=new ClassPathXmlApplicationContext("aop-annotation.xml");
        Calculator bean = ioc.getBean(Calculator.class);
        bean.add(1,2);
    }
}
//输出结果
ValidateAspect方法add参数[1, 2]
LoggerAspect方法add参数[1, 2]
方法内部result3
LoggerAspect-->后置通知方法名add
ValidateAspect-->后置通知方法名add

总结Spring AOP 的实现步骤

  1. 添加 Spring AOP 框架支持。导入相应的jar包
  2. 定义接口和相应的实现类也就是我们的程序程序中的方法可以作为切入点进行功能增强
  3. 定义通知类存放我们的切面@Aspect修饰类并且让这个通知类被SpringIoc容器管理生产对应的bean我们的被切入的类也需要被SpringIoc容器管理
  4. 在通知类切面定义切入点用PointCut()进行匹配对应的连接点
  5. 进行我们的通知的定义具体的增强功能的逻辑用方法的形式实现然后跟对应的切入点建立对应的联系 @Before之类
  6. 开启对Aop注解驱动支持 (SpringBoot会自动帮我们做这些配置)
阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6
标签: Spring
返回列表

上一篇：ZooKeeper-分布式锁实现

下一篇：【CSDN2022年度总结】你不停的翻找答案，只不过是在找一个替你讲故事的人——Oracle DBA转型大数据开发DBA的自述

“第五章SpringFramework之AOP” 的相关文章

学习笔记——SpringMVC文件上传与下载1年前 (2023-02-02)
【Spring6源码・IOC】Bean的初始化 - 终结篇1年前 (2023-02-02)
后台交互—springboot+mybatis整合小程序（源码演示）_小程序springboot交互1年前 (2023-02-02)
springcloud3 Nacos的服务搭建和生产消费案例1年前 (2023-02-02)
Springboot整合log4j2（按级别拆分）1年前 (2023-02-02)
SpringCloud-Netflix学习笔记01——SpringCloud入门1年前 (2023-02-02)
SpringMVC中解决POST和GET请求中文乱码问题1年前 (2023-02-02)
Spring数据校验Validation详解，JSR-330使用，1年前 (2023-02-02)
熟悉Spring框架？Spring容器使用流程，注解 你真的会吗？（让你一下通透~）1年前 (2023-02-02)
SpringBoot的filter过滤器1年前 (2023-02-02)

阿里云国际版