java代理模式（jdk proxy）

什么是代理

举个栗子

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

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

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

原来的访问关系

通过代理的访问关系

什么是代理模式

百度百科

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

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

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

实现代理的方式

静态代理

静态代理是指，代理类在程序运行前就已经定义好.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()方法中 。

在 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);
    }
}

静态代理

动态代理

UML图

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注脚本之家的更多内容！

最新评论