Spring AOP—深入动态代理 万字详解（通俗易懂）

目录

一、前言

二、动态代理快速入门

        1.为什么需要动态代理？ : 

        2.动态代理使用案例：

        3.动态代理的灵活性 : 

三、深入动态代理

        1.需求 : 

        2.实现 : 

            2.1 接口和实现类

            2.2 提供代理对象的类

            2.3 测试类

        3.引出AOP : 

四、总结

一、前言

  • 第四节内容，up打算和大家分享Spring 动态代理 相关的内容；动态代理本质上是Spring AOP的一个前置的引入内容，一个AOP开篇之作，但它却相当重要，且本身难度较大。
  • 注意事项——①代码中的注释也很重要；②不要眼高手低，自己跟着过一遍才真正有收获；③点击文章的侧边栏目录或者文章开头的目录可以进行跳转。
  • 良工不示人以朴，up所有文章都会适时补充完善。大家如果有问题都可以在评论区进行交流或者私信up。感谢阅读！

二、动态代理快速入门

        1.为什么需要动态代理？ : 

        在日常开发中，往往存在这样一种需求——同时存在多个对象，这些对象对应的类都实现了同一接口，并且这些对象会去调用这个接口中的某一个方法，即多态，但是我们要求这几个对象在调用方法前，和调用方法后都要做一些业务处理，eg : 权限校验、事务管理、日志管理、安全校验等。

        如果我们将这些相同的业务处理，都下沉到每一个具体的类，就会造成代码冗余，并且没有办法进行对象的统一管理和调用；而动态代理的出现，尤对其症地解决了这个问题。

        2.动态代理使用案例：

                up先在dynamic_proxy包下创建Animal接口，以及Cat, Dog类，Cat类和Dog类都实现了Animal接口。如下图所示 : 

                Animal接口代码如下 : 

package com.cyan.spring.dynamic_proxy;/*** @author : Cyan_RA9* @version : 21.0*/
public interface Animal {public abstract void eat();
}

                Cat类代码如下 :  

package com.cyan.spring.dynamic_proxy;/*** @author : Cyan_RA9* @version : 21.0*/
public class Cat implements Animal{@Overridepublic void eat() {System.out.println("小猫爱吃鱼捏~");}
}

                Dog类代码如下 : 

package com.cyan.spring.dynamic_proxy;/*** @author : Cyan_RA9* @version : 21.0*/
public class Dog implements Animal{@Overridepublic void eat() {System.out.println("小狗爱吃骨头捏~");}
}

                然后，我们创建一个AnimalProxyProvider类，见名知意，这个类可以提供一个Animal接口的代理对象，所以，该类中肯定会定义一个方法，用来返回Animal接口的代理实例，当然，这个方法稍微有点复杂，大家可以借助up的代码注释逐渐理解。
                AnimalProxyProvider类代码如下 : （尤其注意匿名内部类中实现的invoke方法，其中的两条输出语句表示实现类对象相同的业务逻辑代码）

