[程序设计]—代理模式👳

本文章记录学习于——52.面向切面：AOP-场景模拟_哔哩哔哩_bilibili

最近闲来无事，在学习Spring的源码：后面慢慢更新源码系列blog，希望多多关注🙏🙏

目前已经总结的blog 系列🕳：慈様や 前端学习导航👩🏻‍🚀🚀 、小様—Java后端开发日记

很多框架在设计和实现过程中广泛运用了多种设计模式：Spring核心IOC、AOP

• 工厂模式：BeanFactory和ApplicationContext实现了工厂模式，负责创建和管理Bean对象

• 单例模式：Spring默认将所有Bean定义为单例模式，即每个容器中只存在一个实例

• 代理模式：AOP 面向切面编程的核心，通过动态代理：JDK代理、CGLIB代理

  实现了非侵入式编程，可以在不修改原有业务代码的情况下增加额外功能

  在目标方法调用前后添加增强逻辑，如事务管理、日志记录等，

• 适配器默认、观察者默认、策略模式…设计模式使，

  Spring框架展现出了高度的模块化、可配置性和可扩展性，使得开发者能够高效地构建复杂的应用程序

👊 总而颜值->设计模式很重要，

设计模式其实是在软件开发过程中经过经验积累和验证总结，一套通用代码设计方案

如果熟悉了设计模式，当遇到类似的场景，我们可以快速地参考设计模式实现代码，

不仅可以加速我们的编码速度，也提升了代码的：扩展性、重用性、维护性!

个人看法：

虽然，设计模式听着高大上，其实实际开发过程中已经潜移默化的接触了很多了，

且有的设计模式已经随着时代、或还并没有完全适合的引用常见，新手建议会用为主，了解为辅

设计模式：属于程序的内功心法💖、学习是一个长期反复推敲的过程、不断优化升级🆙🆙❗ ❗ ❗

• 注意：设计模式不属于某个特定的编程语言，而是一种编程思想，代码模式；

设计模式分类：

目前设计模式主要有：23种，大致分为三大类：

创建型模式Creational Patterns用于创建对象的模式，同时隐藏对象创建的逻辑，

避免代码中出现大量new操作和复杂的创建逻辑，目的是解耦对象的创建和使用

• 常用的有：单例模式、工厂模式、建造者模式
• 不常见的有：原型模式

结构型模式Structural Patterns

用于处理对象组合的结构，关注类与对象的组合，目的是通过组合对象或类的方式，形成更大的结构

• 常用的有：适配器模式、桥接模式、组合模式、装饰器模式、代理模式
• 不常见的有：外观模式(门面模式)、享元模式

行为型模式Behavioral Patterns

用于定义对象相互协作以完成单个对象无法单独实现的任务，目的：是定义类和对象间的通信方式；

• 常用的有：观察者模式、责任链模式、策略模式、模板模式、状态模式、迭代器模式，
• 不常见的有：备忘录模式、命令模式、中介者模式、访问者模式、解释器模式

需求介绍：

目前有一个计算器🧮类，它有add 加、sub 减的方法，新需求：计算前后进行日志记录输出；

声明计算器接口：用于规范计算器类的定义；

//计算器类接口:publicinterfaceCalculator{//计算器加函数intadd(inti,intj);//计算器减函数intsub(inti,intj);}

计算器接口实现类：声明并实现计算器接口；

//计算器接口实现类:publicclassCalculatorImplimplementsCalculator{@Overridepublicintadd(inti,intj){returni+j;}@Overridepublicintsub(inti,intj){returni-j;}}

新需求：在加减之前进行日志记录——计算器日志接口实现类：

• 正常情况下，大部分开发者会直接在上面实现类上改动，但为了不影响其他就创建新的实现类；

