专项攻克——AOP

已于 2023-04-06 12:17:59 修改
阅读量308 收藏
点赞数
分类专栏： java基础 框架基础 文章标签： java 开发语言 spring
于 2023-04-05 03:33:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18683559/article/details/129931538
版权

文章目录

  • 参考博客：AOP的使用（详细讲解）

  • 参考B站视频1

    5分钟精通SpringAOP-视频

  • 参考B站视频2

    史上最完整的AOP底层原理-视频

1 什么是AOP

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程
（1）面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而是的业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
（2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能
（3）使用登录的例子说明AOP
在这里插入图片描述

2 AOP作用、使用场景

应用场景：

  1. 拦截器、
  2. RPC接口统一日志打印、
  3. 接口入参数据校验、
  4. 权限控制、
  5. 监控方法运行时间、
  6. 缓存优化 （第一次调用查询数据库，将查询结果放入内存对象， 第二次调用， 直接从内存对象返回，不需要查询数据库 ）
  7. 接口限流（推荐wx文章：Redis 做接口限流，一个注解的事！）
  8. 多数据源处理（推荐wx文章：AOP多数据源动态切换）
  9. 事务管理 （调用方法前开启事务， 调用方法后提交关闭事务 ）

补充知识

  • 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
  • 切面（Aspect）：切面是一个类，其中包含了多个通知和切点。切面用于描述在哪些类、哪些方法的什么位置上执行哪些通知。切面是切点和通知的组合称谓，就是变相给组合起了个名字。
  • 切点（PointCut）：切点是一个表达式，用于描述哪些类的哪些方法会被拦截。通常情况下，切点会使用表达式语言（@execution、within、this 与 target、bean）来定义。在一个应用程序中，通常会有多个切点。（参考：AOP中常见的切点标志符）
  • 通知/增强（Advice）：通知是在切点处执行的代码。通知定义了在目标方法执行前、执行后或异常抛出时需要执行的代码。通知有多种类型。
  • 目标（Target）：被通知对象。
  • 代理（Proxy）：向目标对象应用通知之后创建的对象。
  • 连接点（JointPoint）：与切入点匹配的执行点。连接点可以说是切点的全集，切点是连接点的子集。。

举个例子，下面是一个AOP切面模型图，在某一个方法执行前后执行的一些操作，并且这些操作不会影响程序本身的运行。可以发现，在执行业务逻辑代码的前后，都需要做“验证参数、前置日志、后置日志”的相同操作。这些相同操作可以抽象出来，放在切面类里，在切面类里通过execution（切点）指定要在哪些业务逻辑（连接点）的前或后织入通知代码（advice）。
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

3 AOP底层实现原理

关于动态代理和静态代理的概念，推荐博客：静态代理和动态代理

AOP底层使用动态代理，有JDK动态代理和CGLIB动态代理

  • （1）动态代理有接口情况，==使用JDK动态代理，即创建接口实现类代理对象，增强类的方法。
    在这里插入图片描述

  • （2）动态代理没有接口情况，==使用CGLIB动态代理，即创建子类的代理对象，增强类的方法。
    在这里插入图片描述

代理设计模式：AOP的实现原理是动态代理，讲到动态代理之前先说一下代理模式， 代理模式是指给某一个对象提供一个代理，并由代理对象控制对原对象的引用。代理模式包含如下角色：

  • subject：抽象主题角色，是一个接口。该接口是对象和它的代理共用的接口;
  • RealSubject：真实主题角色，是实现抽象主题接口的类;
  • Proxy:代理角色，内部含有对真实对象RealSubject的引用，从而可以操作真实对象。

代理对象提供与真实对象相同的接口，以便代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
eg：一个班上的学生需要交作业，现在由班长代理交作业，那么班长就是代理，学生就是被代理的对象。

按照代理的创建时期，代理类可以分为静态代理和动态代理，他们的区别如下

  1. 静态代理：由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。
  2. 动态代理：动态代理是指java程序运行过程（程序已经启动正在运行中）由jvm生成代理类的class信息，该class信息生成后是直接处于内存中的，并没有写入磁盘保存起来，然后通过反射方式实例化代理类对象。因为代理类的class信息已经存在于内存中，所以可以通过反射方式实例化。

静态代理的缺点：静态代理在代码运行之前就已经存在代理类了，每一个代理对象都需要去建一个代理类去代理，当需要代理的对象有很多时，就需要创建很多的代理类，降低了程序可维护性。所以有了动态代理，动态代理可以很方便的对代理类的函数进行统一处理，而不用修改每个代理类中的方法。

3.1 AOP的JDK动态代理

3.1.1 Proxy类及InvocationHandler类

