代理模式（jdk proxy）

以你之姓@ 2022-12-19 13:10 113阅读 0赞

# 什么是代理 #

**举个栗子**  
    比如有一家美国的大学，可以对全世界招生。但是对于家长来说，家长不能直接自己去找学校，家长没有能力去直接访问学校，或者说，美国学校不接受个人来访，那么此时就需要一个留学中介来帮助这家美国学校招

生，中介就是学校的代理。中介和学校要做的事情是一致：招生。对于家长来说，学校就是目标，留学中介就是代理。日常生活中，有许多代理的例子，比如：代购，房产中介，各种中介，换ip，商家厂家和买家。在开发中

也有同样的情况，比如，你有a类， 本来是调用c类的方法， 完成某个功能。 但是c不让a调用。 a -----不能调用 c的方法。在a 和 c 直接 创建一个 b 代理，    c让b访问。 a --访问b---访问c。

原来的访问关系

![20201107175549378.png][]

通过代理的访问关系

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70][]

# 什么是代理模式 #

**百度百科**

代理模式是指，为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户类和目标对象之间起到中介的作用。

换句话说，使用代理对象，是为了在不修改目标对象的基础上，增强主业务逻辑。**客户类真正的想要访问的对象是目标对象**，但客户类真正可以访问的对象是代理对象。客户类对目标对象的访问是通过访问代理对象来实现

的。当然，代理类与目标类要实现同一个接口。

# 实现代理的方式 #

## 静态代理 ##

静态代理是指，代理类在程序运行前就**已经定义好.java 源文件**，其与**目标类的关系在程序运行前就已经确立**。在程序运行前代理类已经编译为.class 文件。

举一个静态代理的例子

需求：用户需要购买 u 盘，u 盘厂家不单独接待零散购买，厂家规定一次最少购买 1000个以上，用户可以通过淘宝的代理商，或者微商哪里进行购买。淘宝上的商品，微商都是 u 盘工厂的代理商， 他们代理对 u 盘的销售业

务。用户购买-------代理商（淘宝，微商）----- u 盘厂家（金士顿，闪迪等不同的厂家）

**1、定义业务接口**

定义业务接口UsbSell(目标接口)，其中含有抽象方法sell(int amout);sell是目标方法

public interface UsbSell {
        /**
         * 表示功能的，厂家和商家都要完成的功能
         * @param amount
         * @return
         */
        float sellUsb(int amount);
    }

**2、定义接口的实现类**

目标类UsbKingFactory金士顿U盘，该类实现了接口

import school.xauat.service.UsbSell;
    
    public class UsbKingFactory  implements UsbSell {
        @Override
        /**
         * 定义金士顿厂家的销售价格
         */
        public float sellUsb(int account) {
            return 75.0f;
        }
    }

**3、定义代理**

TaoBao就是一个代理类，代理厂家销售U盘

import school.xauat.factory.UsbKingFactory;
    import school.xauat.service.UsbSell;
    
    public class Taobao implements UsbSell {
        //声明 商家代理的厂家具体是哪一家
        private UsbSell factory=new UsbKingFactory();
        @Override
        /**
         * 实现销售U盘的功能
         */
        public float sellUsb(int account) {
            float price=factory.sellUsb(account);
            //代理增强功能
            price+=25;
            return price;
        }
    }

WeiShang也是一个代理类代理厂家销售U盘

import school.xauat.factory.UsbKingFactory;
    import school.xauat.service.UsbSell;
    
    public class Weishang implements UsbSell {
        //声明 商家代理的厂家具体是哪一家
        private UsbSell factory=new UsbKingFactory();
        @Override
        public float sellUsb(int amount) {
            float price=factory.sellUsb(amount);
            //代理增强功能
            price+=15;
            return price;
        }
    }

4、客户端调用者，购买商品类

客户端可以通过Taobao和WeiShang两个代理来购买U盘