package com.cyan.spring.dynamic_proxy;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** @author : Cyan_RA9* @version : 21.0*/
public class AnimalProxyProvider {//利用接口类型对传入的对象做接收 (多态)private Animal targetAnimal;//通过带参构造传入一个Animal接口实现类的对象public AnimalProxyProvider(Animal targetAnimal) {this.targetAnimal = targetAnimal;}//编写一个方法，用于返回代理对象 (用到反射机制)public Animal getAnimalProxy() {/**java.lang.reflect.Proxy类中的 newProxyInstance方法可以返回一个代理对象。public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException {...}该方法需要传入三个实参 ———(1) ClassLoader loader : 类加载器(2) Class<?>[] interfaces : 接口信息(3) InvocationHandler h : 调用处理器，其本身也是一个接口，内部声明了抽象方法invoke。*///(1)得到类加载器ClassLoader classLoader = targetAnimal.getClass().getClassLoader();//(2)得到被执行对象的接口信息(因为newProxyInstance方法底层是通过接口来调用的，即接口多态)Class<?>[] interfaces = targetAnimal.getClass().getInterfaces();//(3)得到处理器对象(通过匿名内部类实现,最终返回的是一个匿名内部类对象)//!!![注意，处理器对象本身也是newProxyInstance方法的一个形参]InvocationHandler invocationHandler = new InvocationHandler() {/*** @param proxy the proxy instance that the method was invoked on** @param method the {@code Method} instance corresponding to* the interface method invoked on the proxy instance.  The declaring* class of the {@code Method} object will be the interface that* the method was declared in, which may be a superinterface of the* proxy interface that the proxy class inherits the method through.** @param args an array of objects containing the values of the* arguments passed in the method invocation on the proxy instance,* or {@code null} if interface method takes no arguments.* Arguments of primitive types are wrapped in instances of the* appropriate primitive wrapper class, such as* {@code java.lang.Integer} or {@code java.lang.Boolean}.** @return : the results of method instance invoked* @throws Throwable*/@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {/*将相同的业务逻辑代码，放在处理器对象的invoke对象中，避免了代码下沉到每个实现类所造成的代码冗余。*/System.out.println("要吃饭的嘛~");//通过反射调用实现类中的方法Object results = method.invoke(targetAnimal, args);System.out.println("吃完了捏~");return results;}};Animal animalProxy = (Animal) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);return animalProxy;}
}

                接着，up定义一个测试类，在测试类中定义一个单元测试方法，用以测试我们的动态代理是否生效。
                TestAnimal类代码如下 : 