//计算器日志接口实现类: 不就是日志嘛一行代码CV的事~~publicclassCalculatorLogImplimplementsCalculator{@Overridepublicintadd(inti,intj){System.out.println("[日志]mul 方法开始了，参数是:"+i+","+j);System.out.println("[日志]mul 方法结束了，结果是:"+(i+j));returni+j;}@Overridepublicintsub(inti,intj){System.out.println("[日志]mul 方法开始了，参数是:"+i+","+j);System.out.println("[日志]mul 方法结束了，结果是:"+(i-j));returni-j;}}

轻轻松松~ 小活😀这就结束了吗？到此为止了…

NO—NO—NO❗ ❗ ❗如果这个类在大一点呢？或者方法实现更复杂呢？

• 针对日志功能实现类，我们发现有如下缺陷：对核心业务功能有干扰，附加功能分散各个业务功能中；

🆗，主角登场——代理模式：👇👇👇

JDK 代理模式

代理模式是一种结构型设计模式：

它为其他对象提供一种代理，以控制对这个对象的访问，代理对象可以在客户端和目标对象之间起到中介的作用，

在不改变目标对象接口的前提下，对目标对象的访问进行控制或增强，上述代码举例：👆👆👆

代理模式的特点：

• 功能增强：代理对象可以在访问实际对象之前或之后添加额外的功能
• 间接访问：客户端通过代理访问实际对象，代理对象负责对实际对象的控制
• 代码解耦：客户端不直接与实际对象交互，通过代理对象可以透明地扩展实际对象的功能

代理模式的分类：

• 静态代理：在编译时创建代理类，代理类与目标类实现相同的接口，
• 动态代理：在运行时动态生成代理类，适用于无需事先定义代理类的场景

静态代理：

静态代理：不推荐)了解即可，实际开发中不经常使用，

代理类和被代理类在编译时期就确定了它们之间的代理关系，

代理类需要实现与被代理类相同的接口，并且在代理类中持有被代理类的实例目标对象，

通过调用被代理类的方法，来完成实际的操作，在方法调用前后添加额外的逻辑；这一点也不高级；

//静态代理类publicclassCalculatorStaticProxyimplementsCalculator{//被代理的目标对象privateCalculatortarget;publicCalculatorStaticProxy(Calculatortarget){this.target=target;}@Override//附加功能由代理类中的代理方法来实现publicintadd(inti,intj){System.out.println("[日志] add 方法开始了，参数是："+i+","+j);//通过目标对象来实现核心业务逻辑intaddResult=target.add(i,j);System.out.println("[日志] add 方法结束了，结果是："+addResult);returnaddResult;}//省略...其他实现;}

//静态代理使用:publicclassCalculatorStaticProxyMain{publicstaticvoidmain(String[]args){//创建被代理类对象CalculatorImplcalculator=newCalculatorImpl();//被代理类对象 ==>构造创建 对应的 ==> 静态代理类,静态代理类中对函数进行调用扩展;CalculatorStaticProxycalStaticProxy=newCalculatorStaticProxy(calculator);//因此: 直接使用静态代理类对象即可,获得存在日志的计算机函数方法;calStaticProxy.add(1,1);}}

静态代理确实实现了解耦：，但是由于代码都写死了，完全不具备任何的灵活性

• 如果：将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代码

如何：将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理类来实现——动态代理技术

动态代理：

涉及知识：【反射】、【类加载ClassLoad】… ，JDK 官方文档📑Java.lang.reflect.Proxy

Java 动态代理是一种在运行时动态地创建代理对象的机制：

• 它允许开发者在不修改原有类代码的基础上，

• 为目标对象创建代理，并且能够在代理对象的方法调用前后灵活地添加自定义的逻辑；

与静态代理不同：动态代理不需要为每个目标类手动编写代理类，在JDK中，常用的实现方式是反射

• 反射机制：是指程序在运行期间可以访问、检测和修改其本身状态或行为的一种能力

实现原理

实现原理：基于 Java 的java.lang.reflect包：InvocationHandler接口：