JDK动态代理，需要使用Proxy类的newProxyInstance 方法创建代理对象，该方法有三个参数：
(1) loader，类加载器
(2) interfaces，增强方法所在的类，这个类实现的接口，支持多个接口
(3) h，实现这个接口 InvocationHandler，创建代理对象，写增强的部分

public static Object newProxyInstance(ClassLoader loader,
                                        Class<?>[] interfaces,
                                        InvocationHandler h)

3.1.2 JDK动态代理代码案例

  1. 创建接口，定义方法

    public interface UserDao {
    public int add(int a,int b);
    public String update(String id);

}

  2. 创建接口实现类、方法

    public class UserDaoImpl implements UserDao{
    @Override
    public int add(int a,int b) {
        return a+b;
    }

    @Override
    public String update(String id) {
        return id;
    }

}

  3. 创建代理对象代码

    //创建代理对象（把手）
public class UserDaoProxy implements InvocationHandler {

    //把创建的是谁的代理对象，把谁传递过来
    //有参构造传递
    private Object obj;

    public UserDaoProxy(Object obj) {
        this.obj = obj;
    }

    //增强的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) 
    									throws Throwable {
         //方法之前
         System.out.println("方法之前执行..."+method.getName()+":传递的参数..."+ Arrays.toString(args));
         //被增强的方法执行
         Object res = method.invoke(obj, args);
         //方法之后
         System.out.println("方法之后执行..."+obj);
        return res;
    }
}

  4. 调用：使用 Proxy 类创建接口代理对象

    //使用 Proxy 类创建接口代理对象
public class JDKProxy {
    public static void main(String[] args) {

        //创建接口实现类代理对象
        Class[] interfaces = {UserDao.class};

        UserDaoImpl userDaoImpl = new UserDaoImpl();
        
        UserDao dao = (UserDao) Proxy.newProxyInstance(
        		JDKProxy.class.getClassLoader(), //JDK代理的类加载器
        		interfaces, //接口
        		new UserDaoProxy(userDaoImpl));//将接口实现类交给处理器增强

        int res = dao.add(1, 2);
        System.out.println("result:"+res);
    }

}

    在这里插入图片描述

3.2 AspectJ框架（CGLIB）【重点】

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

3.2.1 AspectJ是什么？

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

3.2.2 基于AspectJ实现AOP操作

（1）在项目工程里面引入AOP相关依赖
（2）基于xml配置文件实现
（3）基于注解方式实现

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.15.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.9</version>
        </dependency>

        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjtools</artifactId>
            <version>1.9.9</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>

3.2.3 补充知识——切点表达式execution

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

  • 语法结构：

    execution （【权限修饰符public private等】【返回类型 int long等】【类全路径】【方法名称】(【参数列表】)）

  • 举例

    1. 增强某方法，如com.jin.dao.UserDao类的add方法
      execution(* com.jin.dao.UserDao.add(..))
    2. 增强类的所有方法，如com.jin.dao.UserDao类的所有方法
      execution(* com.jin.dao.UserDao.*(..))
    3. 增强某包里的所有类的所有方法，如com.jin.dao包里所有类的所有方法
      	execution(* com.jin.dao.*.*(..))

3.2.4 AspectJ注解方式（CGLIB）-案例【重要】

  1. 进行通知的配置
    （1）方式一、在spring配置文件中，开启注解扫描；在spring配置文件中开启生成代理对象

    <?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
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
">
    <!--开启注解扫描-->
<context:component-scan base-package="com.jin.aopanno"></context:component-scan>
</beans>

<!--开启Aspect生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    （2）方式二、完全使用注解开发，创建配置类，不需要创建xml配置文件

    @ComponentScan(basePackages = {"com.jin.pojo"})
@Configuration
//默认EnableAspectJAutoProxy为false，True则使用CGLIB
@EnableAspectJAutoProxy(proxyTargetClass = true) 
public class SpringConfig {
}

    测试代码：

    @Test
    public void MyTest01(){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        User user = context.getBean("user", User.class);
        user.add();
    }

  2. 使用注解创建被增强类User类（目标对象）

    //被增强的类
@Component
public class User {
    public void add(){
        System.out.println("add ...");
    }

  3. 使用注解@Aspect创建增强类UserProxy类，在增加类的通知方法上添加通知类型注解@Before、@After、@AfterReturning、@AfterThrowing、@Around，并使用切点表达式指明代理的目标。

    补充知识

    • @Aspect 设置当前类为切面类
    • @Pointcut 使用当前方法名作为切入点引用名称，例如
      @Pointcut("execution(* *(..))")
public void pt() {
}
    • @Before 标注当前方法作为前置通知
    • @After 标注当前方法作为后置通知
    • @AfterReturning 标注当前方法作为返回后通知
    • @AfterThrowing 标注当前方法作为异常后通知
    • @Around 标注当前方法作为环绕通知

    增强类（切面）