import school.xauat.business.Taobao;
    import school.xauat.business.Weishang;
    
    public class ShopMain {
        public static void main(String[] args) {
            Taobao taoBao=new Taobao();
            float price=taoBao.sellUsb(1);
            System.out.println(price);
            Weishang weishang=new Weishang();
            float price2=weishang.sellUsb(1);
            System.out.println(price2);
        }
    }

### 根据以上过程，分析静态代理的优缺点 ###

优点：实现简单，易于理解

缺点：

**代码复杂，难于管理**

代理类和目标类实现了相同的接口，每个代理都需要实现目标类的方法，这样就出现了大量的代码重复。如果接口增加一个方法，除了所有目标类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂

度。

**代理类依赖目标类，代理类过多**

代理类只服务于一种类型的目标类，如果要服务多个类型。势必要为每一种目标类都进行代理，静态代理在程序规模稍大时就无法胜任了，代理类数量过多。

## 动态代理 ##

动态代理是指代理类对象在程序运行时由 JVM 根据反射机制动态生成的。动态代理不需要定义代理类的.java 源文件。

动态代理其实就是 jdk 运行期间，动态创建 class 字节码并加载到 JVM。

动态代理的实现方式常用的有两种：使用 **JDK 动态代理（这里主要讲）**，与通过 **CGLIB 动态代理**。

### **CGLIB代理** ###

CGLIB(Code Generation Library)是一个开源项目。是一个强大的，高性能，高质量的 Code 生成类库，它可以在运行期扩展 Java 类与实现 Java 接口。它广泛的被许多 AOP 的框架使用，例如 Spring AOP。使用 JDK 的

Proxy 实现代理，要求目标类与代理类实现相同的接口。若目标类不存在接口，则无法使用该方式实现。但对于无接口的类，要为其创建动态代理，就要使用 CGLIB 来实现。CGLIB 代理的生成原理是生成目标类的子类，而

子类是增强过的，这个子类对象就是代理对象。所以，使用CGLIB 生成动态代理，要求目标类必须能够被继承，即不能是 final 的类。cglib 经常被应用在框架中，例如 Spring ，Hibernate 等。Cglib 的代理效率高于 Jdk。对

于 cglib 一般的开发中并不使用。做了一个了解就可以。

### JDK代理 ###

jdk 动态代理是基于 Java 的反射机制实现的。使用 jdk 中接口和类实现代理对象的动态创 建。 Jdk 的动态要求目标对象必须实现接口，这是 java 设计上的要求。 从 jdk1.3 以来，java 语言通过 java.lang.reflect 包提供三个类

支持代理模式 **Proxy**, **Method** 和 **InovcationHandler**。

### InvocationHandler接口 ###

InvocationHandler 接口叫做调用处理器，负责完调用目标方法，并增强功能。通 过 代 理 对 象 执 行 目 标 接 口 中 的 方 法 ， 会 把 方 法 的 调 用 分 派 给 调 用 处 理 器(InvocationHandler)的实现类，执行实现类中的 i

nvoke()方法，我们需要把功能代理写在 invoke()方法中 。

![20201107191359192.png][]

在 invoke 方法中可以截取对目标方法的调用。在这里进行功能增强。Java 的动态代理是建立在反射机制之上的。实现了 InvocationHandler 接口的类用于加强目标类的主业务逻辑。这个接口中有一个方法 invoke()，具体加

强的代码逻辑就是定义在该方法中的。通过代理对象执行接口中的方法时，会自动调用 invoke()方法。

**invoke()方法的介绍如下**：

**public Object invoke ( Object proxy, Method method, Object\[\] args)**

**proxy：代表生成的代理对象**

**method：代表目标方法**

**args：代表目标方法的参数**

第一个参数 proxy 是 jdk 在运行时赋值的，在方法中直接使用，第二个参数后面介绍，第三个参数是方法执行的参数， 这三个参数都是 jdk 运行时赋值的，无需程序员给出。

