设计模式-代理模式

技术文档

1.代理模式

1.1什么是代理模式

代理模式就是为一个对象提供一个替身，以控制对这个目标对象的访问。即通过代理对象访问目标对象，这样做的好处是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。

要点：即从直接访问目标对象转变为访问代理对象。

1.2代理对象可以为哪些？

1.远程对象。2.创建开销大的对象。3.需要安全控制的对象。

1.3代理模式的三种形式

代理模式的三种形式：1.静态代理。2.JDK动态代理。3.CGLIB动态代理。

1.4代理模式示意图

ProxyObject是代理对象，TargetObject是目标对象，Client客户端依赖代理对象（进行调用），代理对象依赖目标对象，当客户端调用代理对象的时候，代理对象会去调用目标对象。

2.静态代理

2.1静态代理的介绍

静态代理在使用时，需要定义接口或者父类，被代理的对象（即目标对象）与代理对象一起实现相同的接口或者继承相同的父类。

要点：静态代理要求TargetObject，ProxyObject实现相同的接口/继承相同的父类。

2.2实现静态代理模式的步骤

1.定义一个统一的接口：ITeacherDao。

2.目标对象（TargetObject）实现统一的接口：如TeacherDAO实现接口ITeacherDAO。

3.代理对象（ProxyObject）实现统一的接口：如TeacherDAOProxy实现接口ITeacherDAO。

4.Client调用的时候，去调用代理对象（ProxyObject）

5.特别提醒：代理对象与目标对象要实现相同的接口，然后通过调用相同的方法来调用目标对象的方法。

2.3静态代理设计的UML类图

2.4代码实现

2.4.1实现的统一的接口

定义一个统一的接口，定义TargetObject和ProxyTarget都有的方法。

要点：即TargetObject中需要被代理类代理的方法都在统一接口中定义。