    //增强类
/**
如果有多个增强类对同一个方法进行增强，可以通过
Order设置增强类优先级，数字类型值越小优先级越高
*/
@Component
@Aspect //@Aspect注解指明该类为代理对象
@Order(1)
public class UserProxy {
    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* com.jin.aopanno.User.add(..))")
    public void before(){
        System.out.println("before ...");
    }
    //返回之后的通知
    @AfterReturning(value = "execution(* com.jin.aopanno.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning ...");
    }
    //
    @After(value = "execution(* com.jin.aopanno.User.add(..))")
    public void after(){
        System.out.println("after ...");
    }
	//异常通知
    @AfterThrowing(value = "execution(* com.jin.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("AfterThrowing ...");
    }
    //？？
    @Around(value = "execution(* com.jin.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前 ...");
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后 ...");
    }
}

    在这里插入图片描述

6. AOP是如何运行的？

在这里插入图片描述

攻城有术
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring 入门案例——AOP
08-19
Spring AOP（面向切面编程）是Spring框架的重要组成部分，它提供了一种模块化和声明式的方式来实现横切关注点，如日志、事务管理、性能监控等。本入门案例将帮助你理解并掌握Spring AOP的基本概念和使用方法。 在...
Spring——aop
12-23
**Spring AOP 知识详解** 在Java开发领域，Spring框架是不可或缺的一部分，它提供了许多强大的功能，其中AOP（面向切面编程）是其重要特性之一。AOP允许开发者将关注点分离，使得业务逻辑代码与系统服务如日志、...
Spring AOP原理分析(六)-- AOP执行流程
weixiaohuai的博客
01-31 2970
目录 一、简介 二、AOP执行流程 三、总结 一、简介 在前面一篇文章中，我们介绍了 AOP 代理的创建过程，那么代理对象是创建出来了，在什么时候使用呢？通知方法又是在何处被调用了？ 带着这些问题，我们以前面的AOP示例代码，边调试边介绍AOP代理的方法的完整执行过程。 二、AOP执行流程 先回顾一下我们前面使用AOP的切面代码： // @Aspect：告诉Spring这是一个切面类 @Aspect @Component public class SimpleAspect { .
专项攻克——事务
军威兄的博客
03-31 703
事务、分布式事务攻克
专项攻克汇总——问题与解答
军威兄的博客
03-20 216
文章目录一、Java基础二、数据库三、Redis四、Spring、Mybatis五、微服务——zookeeper、JSF六、事务七、分布式job、分布式锁八、算法篇 一、Java基础 类加载机制 jvm内存模型、 jvm内存优化 垃圾回收：gc java集合：hashMap、线程安全 异常与错误 多线程 线程安全：Lock、reentrantLock、synchronized、volatile、CAS 锁：乐观锁、悲观锁 反射机制 自定义注解 二、数据库 三、Redis 四、Spring、Mybatis
基于WebGIS的车联网平台的研究与应用
热门推荐
门心叼龙的专栏
01-05 2万+
前言： 本文写于2014年2月，五年弹指一挥间，近期整理发表，本文出自门心叼龙的博客，属于原创类容，侵权必究。转载请注明出处。https://blog.csdn.net/geduo_83/article/details/85855412 1 绪论 3 1.1 课题研究背景及意义 3 1.1.1 课题研究背景 3 1.1.2 基于WebGIS的车联网平台应用介绍 3 1.2 论文的主要研...
Spring注解驱动开发第33讲——AOP原理总结
08-06
Spring注解驱动开发第33讲——AOP原理总结
SpringBoot学习笔记——AOP全局统一日志管理
12-21
【SpringBoot学习笔记——AOP全局统一日志管理】 在软件开发中，日志记录是一项至关重要的任务，它有助于追踪操作记录、系统监控以及满足审计需求。SpringBoot作为一个流行的Java微服务框架，提供了AOP（面向切面...
五、Spring源码分析——Spring Aop
08-11
《Spring AOP 源码分析》 在深入探讨Spring AOP之前，我们先要理解AOP（面向切面编程）的基本概念。AOP是一种编程范式，它将关注点分离，使得我们可以将横切关注点（如日志、事务管理、安全检查等）与业务逻辑解耦...
Integer装箱拆箱、参数传递
军威兄的博客
08-20 3358
（1）JAVA里除了8种基本类型传参数是值传递，其他的类对象传参数都是引用传递。 （2）Integer作为参数传递时引用传递。 举个栗子： public class test{ public void add3(Integer i){ System.out.println("i赋值前的地址:"+System.identityHashCode(i)); i=3...
java基础问题疑点总结
军威兄的博客
07-27 952
（1）static作用  类变量。static类变量，必须声明在构造方法和语句块之外；被所有对象所共享，无论一个类创建了多少个对象，类只拥有类变量的一份拷贝；静态变量在程序开始时创建，在程序结束时销毁；可以用类名或者对象名访问类变量  类方法。static类方法，不能操作实例变量，因为实例变量还没有被被加载；  static代码块。在类被初次加载时，执行顺序：父类的static代码块，子类的static代码块，父类的成员变量，父类的构造函数，子类的成员变量，子类的构造函数  对象的初始化流程如下：
java基础——类加载机制
军威兄的博客
03-06 819
java基础-类加载机制
next()与nextLine()
军威兄的博客
08-23 341
next() 在读取内容时，会过滤掉有效字符前面的无效字符，对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符，next()方法会自动将其过滤掉。 只有在读取到有效字符之后，next()方法才将其后的空格键、Tab键或Enter键等视为结束符。所以next()方法不能得到带空格的字符串。 nextLine() 方法字面上有扫描一整行的意思，它的结束符只能是Enter键，即next...
专项攻克——垃圾回收机制
军威兄的博客
03-21 310
专项攻克——垃圾回收机制
专项攻克——java异常与Error
军威兄的博客
03-22 252
专项攻克——java异常与error
mybatis的动态sql（从注解到xml的过渡学习）
军威兄的博客
09-27 246
学习背景： 之前一直是用mybatis的注解的方式写sql的，但是来到京东实习后，大家都是用的.xml的方式写sql，今天就学习一下如何用xml方式写sql。 主要参考博客： 1、mybatis中的.xml文件总结–mybatis的动态sql 2、Mybatis学习总结（五）——动态sql 文章目录为什么使用MyBatis？OGNL表达式？ 为什么使用MyBatis？ MyBatis 的强大特性之...
专项攻克——ThreadLocal全解
军威兄的博客
07-31 192
参考博客：ThreadLocal 用法通俗理解
位运算——应用详解
军威兄的博客
07-20 190
口诀 清零取反要用与：a & b = (1100) 某位置一可用或 若要取反和交换， 轻轻松松用异或 移位运算 1 要求两个运算分量都是整形，结果也是整形。 2 “<<” 左移：右边空出的位上补0，左边的位将从字头挤掉，其值相当于乘2。 3 ">>"右移：右边的位被挤掉。对于左边移出的空位，如果是正数则空位补0，若为负数，可能补0或补1，这取决于所用的计算机系统。...
Spring AOP——基于注解的AOP实现
最新发布
05-18
Spring AOP是Spring框架中的一个重要模块，它提供了面向切面编程（AOP）的支持。AOP是一种编程思想，它可以在不改变原有代码的情况下，通过在程序运行时动态地将代码“织入”到现有代码中，从而实现对原有代码的增强。 Spring AOP提供了基于注解的AOP实现，使得开发者可以通过注解的方式来定义切面、切点和通知等相关内容，从而简化了AOP的使用。 下面是一个基于注解的AOP实现的例子： 1. 定义切面类 ```java @Aspect @Component public class LogAspect { @Pointcut("@annotation(Log)") public void logPointcut() {} @Before("logPointcut()") public void beforeLog(JoinPoint joinPoint) { // 前置通知 System.out.println("执行方法：" + joinPoint.getSignature().getName()); } @AfterReturning("logPointcut()") public void afterLog(JoinPoint joinPoint) { // 后置通知 System.out.println("方法执行完成：" + joinPoint.getSignature().getName()); } @AfterThrowing(pointcut = "logPointcut()", throwing = "ex") public void afterThrowingLog(JoinPoint joinPoint, Exception ex) { // 异常通知 System.out.println("方法执行异常：" + joinPoint.getSignature().getName() + "，异常信息：" + ex.getMessage()); } } ``` 2. 定义业务逻辑类 ```java @Service public class UserService { @Log public void addUser(User user) { // 添加用户 System.out.println("添加用户：" + user.getName()); } @Log public void deleteUser(String userId) { // 删除用户 System.out.println("删除用户：" + userId); throw new RuntimeException("删除用户异常"); } } ``` 3. 在配置文件中开启AOP ```xml <aop:aspectj-autoproxy/> <context:component-scan base-package="com.example"/> ``` 在这个例子中，我们定义了一个切面类LogAspect，其中通过@Aspect注解定义了一个切面，通过@Pointcut注解定义了一个切点，通过@Before、@AfterReturning和@AfterThrowing注解分别定义了前置通知、后置通知和异常通知。 在业务逻辑类中，我们通过@Log注解标注了需要增强的方法。 最后，在配置文件中，我们通过<aop:aspectj-autoproxy/>开启了AOP功能，并通过<context:component-scan>扫描了指定包下的所有组件。 这样，当我们调用UserService中的方法时，就会触发LogAspect中定义的通知，从而实现对原有代码的增强。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

攻城有术

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值