### Method类 ###

invoke()方法的第二个参数为 Method 类对象，该类有一个方法也叫 invoke()，可以调用目标方法。这两个 invoke()方法，虽然同名，但无关。

public Object invoke ( Object obj, Object... args)

obj：表示目标对象

args：表示目标方法参数，就是其上一层 invoke 方法的第三个参数

该方法的作用是：调用执行 obj 对象所属类的方法，这个方法由其调用者 Method 对象确定。

在代码中，一般的写法为

method.invoke(target, args);

其中，method 为上一层 invoke 方法的第二个参数。这样，即可调用了目标类的目标方法。

### Proxy类 ###

通 过 JDK 的 java.lang.reflect.Proxy 类 实 现 动 态 代 理 ， 会 使 用 其 静 态 方 法newProxyInstance()，依据目标对象、业务接口及调用处理器三者，自动生成一个动态代理对象。

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

**loader：目标类的类加载器，通过目标对象的反射可获取**

**interfaces：目标类实现的接口数组，通过目标对象的反射可获取**

**handler：调用处理器。**

## jdk动态代理的实现步骤 ##

jdk 动态代理是代理模式的一种实现方式，其只能代理接口。

实现步骤

**1、新建一个接口，作为目标接口**

**2、为接口创建一个实现类，是目标类**

**3、创建类实现 java.lang.reflect.InvocationHandler 接口，调用目标方法并增加其他功能代码**

**4、创建动态代理对象，使用 Proxy.newProxyInstance()方法，并把返回值强制转为接口类型。**

举例

1、创建目标接口，定义目标接口功能

2、为接口创建实现类

以上两步同静态代理

3、创建InvocationHandler接口的实现类，调用目标方法和增加其他代码功能

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    
    public class MySellHandler implements InvocationHandler {
        //目标对象
        private Object target=null;
        public MySellHandler(Object target){
            this.target=target;
        }
        @Override
        /**
         * 实现InvocationHandler接口的实现类，在invoke方法中完成代理类的功能
         *      -调用目标方法
         *      -功能增强
         */
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object result=null;
            result=method.invoke(target,args);
    
    
            //功能增强
            //这里为了简化，我们将功能增强定义为加价25元
            if (result!=null){
                float price=(float)result;
                price=price+25;
                result=price;
            }
    
            return result;
        }
    }

**这里的target对象相当于静态代理中的TaoBao和WeiShang **

4、模拟客户购买U盘，使用proxy.newProxyInstance创建Proxy代理对象并且使返回值为目标接口类型

import school.xauat.factory.UsbKingFactory;
    import school.xauat.handler.MySellHandler;
    import school.xauat.service.UsbSell;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    
    public class MainShop {
        public static void main(String[] args) throws Exception {
            //创建目标对象
            Class c=UsbKingFactory.class;
            Object obj=c.newInstance();
    
            //获得目标类的类加载器
            ClassLoader loader =UsbKingFactory.class.getClassLoader();
            //获取目标类实现的接口数组
            Class<?>[]interfaces=obj.getClass().getInterfaces();
            //创建InvocationHandler对象
            InvocationHandler handler=new MySellHandler(obj);
    
            //创建代理对象
            UsbSell proxy=(UsbSell) Proxy.newProxyInstance(loader,interfaces,handler);
    
            //通过这个代理执行方法
            float price=proxy.sell(1);
            System.out.println(price);
        }
    }

静态代理

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70 1][]

动态代理

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70 2][]

UML图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70 3][]

[20201107175549378.png]: /images/20221120/691901920266487d9d07f9f3b7be5d60.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70]: /images/20221120/5bf0313d6df44cde8127b77cd4dc5f97.png
[20201107191359192.png]: https://img-blog.csdnimg.cn/20201107191359192.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20201107192931206.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20201107192953623.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20201107193041860.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1Nzk2MjA4,size_16,color_FFFFFF,t_70