package com.cyan.spring.dynamic_proxy;import org.junit.jupiter.api.Test;public class TestAnimal {@Testpublic void testGeyAnimalProxy() {//构造接口多态Animal animal = new Cat();Animal animal2 = new Dog();//传入需要被代理的对象AnimalProxyProvider animalProxyProvider = new AnimalProxyProvider(animal);AnimalProxyProvider animalProxyProvider2 = new AnimalProxyProvider(animal2);//得到代理对象/*注意！此处代理对象animalProxy的编译类型仍然是Animal类型，但运行类型却不再是Cat or Dog类型，而是代理类型 ——— class com.sun.proxy.$Proxy9。*/Animal animalProxy = animalProxyProvider.getAnimalProxy();Animal animalProxy2 = animalProxyProvider2.getAnimalProxy();System.out.println("animalProxy's RuntimeType = " + animalProxy.getClass());System.out.println("animalProxy2's RuntimeType = " + animalProxy2.getClass());//通过代理对象调用实现类方法animalProxy.eat();System.out.println("==============================");animalProxy2.eat();}
}

                运行结果 : 

                现在我们进行Debug断点调试，断点如下图所示 : 

                跳入eat()方法时会发现，IDEA直接跳到了AnimalProxyProvider类的getAnimalProxy方法中——匿名内部类实现的invoke方法里面，如下图所示 : 

                再往下执行便是通过反射调用对应的method，一直往下追，最终会跳到实现类的eat()方法中，如下图所示 : 

        3.动态代理的灵活性 : 

                动态代理的灵活性体现在哪里？
                首先，被代理的对象是可变的。并且，代理对象所调用的方法也是可变的。

                比方说，up在Animal接口中新定义了一个sleep方法，如下图所示 : 

                然后，up在Cat类中实现了sleep方法，如下图所示 : 

                接着，修改匿名内部类实现的invoke方法中的“业务逻辑”代码，如下图所示 : 

                最后，up在测试类中新定义一个单元测试方法，测试动态代理是否生效。
                testSleep()方法代码如下 : 

    @Testpublic void testSleep() {//1.构造接口多态Animal animal = new Cat();//2.传入需要被代理的对象AnimalProxyProvider animalProxyProvider = new AnimalProxyProvider(animal);//3.获取代理对象Animal animalProxy = animalProxyProvider.getAnimalProxy();//4.通过代理对象调用实现类方法String sleepMinutes = animalProxy.sleep(Long.valueOf(1314));}

                运行结果 : 

三、深入动态代理

        1.需求 : 

        定义Calculator接口，表示一个计算器，该接口中定义有可以完成简单加减乘除运算的方法，要求在每次执行运算方法前后，都打印出运算日志（运算法则和运算参数，以及运算结果）。

        2.实现 : 

            2.1 接口和实现类

                首先分析需求，既然要求在每次执行运算方法前后都打印出运算日志，显然我们会想到——仍是在匿名内部类实现的invoke方法中动手脚。
                别的不说，先来定义Calculator接口和一个它的实现类。
                Calculator接口如下 : (声明了“加减乘除”四个抽象方法)

package com.cyan.spring.dynamic_proxy;/*** @author : Cyan_RA9* @version : 21.0*/
public interface Calculator {public abstract double add(double n1, double n2);public abstract double subtract(double n1, double n2);public abstract double multiply(double n1, double n2);public abstract double divide(double n1, double n2);
}

                定义一个实现类Calculator_Demo1，代码如下 : 

package com.cyan.spring.dynamic_proxy;/*** @author : Cyan_RA9* @version : 21.0*/
public class Calculator_Demo1 implements Calculator {@Overridepublic double add(double n1, double n2) {return n1 + n2;}@Overridepublic double subtract(double n1, double n2) {return n1 - n2;}@Overridepublic double multiply(double n1, double n2) {return n1 * n2;}@Overridepublic double divide(double n1, double n2) {//分母不允许为0if (n2 != 0) {return n1 / n2;}return -1;}
}

            2.2 提供代理对象的类

                定义一个CalculatorProxyProvider类，与上文 “动态代理使用案例” 中定义的“提供代理对象的类”类似，都需要定义一个方法用于返回代理对象。
                CalculatorProxyProvider类代码如下 : 

package com.cyan.spring.dynamic_proxy;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.time.LocalDateTime;public class CalculatorProxyProvider {private Calculator calculator;public CalculatorProxyProvider(Calculator calculator) {this.calculator = calculator;}/*底层仍然使用java.lang.reflect包下的Proxy类的newProxyInstance方法来获取代理对象。*/public Calculator getCalculatorProxy() {//1.获取newProxyInstance方法的第一个参数————类加载器ClassLoader classLoader = calculator.getClass().getClassLoader();//2.获取newProxyInstance方法的第二个参数————接口信息Class<?>[] interfaces = calculator.getClass().getInterfaces();//3.获取newProxyInstance方法的第三个参数————处理器对象//仍然借助匿名内部类来实现，并通过构造接口多态的形式做接收。InvocationHandler invocationHandler = new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//获取到当前传入的参数double n1 = (double) args[0];double n2 = (double) args[1];//获取当前方法名String name = method.getName();//定义运算结果double result = 0.0;try {//Δ在运算方法执行前打印出运算日志System.out.println("运算日志————运算法则 = " + name + ",传入两个参数分别是 " + n1 + " 和 " + n2);//执行运算result = (double) method.invoke(calculator, args);System.out.println("result = " + result);//Δ在运算方法执行后打印出运算日志System.out.println("运算日志————运算法则 = " + name + ",运算结果 = " + result);//返回运算结果return result;} catch (Exception e) {System.out.println("异常日志————" + LocalDateTime.now() + ",方法" + method.getName() + "执行异常");throw new RuntimeException(e);} finally {System.out.println("执行日志————" + method.getName() + "方法执行结束。");}}};//4.调用newProxyInstance方法，得到代理对象Calculator instance = (Calculator) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);//5.返回获得的代理对象return instance;}
}

            2.3 测试类

                最后，仍然是在测试类中定义一个单元测试方法，up新定义了一个TestCalculator类，代码如下 : 

package com.cyan.spring.dynamic_proxy;import org.junit.jupiter.api.Test;public class TestCalculator {@Testpublic void testArithmetic() {//1.构造接口多态Calculator calculator = new Calculator_Demo1();//2.传入需要被代理的对象CalculatorProxyProvider calculatorProxyProvider = new CalculatorProxyProvider(calculator);//3.获取代理对象Calculator calculatorProxy = calculatorProxyProvider.getCalculatorProxy();//4.通过代理对象调用实现类方法double addResult = calculatorProxy.add(200.333, 33);System.out.println("-----------------------------");double subtractResult = calculatorProxy.subtract(141, 5);System.out.println("-----------------------------");double multiplyResult = calculatorProxy.multiply(11.11, 2);System.out.println("-----------------------------");double divideResult = calculatorProxy.divide(3917.0, 500.00);}
}

                运行结果 : 

                注意——
                (1) CalculatorProxyProvider类的这段代码，如下图所示 : 

                在AOP中，称为“横切关注点”，也叫“前置通知”。

                (2) 而下面的这段代码，如下图所示 : 

                从AOP的角度来看，也称为一个“横切关注点”，但也叫“后置通知”。

                (3) 此外，异常处理——catch语句块中的这段代码，如下图所示 : 

                从AOP看，也称为一个“横切关注点”，但又称为“异常通知”。

                (4) 最后，finally代码块中的内容，如下图所示 : 

                从AOP看，也称为一个“横切关注点”，但又称为“最终通知”。

        3.引出AOP : 

                分析一下我们方才写得代码，如下图所示 : 

                可以看到，无论是“前置通知”，“后置通知”，还是“异常通知”，“最终通知”。我们都只是草草地用了一条输出语句敷衍过去，这使得我们的代码不够牛逼，功能不够强大，且代码死板，不够灵活。
                而作为一名OOP程序员，我们会容易联想到——假如此处的输出语句都替换成方法，用一个方法直接切入，那不就既满足灵活性，又可以实现强大的功能吗？

四、总结

  • 🆗，以上就是Spring系列博文第四小节的全部内容了。
  • 总结一下，我们应该明白动态代理究竟“动态”在哪里？—— 不止是被代理对象可变，且代理对象执行的方法也是可变的。我们还需要知道newProxyInstance方法的三个形参分别有什么作用，以及如何获取这三个形参（尤其是第三个形参——处理器对象的获取，用到了匿名内部类）。总之，这篇博文其实是为了给“Spring—AOP”的分享做一个铺垫，我们以一个问题开始，又以一个问题结尾，也符合这篇博客的定位。
  • 下一节内容——Spring AOP—切入表达式和基于XML配置AOP，我们不见不散。感谢阅读！

        System.out.println("END---------------------------------------"); 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/305813.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

设备不锈钢二维码标识牌

设备不锈钢二维码标识牌

随着科技的不断发展&#xff0c;二维码已经应用于身边的各个领域。特别是在建筑施工、工业制造、设备管理等领域被广泛应用。 不锈钢二维码的优势。首先&#xff0c;不锈钢材质具有高度耐腐蚀、抗压和耐磨损的特点&#xff0c;可以适应各种极端环境。其次&#xff0c;不锈钢二…
阅读更多...
mysql保姆安装教程

mysql保姆安装教程

一.下载install文件 1.进入Mysql官网&#xff0c;点击下载 2.选择MySQL Installer for Windows 3.推荐选择第二个安装包 4.不登陆&#xff0c;开始下载 5.等待下载完成 二.安装前的配置 通过电脑“设置”&#xff0c;检查电脑是否包含中文名&#xff0c;如果包含请重命名 …
阅读更多...
Python中JSON模块的使用

Python中JSON模块的使用

1 JSON简介 JSON是JavaScript Object Notation即Javascript对象简谱的缩写。JSON是一种轻量级的数据交换格式&#xff0c;JSON数据是由键值对组成的结构&#xff0c;与Python中的字典类似&#xff0c;由尖括号包围的键值对组成&#xff0c;键和值的类型可以是字符串、数字、布…
阅读更多...
drf知识-08

drf知识-08

Django之了解DRF框架 # 介绍&#xff1a;DRF全称 django rest framework # 背景&#xff1a; 在序列化与反序列化时&#xff0c;虽然操作的数据不尽相同&#xff0c;但是执行的过程却是相似的&#xff0c;也就是说这部分代码是可以复用简化编写的 增&#xff1a;校验请…
阅读更多...
电子学会C/C++编程等级考试2023年03月（七级）真题解析

电子学会C/C++编程等级考试2023年03月（七级）真题解析

C/C++等级考试（1~8级）全部真题・点这里 第1题：走出迷宫 当你站在一个迷宫里的时候，往往会被错综复杂的道路弄得失去方向感，如果你能得到迷宫地图，事情就会变得非常简单。 假设你已经得到了一个n*m的迷宫的图纸，请你找出从起点到出口的最短路。 时间限制：1000 内存限制…
阅读更多...
边缘检测——PidiNet网络训练自己数据集并优化推理测试（详细图文教程）

边缘检测——PidiNet网络训练自己数据集并优化推理测试（详细图文教程）

PiDiNet 是一种用于边缘检测的算法&#xff0c;它提出了一种简单、轻量级但有效的架构。PiDiNet 采用了新 颖的像素差卷积&#xff0c;将传统的边缘检测算子集成到现代 CNN 中流行的卷积运算中&#xff0c;以增强任务性能。 在 BSDS500、NYUD 和 Multicue 上进行了大量的实验…
阅读更多...
蓝桥杯嵌入式ADC

蓝桥杯嵌入式ADC

1.ADC原理图 2.CubeMX配置 3.ADC相关代码
阅读更多...
3D展2D数学原理

3D展2D数学原理

今年早些时候&#xff0c;我为 MAKE 杂志写了一篇教程&#xff0c;介绍如何制作视频游戏角色的毛绒动物。 该技术采用给定的角色 3D 模型及其纹理&#xff0c;并以编程方式生成缝纫图案。 虽然我已经编写了一般摘要并将源代码上传到 GitHub&#xff0c;但我在这里编写了对使这一…
阅读更多...
纺织辅料品小程序商城：智能化运营，轻松赚钱

纺织辅料品小程序商城：智能化运营，轻松赚钱

随着互联网的发展&#xff0c;越来越多的传统行业开始转向数字化转型&#xff0c;以提升企业效益和客户体验。纺织品行业也不例外。通过开发纺织品小程序&#xff0c;可以更好地满足消费者需求&#xff0c;提高品牌知名度&#xff0c;促进业务发展。下面就让我们一起了解如何快…
阅读更多...
RFID智能巡检系统方案—保障消防安全，提升管理效能

RFID智能巡检系统方案—保障消防安全，提升管理效能

一、问题背景 在火灾发生时&#xff0c;消防设备的及时启动至关重要&#xff0c;然而&#xff0c;传统的消防设备巡检与管理方式存在以下问题&#xff1a; 设备管理不便&#xff1a;消防设备规格不一、类型众多、地理位置分散&#xff0c;给设备管理带来困难&#xff0c;传统的…
阅读更多...
Python+OpenGL 杂谈

Python+OpenGL 杂谈

系列文章 一、逆向工程 Sketchup 逆向工程&#xff08;一&#xff09;破解.skp文件数据结构 Sketchup 逆向工程&#xff08;二&#xff09;分析三维模型数据结构 Sketchup 逆向工程&#xff08;三&#xff09;软件逆向工程从何处入手 Sketchup 逆向工程&#xff08;四&#xf…
阅读更多...
elementui+vue2 input输入框限制只能输入数字

elementui+vue2 input输入框限制只能输入数字

方法1 自定义表单校验 <el-form :model"Formdata" ref"formRef" :rules"nodeFormRules" label-width"100px"><el-form-itemlabel"年龄"prop"age"><el-input v-model.number"Formdata.age&q…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023