代理模式（结构型模式）-编程知识

1、概述

2、结构

2.1、角色分类

2.2、类图

3、静态代理

3.1、案例类图

3.2、案例代码

4、JDK 动态代理

4.1、案例代码

4.2、底层原理

4.3、执行流程说明

5、CGLib 动态代理

5.1、案例代码

6、三种代理的对比

6.1、JDK代理和CGLib代理

6.2、动态代理和静态代理

7、优缺点

7.1、优点

7.2、缺点

8、使用场景

8.1、远程（Remote）代理

8.2、防火墙（Firewall）代理

8.3、保护（Project or Access）代理

1、概述

由于某些原因需要给某对象提供一个代理以控制该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的媒介。

代理模式也叫做委托模式，它是一项基本设计技巧。许多其他的模式，如状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式，而且在日常的应用中，代理模式可以提供非常好的访问控制。

Java 中的代理按照生成时机不同又分为静态代理和动态代理。静态代理代理类在编译期就生成，而动态代理代理类则在 Java 运行时动态生成，程序结束时内存会自动释放。动态代理又分为 JDK 动态代理和 CGLib 动态代理。

2、结构

2.1、角色分类

代理（Proxy）模式分为三种角色，分别如下：

（1）抽象主题（Subject）角色：通过接口或抽象类声明真实主题和代理对象实现的业务方法。

（2）具体主题（Real Subject）角色：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象，也叫做被委托角色、被代理角色。

（3）代理（Proxy）角色：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。

2.2、类图

3、静态代理

静态代理是由程序创建或者特定工具自动生成源代码，在程序运行前，代理类的.class文件已经存在。

案例：

房东出租房屋，将出租和收回房子的事情都交给中介来完成，中介出租房屋后可以赚取到中介费。

3.1、案例类图

3.2、案例代码