开发者需要实现这个接口，并且实现invoke方法，在invoke方法中定义代理对象的方法被调用时要执行逻辑；

• invoke方法有三个参数：proxy代理对象本身、method被调用的方法对象、args方法的参数数组；

Proxy类：通过Proxy.newProxyInstance方法可以创建生成代理对象；这个方法需要三个参数：

• 目标对象的类加载器：目标对象.getClass().getClassLoader(),
• 目标对象的接口数组：目标对象.getClass().getInterfaces(),
• InvocationHandler接口实例；

🆗，到此就获得了一个：(动态)代理对象：使用动态代理对象，具有目标对象，一样的方法([参数]);

• 通过代理对象方法时，实际上会调用InvocationHandler实例对象的invoke方法，方法中，执行了增强逻辑；

importjava.lang.reflect.InvocationHandler;importjava.lang.reflect.Method;//动态代理类publicclassDynamicProxyimplementsInvocationHandler{//目标代理对象privateObjecttarget;publicDynamicProxy(Objecttarget){this.target=target;}@Override//proxy代理对象本身、method被调用的方法对象、args方法的参数数组publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{System.out.println("[日志] "+method.getName()+" 方法开始了，参数是："+args);// 通过目标对象来实现核心业务逻辑ObjectaddResult=method.invoke(target,args);System.out.println("[日志] "+method.getName()+" 方法结束了，结果是："+addResult);returnaddResult;}}