/** * 接口 */public interface ITeacherDAO { // 授课的方法 void teach();}

2.4.2定义TargetObject

TargetObject就是被代理的对象，需要被代理的方法需要定义在统一接口中，并进行实现相关定义的接口。

/** * TargetObject */public class TeacherDAO implements ITeacherDAO { @Override public void teach() { System.out.println(\" 老师授课中... \"); }}

2.4.3定义ProxyObject

ProxyObject是代理对象，要进行实现相关统一接口（接口中定义的方法就是Proxy要进行代理Target中的方法），Proxy类中要聚合一个Target进行使用（以接口的形式进行聚合来），只要是实现了相关接口的Target类都可以进行代理。

代理方法中主要是调用聚合的Target类中的方法，前后进行添加一些逻辑，实现代理Target的功能。

// 代理对象(ProxyObject)public class TeacherDaoProxy implements ITeacherDAO { // 目标对象, 通过接口进行聚合 private ITeacherDAO target; // 构造器 public TeacherDaoProxy(ITeacherDAO target) { this.target = target; } @Override public void teach() { System.out.println(\"前置代理逻辑.....\"); target.teach(); System.out.println(\"提交......\"); }}

2.5测试静态代理模式

2.5.1测试代码

// 客户端public class Client { public static void main(String[] args) { // 创建目标对象 (被代理对象) TeacherDAO teacherDAO = new TeacherDAO(); // 创建代理对象, 同时将被代理对象传递给代理对象 TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDAO); // 通过代理对象, 调用被代理对象的方法 // 即: 执行的时代理对象的方法, 代理对象再去调用目标对象的方法 teacherDaoProxy.teach(); }}

2.5.2测试结果

可以发现静态代理设计模式生效了，在TargetObject方法的前后进行添加了逻辑。

2.6静态代理的优缺点

2.6.1优点

在不修改目标对象的功能前提下，能通过代理对象对目标功能进行扩展。

要点：不修改TargetObject，通过ProxyObject进行扩展原始方法。

2.6.2缺点

系统中代理类较多：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类。

要点：代理类耦合在系统中，使得系统很庞大，需要代理一个目标对象就需要实现一个代理对象，十分费劲。

难以维护性：需要进行代理TargetObject中新方法的时候，TargetObject，统一接口，ProxyObject都要进行修改，十分复杂。

要点：代理一个方法要维护三个类，维护成本十分大。

3.JDK动态代理

3.1基本介绍

3.1.1什么是JDK动态代理

1.代理对象不需要实现接口，但是目标对象要实现接口，否则不能用动态代理。

要点：JDK动态代理的代理对象类无需实现接口，目标对象需要实现接口。

2.代理对象的生成，是利用JDK的API，动态的在内存中构建代理对象。

要点：JDK动态代理在JVM中进行动态的在内存中生成代理对象，无需编码代理对象。

3.JDK动态代理也被称之为接口动态代理模式。

3.1.2JDK中生成代理对象的API

1 代理类所在的包是java.lang.reflect.Proxy，即JDK动态生成的代理类都是java.lang.reflect.Proxy的子类。

2.JDK实现代理只需要使用newProxyInstance方法，但是这个方法需要接收三个参数，完整的写法是：

Object newProxyInstance(ClassLoader classLoader, Class interfaces, InvocationHandler handler)

调用newProxyInstance方法就可以快速生成TargetObject的代理对象

3.2UML类设计图

3.3实现代码

3.3.1抽象代理接口定义

TargetObject进行实现这个抽象接口，抽象接口中定义的抽象方法都是TargetObject中可以被代理的方法。

要点：TargetObject需要实现一个抽象接口，只有抽象接口中定义的方法才能被代理类所代理使用。

// 定义接口, 方便Target Object实现public interface ITeacherDao { void teach(); String sayHello(String name);}

3.3.2目标类（TargetObject）的定义

目标类TargetObject需要实现抽象代理接口，实现的这些方法是可以被代理对象所劫持代理的方法。

// TargetObjectpublic class TeacherDao implements ITeacherDao { @Override public void teach() { System.out.println(\" 老师授课中...... \"); } @Override public String sayHello(String name) { System.out.println(\"Hello \" + name); return \"你好 \" + name; }}

3.3.3直接使用java.lang.reflect.Proxy使用JDK动态代理

先创建目标对象，然后调用newProxyInstance()方法，传入目标对象的Class对象，再传入生成的代理对象需要实现的接口（TargetObject定义的类也需要实现相关接口），最终传入一个-InvocationHandler接口实现类，实现invoke方法，invoke方法会传入method参数和args参数（method参数就是劫持的调用方法对象，args参数就是劫持函数对象接收的参数列表），在invoke方法中进行实现代理类的逻辑。

import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;public class ClientTest { public static void main(String[] args) { ITeacherDao teacherDao = new TeacherDao(); ITeacherDao teacherDaoProxy = (ITeacherDao) Proxy.newProxyInstance(teacherDao.getClass().getClassLoader(), teacherDao.getClass().getInterfaces(), new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println(\"我是付庆浩爸爸\"); Object resObj = method.invoke(teacherDao, args); System.out.println(\"我是尹蔚然爷爷\"); return resObj; } }); String str = teacherDaoProxy.sayHello(\"牛逼\"); System.out.println(str); }}

实现步骤：

1.创建TargetObject实现类对象。

2.调用java.lang.reflect.Proxy中的newProxyInstance()方法，需要接收三个参数，ClassLoader（类加载器 => 加载动态生成的代理类的类加载器），interfaces => 需要被代理的接口Class对象数组（TargetObejct类必须实现），InvocationHandler实现类（需要重写Invoke方法，实现代理类的逻辑）

要点：生成的代理类是实现了传进去的interfaces中的接口的类，可以声明为相关接口类型。

3.3.4建立动态代理工厂

3.3.4.1为什么要采用动态代理工厂模式

直接使用java.lang.reflect.Proxy.newProxyInstance进行耦合在Client中创建对象是一个糟糕的选择，因为我们如果想要创建目标对象代理对象的时候，就需要重新写一遍newProxyInstance中复杂的逻辑，太费劲了这样，维护起来简直是灾难，所以建议直接建立一个代理工厂类，需要创建代理对象的时候，就直接调用这个工厂中的方法创建代理对象，需要改变创建对象的逻辑的时候，就直接去修改工厂类中的方法逻辑即可。

3.3.4.2建立动态代理工厂的步骤

1.维护一个target字段，负责进行忖出目标对象 => 表示生产谁的代理对象。

2.维护一个构造器，在构造动态代理对象的时候，传入一个TargetObject表示构造哪个类型的对象

要点：一个工厂实例可以对应创建一个类型的TargetObject的实例对象。

3.定义一个getProxyInstance方法，用于进行返回一个Proxy对象，调用Proxy.newProxyInstance方法进行构造Proxy代理对象，在InvocationHandler的实例化对象里面重写的invoke方法中进行定义代理对象的逻辑。

import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;// 制造动态代理的工厂public class ProxyFactory { // 维护一个目标对象, Object private Object target; // 构造起, 对target进行初始化 public ProxyFactory(Object target) { this.target = target; } // 获取动态代理对象‘ public Object getProxyInstance() { return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {  @Override  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println(\"JDK代理开始~~\"); // 反射机制调用目标对象 Object returnVal = method.invoke(target, args); System.out.println(\"JDK代理结束~~\"); return returnVal;  } }); } }

这样通过代理对象工厂进行创建出来的Proxy代理对象，是解耦后的，不用每次创建代理对象都需要书写java.lang.reflect.Proxy.newProxyIntance()的逻辑了，这样大大降低了代码工作量，提高了代码的可维护性。

/** * 测试客户端 */public class Client { public static void main(String[] args) { // 创建目标对象 ITeacherDao target = new TeacherDao(); // 给目标对象, 创建代理对象, 可以转换为TargetObject实现的接口类型 ITeacherDao proxyInstance = (ITeacherDao) new ProxyFactory(target).getProxyInstance(); // class com.sun.proxy.$Proxy0 可以发现创建出来动态代理类是com.sun.proxy包下的类 System.out.println(\"proxyInstance = \" + proxyInstance.getClass()); // 通过ProxyObject, 调用目标对象的方法 proxyInstance.teach(); String str = proxyInstance.sayHello(\"付庆浩\"); System.out.println(str); }}

4.CGLIB动态代理

4.1基本介绍

4.1.1思想转变

代理类由实现接口转变为继承类。

静态代理和JDK动态代理模式都要求目标对象是实现一个接口，但是有时候目标对象只是一个单独的对象，并没有实现任何的接口，这个时候可以使用目标对象子类来实现代理，也就是CGLIB代理。

4.1.2为什么CGLIB是动态代理？

CGLIB代理也被称为子类代理，它是内存中构建一个子类对象从而实现对目标对象功能扩展，并且CGLIB代理也被列为动态代理模式。

4.1.3CGLIB在库中的使用？

CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口（在运行时动态扩展Java类与实现Java接口），广泛的被用于各种AOP框架使用（例如SpringAOP），实现方法拦截。

要点：SpringAOP中的方法拦截是靠动态代理实现的。

4.1.4在AOP编程中如何选择代理模式

1.目标对象需要实现接口，使用JDK代理。

2.目标对象不需要实现接口，使用CGLIB编程。

4.1.5CGLIB的底层是如何实现的？

CGLIB的底层是通过字节码处理框架ASM来转换字节码并生成新的类。

要点：CGLIB底层依赖的ASM操作字节码。

4.2UML类图的设计

MethodInterceptor是CGLIB库内部的接口，需要定义代理对象工厂的类进行实现，来编辑代理对象的逻辑，在工厂类ProxyFactory内部通过getProxyInstance进行创建target对应的代理对象，使用interceptor编写对应的代理对象逻辑。

4.3实现代码

4.3.1使用Maven引入CGLIB

 cglib cglib 3.3.0

4.3.2TargetObject被代理对象类的定义

/** * TargetObject类的设计 */public class TeacherDao { public String teach() { System.out.println(\" 老师授课中 , 我是cglib代理, 不需要实现接口 \"); return \"hello\"; }}

4.3.3ProxyFactory代理对象工厂类的定义

1.和JDK实现代理对象工厂类的逻辑一样，使用成员字段进行接收目标对象，一个代理对象工厂类的实例就可以创建一个类型的对象的代理对象，使用构造器进行聚合要生成代理对象的实例对象。

2.定义getProxyInstance方法进行获取代理对象，主要使用工具类Enhancer，实例化一个工具类，使用setSuperclass设置父类，使用setCallback设置实现了MethodInterceptor接口的类的实例化对象，主要是设置定义代理对象逻辑的实例化对象，最终调用enhancer.create()创建代理对象，并进行返回。

3.类实现MethodInterceptor接口，重写interceptor方法，定义代理对象的逻辑。

import net.sf.cglib.proxy.Enhancer;import net.sf.cglib.proxy.MethodInterceptor;import net.sf.cglib.proxy.MethodProxy;import java.lang.reflect.Method;/** * 代理对象生产工厂 */public class ProxyFactory implements MethodInterceptor { // 维护一个目标对象 private Object target; // 构造器, 传入一个被代理的对象 public ProxyFactory(Object target) { this.target = target; } // 返回一个代理对象: 是target对象的代理对象 public Object getProxyInstance() { // 1. 创建一个工具类 Enhancer enhancer = new Enhancer(); // 2. 设置父类 enhancer.setSuperclass(target.getClass()); // 3. 设置回调函数 enhancer.setCallback(this); // 4. 创建子类对象, 即代理对象 return enhancer.create(); } @Override public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { System.out.println(\"Cglib代理模式~~ 开始\"); Object returnVal = method.invoke(target, args); System.out.println(\"Cglib代理模式~~ 结束\"); return returnVal; }}

4.4测试CGLIB动态代理

4.4.1测试代码

/** * 测试客户端 */public class Client { public static void main(String[] args) { // 创建目标对象 TeacherDao target = new TeacherDao(); // 获取到代理对象, 并且将目标对象传递给代理对象 TeacherDao proxyInstance = (TeacherDao) new ProxyFactory(target).getProxyInstance(); // 执行代理对象的方法, 触发intercept方法, 从而实现对目标对象的调用 String res = proxyInstance.teach(); System.out.println(\"res = \" + res); }}

4.4.2测试结果

5.代理模式的变体

5.1防火墙代理

内网通过代理穿透防火墙，实现对公网的访问。

5.2缓存代理

比如：当请求图片文件等资源，先到缓存代理取，如果取到资源就OK，如果取不到资源，再到公网或者数据库去取，然后缓存。

要点：其实redis在后端和MySQL之间就算一个缓存代理。

5.3远程代理

远程对象的本地代表，通过它可以将远程对象当作本地对象进行调用。远程代理通过网络和真正的远程对象沟通信息。

要点：本地Client通过代理访问到远程对象进行调用。

5.4同步代理

主要用于多线程编程中，完成多线程间同步的工作。

要点：多线程编程中，使用同步代理完成多线程间的同步工作。