/*** @ClassName IHouseOwner* @Description 出租房屋的接口-抽象主题角色* @Author chengjunyu* @Date 2022/12/8* @Version V1.0*/public interface IHouseOwner {/*** @Description: 出租房屋* @Author: chengjunyu*/void rentHouse();/*** @Description: 收回房屋* @Author: chengjunyu*/void takeBackHouse();}/*** @ClassName HouseOwner* @Description 房东-具体主题角色* @Author chengjunyu* @Date 2022/12/8* @Version V1.0*/public class HouseOwner implements IHouseOwner {/*** @Description: 出租房屋* @Author: chengjunyu*/@Overridepublic void rentHouse() {System.out.println("房屋闲置，房东要出租房屋");}/*** @Description: 收回房屋* @Author: chengjunyu*/@Overridepublic void takeBackHouse() {System.out.println("房屋到期，房东要收回房屋");}}/*** @ClassName HouseOwnerProxy* @Description 代理角色* @Author chengjunyu* @Date 2022/12/8* @Version V1.0*/public class HouseOwnerProxy implements IHouseOwner {private IHouseOwner houseOwner;public HouseOwnerProxy(IHouseOwner houseOwner) {this.houseOwner = houseOwner;}/*** @Description: 出租房屋* @Author: chengjunyu*/@Overridepublic void rentHouse() {this.houseOwner.rentHouse();System.out.println("帮房东出租了房子，挣取佣金2000元");}/*** @Description: 收回房屋* @Author: chengjunyu*/@Overridepublic void takeBackHouse() {this.houseOwner.takeBackHouse();System.out.println("帮房东收回了房子");}}/*** @ClassName Client* @Description 业务场景* @Author chengjunyu* @Date 2022/12/8* @Version V1.0*/public class Client {public static void main(String[] args) {//创建抽象主题角色IHouseOwner houseOwner = new HouseOwner();//创建代理类，通过代理类来完成具体主题角色需要做的事情HouseOwnerProxy proxy = new HouseOwnerProxy(houseOwner);proxy.rentHouse();proxy.takeBackHouse();}}

执行结果：

房屋闲置，房东要出租房屋

帮房东出租了房子，挣取佣金2000元

房屋到期，房东要收回房屋

帮房东收回了房子

从上面代码中可以看出业务场景直接访问的是 IHouseOwner 类对象，也就是说 IHouseOwner 作为访问对象和目标对象的中介，同时也对 rentHouse() 和 takeBackHouse() 方法做出了增强。

4、JDK 动态代理

JDK 动态代理要求目标对象实现一个接口。

Java 中提供了一个动态代理类 Proxy，Proxy 不是静态代理中所说的代理对象的类，而是提供了一个创建代理对象的静态方法（newProxyInstance()）来获取代理对象。

4.1、案例代码

在JDK动态代理中，不再需要去手动创建一个代理类来完成目标对象的执行方法。

/*** @ClassName IHouseOwner* @Description 抽象主题角色* @Author chengjunyu* @Date 2022/12/8* @Version V1.0*/public interface IHouseOwner {/*** @Description: 出租房屋* @Author: chengjunyu*/void rentHouse();/*** @Description: 收回房屋* @Author: chengjunyu*/void takeBackHouse();}/*** @ClassName HouseOwner* @Description 房东-具体主题角色* @Author chengjunyu* @Date 2022/12/8* @Version V1.0*/public class HouseOwner implements IHouseOwner {/*** @Description: 出租房屋* @Author: chengjunyu*/@Overridepublic void rentHouse() {System.out.println("房屋闲置，房东要出租房屋");}/*** @Description: 收回房屋* @Author: chengjunyu*/@Overridepublic void takeBackHouse() {System.out.println("房屋到期，房东要收回房屋");}}/*** @ClassName ProxyFactory* @Description  获取代理对象的工厂类* @Author chengjunyu* @Date 2022/12/8* @Version V1.0*/public class ProxyFactory {//1、声明目标对象private HouseOwner houseOwner = new HouseOwner();/*** @Description: 获取代理对象的方法* @Author: chengjunyu*/public IHouseOwner getHouseOwner() {//2、返回代理对象/** ClassLoader loader： 类加载器，用于加载代理类（程序运行中动态的在内存中生成的类），通过目标对象获取* Class<?>[] interfaces：代理类实现的接口的字节码对象* InvocationHandler h：代理对象的调用处理程序*/IHouseOwner proxyObject = (IHouseOwner) Proxy.newProxyInstance(houseOwner.getClass().getClassLoader(),houseOwner.getClass().getInterfaces(),//匿名内部类，重写 invoke 方法new InvocationHandler() {/** Object proxy：代理对象，和 proxyObject 是同一个对象，在 invoke 方法中基本上不使用* Method method：对接口中的方法进行封装的 method 对象* Objects[] args：调用方法的实际参数*/@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Object object =  method.invoke(houseOwner, args);if ("rentHouse".equals(method.getName()))  {System.out.println("帮房东出租了房子，挣取佣金2000元");}if ("takeBackHouse".equals(method.getName())) {System.out.println("帮房东收回了房子");}return object;}});return proxyObject;}}/*** @ClassName Client* @Description 业务场景* @Author chengjunyu* @Date 2022/12/8* @Version V1.0*/public class Client {public static void main(String[] args) {//获取代理对象//1、创建代理对象工厂ProxyFactory proxyFactory = new ProxyFactory();//2、使用factory对象的方法获取代理对象IHouseOwner houseOwner = proxyFactory.getHouseOwner();//调用租房方法houseOwner.rentHouse();//调用收回房屋方法houseOwner.takeBackHouse();}}

执行结果：

房屋闲置，房东要出租房屋

帮房东出租了房子，挣取佣金2000元

房屋到期，房东要收回房屋

帮房东收回了房子

4.2、底层原理

在学习JDK动态代理的底层原理之前，可以先考虑一个问题：ProxyFactory是代理类吗？

ProxyFactory 不是代理模式中所说的代理类，代理类是程序在运行过程中动态的在内存中生成的类。

我么可以通过阿里巴巴开源的 Java 诊断工具（Arthas【阿尔萨斯】）查看代理类的结构，操作步骤如下：

1、运行指令 java -jar arhtas-boot.jar 启动 Arthas；

2、运行指令 jad com.sun.proxy.$Proxy0 获取该类源码；

3、优化源码，优化后的源码如下：

package com.sun.proxy;import com.design.pattern.proxy.jdkProxy.IHouseOwner;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.lang.reflect.UndeclaredThrowableException;public final class $Proxy0 extends Proxy implements IHouseOwner {private static Method m1;private static Method m2;//构造方法提供了有参构造，参数为 InvocationHandler 对象，赋值给了父类 Proxypublic $Proxy0(InvocationHandler invocationHandler) {super(invocationHandler);}static {//获取IHouseOwner字节码对象后获取方法m1 = Class.forName("com.design.pattern.proxy.jdkProxy.IHouseOwner").getMethod("rentHouse", new Class[0]);m2 = Class.forName("com.design.pattern.proxy.jdkProxy.IHouseOwner").getMethod("takeBackHouse", new Class[0]);}//调用了 InvocationHandler 的子实现类对象的 invoke 方法public final void rentHouse() {//此处h即为InvocationHandler对象，this表示本类，m1为rentHouse方法this.h.invoke(this, m1, null);}public final void takeBackHouse() {this.h.invoke(this, m2, null);}}//父类Proxypublic class Proxy {protected InvocationHandler invocationHandler;}

从上面的类中，我们可以看到以下几个信息：

1、代理类（$Proxy0）实现了 IHouseOwner ，这也就印证了我们之前说的真实类和代理类实现同样的接口；

2、代理类（$Proxy0）将我们提供了的匿名内部类对象传递给了父类。

4.3、执行流程说明

根据JDK动态代理示例代码和底层原理代码，我们可以分析出JDK动态代理的执行流程如下：

1、在业务场景中通过代理对象调用 rentHouse() 和 takeBackHouse()；

2、根据多态的特性，执行的是代理类（$Proxy0）中的 rentHouse() 和 takeBackHouse()；

3、代理类（$Proxy0）中的 rentHouse() 方法和 takeBackHouse() 方法中又调用了 InvocationHandler 接口的子实现类对象的 invoke() 方法；

4、invoke 方法通过反射执行了真实对象所属类（HouseOwner）中的rentHouse() 和 takeBackHouse()。

5、CGLib 动态代理

有时候目标对象只是一个单独的对象，并没有实现接口，这个时候就可以使用CGLIB代理，它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。

CGLIB动态代理基于继承来实现代理，所以无法对 final 类、private 和 static 方法实现代理。

5.1、案例代码

同样是上面的案例，这里我们使用CGLIB代理实现。

如果没有定义IHouseOwner接口，只定义了HouseOwner（房屋所有者类），很显然JDK动态代理就无法使用了，因为JDK动态代理要求必须定义接口，对接口进行代理。

CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。

CGLIB是第三方提供的包，所以在Spring框架下需要引入jar包的maven坐标。

<dependency>

<groupId>cglib</groupId>

<artifactId>cglib</artifactId>

<version>3.3.0</version>

</dependency>

代码如下：

/*** @ClassName HouseOwner* @Description 房东-具体主题角色* @Author chengjunyu* @Date 2022/12/8* @Version V1.0*/public class HouseOwner {/*** @Description: 出租房屋* @Author: chengjunyu*/public void rentHouse() {System.out.println("房屋闲置，房东要出租房屋");}/*** @Description: 收回房屋* @Author: chengjunyu*/public void takeBackHouse() {System.out.println("房屋到期，房东要收回房屋");}}/*** @ClassName ProxyFactory* @Description 代理工厂类* @Author chengjunyu* @Date 2022/12/10* @Version V1.0*/public class ProxyFactory implements MethodInterceptor {private HouseOwner houseOwner = new HouseOwner();public HouseOwner getProxyObject() {//1、创建Enhancer对象，类似于JDK动态代理中的Proxy类Enhancer enhancer = new Enhancer();//2、设置父类的字节码对象，指定父类enhancer.setSuperclass(HouseOwner.class);//3、设置回调函数enhancer.setCallback(this);//4、创建代理对象，即目标类对象的子对象HouseOwner proxyObject = (HouseOwner) enhancer.create();return proxyObject;}/*** @Description: 方法所属类的回调函数* @Author: chengjunyu*/@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println("调用了回调函数");Object object = method.invoke(this.houseOwner, objects);return object;}}/*** @ClassName Client* @Description 业务场景类* @Author chengjunyu* @Date 2022/12/10* @Version V1.0*/public class Client {public static void main(String[] args) {//创建代理工厂对象ProxyFactory factory = new ProxyFactory();//获取代理对象HouseOwner proxyObject = factory.getProxyObject();//调用代理对象中的方法proxyObject.rentHouse();proxyObject.takeBackHouse();}}

6、三种代理的对比

6.1、JDK代理和CGLib代理

使用CGLib实现动态代理，CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，在JDK1.6之前比使用反射效率要高。唯一需要注意的是，CGLib不能对声明为final的类或者方法进行处理，因为CGLib原理是动态生成被代理的子类。

在JDK1.6、JDK1.7、JDK1.8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于CGLib代理效率，只有当进行大量调用的时候，JDK1.6和JDK1.7比CGLib的代理效率低一些，但是到JDK1.8的时候，JDK代理效率高于CGLib代理，所以如果有接口使用JDK动态代理，如果没有接口则使用CGLib代理。