importorg.proxyD.Calculator;importjava.lang.reflect.Proxy;importorg.proxyD.CalculatorImpl;/** 动态代理使用: */publicclassDynamicProxyMain{publicstaticvoidmain(String[]args){//定义目标对象、InvocationHandler接口实例CalculatorImplcalculator=newCalculatorImpl();DynamicProxycalStaticProxy=newDynamicProxy(calculator);//Proxy.newProxyInstance(目标类加载对象,目标接口数组,InvocationHandler接口实例) 动态创建生成代理对象CalculatorCalculatorimpl=(Calculator)Proxy.newProxyInstance(//calculator 目标对象通过接口getClass 获得类加载对象、接口数组calculator.getClass().getClassLoader(),calculator.getClass().getInterfaces(),//InvocationHandler 接口实例calStaticProxy);//使用: 生成代理类Calculatorimpl.add(1,1);Calculatorimpl.sub(1,1);}}

动态代理优势：可以在运行时根据需要动态地创建代理对象，而不需要像静态代理那样为每个目标类提前编写代理类

代码复用性强：一个InvocationHandler实现类可以用于代理多个实现相同接口的目标对象

易于维护和扩展：由于代理逻辑集中在InvocationHandler实现类的invoke方法中，

当需要修改代理逻辑时，只需要修改这个方法即可，而不需要多个代理类进行修改；

优化—代理工厂：

考虑到代码复用与管理：可以对上述代码进行优化一个 代理工厂，将Proxy.newProxyInstance生成代理类操作进行统一管理；

匿名内部类实现：InvocationHandler接口，重写了invoke方法；

importjava.lang.reflect.InvocationHandler;importjava.lang.reflect.Method;importjava.lang.reflect.Proxy;importjava.util.Arrays;//动态代理工厂publicclassProxyFactory{//目标对象privateObjecttarget;publicProxyFactory(Objecttarget){this.target=target;}//动态代理对象函数//通过: 创建 InvocationHandler接口 匿名实现类对象,直接返回 动态代理对象;publicObjectgetProxy(){/** newProxyInstance()：创建一个代理实例 其中有三个参数: *//** 1、classLoader：加载动态生成的代理类的类加载器 */ClassLoaderclassLoader=target.getClass().getClassLoader();/** 2、interfaces：目标对象实现的所有接口的class对象所组成的数组 */Class<?>[]interfaces=target.getClass().getInterfaces();/** 3、通过: 创建 InvocationHandler接口 匿名实现类对象,直接返回 动态代理对象 * invocationHandler：设置代理对象实现目标对象方法的过程，即代理类中如何重写接口中的抽象方法 */InvocationHandlerinvocationHandler=newInvocationHandler(){@OverridepublicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{Objectresult=null;try{System.out.println("[动态代理][日志] "+method.getName()+"，参数："+Arrays.toString(args));result=method.invoke(target,args);System.out.println("[动态代理][日志] "+method.getName()+"，结果："+result);}catch(Exceptione){e.printStackTrace();System.out.println("[动态代理][日志] "+method.getName()+" 异常");}finally{System.out.println("[动态代理][日志] 方法执行完毕");}returnresult;}};//最后返回代理对象;returnProxy.newProxyInstance(classLoader,interfaces,invocationHandler);}}

CGLIB 动态代理：

JDK动态代理是基于接口的，所以要求代理类一定是有定义接口的，

CGLIB 基于ASM字节码生成工具，它是通过继承的方式生成目标类的子类来实现代理类，

• 注意final方法，不可继承

• 它们之间的性能随着JDK版本的不同而不同：

• JDK6在运行次数较少的情况下，动态代理与CGLIB差距不明显，次数增加之后CGLIB更快

• JDK7情况发生了逆转！在运行次数较少1.000,000情况下，JDK动态代理比CGLIB快了差不多30%；

  而当调用次数增加之后(50000000)，JDK动态代理比CGLIB快了接近1倍，Jdk8表现和Jdk7基本一致

CGLIB 的工作原理

继承目标类：CGLIB 通过继承目标类来创建代理类。在生成的代理类中，它会重写目标类的方法

方法拦截：CGLIB 利用方法拦截器（MethodInterceptor）来控制对目标类方法的访问；

• 当代理类的方法被调用时，会先进入方法拦截器的intercept方法；进行操作；

添加 CGLIB 依赖：CGLIB 是第三方库，所以需要引入对应依赖；

<dependency><groupId>cglib</groupId><artifactId>cglib-nodep</artifactId><version>3.3.0</version></dependency>

创建方法拦截器：实现 CGLIB 的MethodInterceptor接口来定义方法拦截逻辑，重写：intercept方法：

• 第一个参数o是代理对象本身

• 第二个参数method是被调用的目标方法

• 第三个参数objects是目标方法的参数数组

• 第四个参数methodProxy是一个方法代理对象，用于调用目标类的原始方法

  通过methodProxy.invokeSuper(o, objects)可以调用目标类的原始方法，并获取返回结果；

importnet.sf.cglib.proxy.MethodInterceptor;importnet.sf.cglib.proxy.MethodProxy;importjava.lang.reflect.Method;//实现 CGLIB 的MethodInterceptor接口来定义方法拦截逻辑publicclassCglibInterceptorimplementsMethodInterceptor{@OverridepublicObjectintercept(Objecto,Methodmethod,Object[]objects,MethodProxymethodProxy)throwsThrowable{System.out.println("代理类在目标方法执行前的操作"+method.getName());Objectresult=methodProxy.invokeSuper(o,objects);System.out.println("代理类在目标方法执行后结果"+result);returnresult;}}

//CGLIB 的Enhancer类来创建代理对象importnet.sf.cglib.proxy.Enhancer;publicclassCglibInterceptorMain{publicstaticvoidmain(String[]args){//首先创建一个Enhancer对象Enhancerenhancer=newEnhancer();//设置代理类要继承的目标类、设置方法拦截器enhancer.setSuperclass(Calculator.class);enhancer.setCallback(newCglibInterceptor());//最后通过enhancer.create()创建代理对象将其转换为目标类类型Calculatorproxy=(Calculator)enhancer.create();//代理类对象调用函数;proxy.add(1,1);proxy.sub(1,1);}}

🆗，代理模式大致如此，是不是so easy轻轻松松的，求点赞👍、收藏⭐ 🥰🥰🥰