详解代理模式-【静态代理与JDK动态代理】（非常的斯国一）

静态代理

什么是静态代理:

特点:

例子：

JDK动态代理（主要讲点）

大纲：

1、与静态代码的联系

2、JDK动态代理的主流程

3、Proxy的源码

整体概述：

重要点的翻译：

newProxyInstance源码：

调用处理机制：

详解调用处理机制：

编辑

总结：

留言：

结言：

静态代理

什么是静态代理:

静态代理相当于是多写了一个代理类，在调用的时候调用的是代理类，在代理类中的处理还是原生的处理逻辑，不过在前后添加上需要添加的代码。

特点:

定义一个接口，该接口包含了要被代理对象的方法。
创建一个代理类，实现上述接口，并在方法中调用实际的被代理对象来执行相应的操作。
创建一个被代理对象的实例。
创建代理对象的实例，将被代理对象的实例传递给代理对象。
调用代理对象的方法，代理对象将方法调用传递给被代理对象进行处理。

例子：

如果要买火车票的话，需要去火车站买票，坐车到火车站，排队等一系列的操作，显然比较麻烦。而火车站在多个地方都有代售点，我们去代售点买票就方便很多了。这个例子其实就是典型的代理模式，火车站是目标对象，代售点是代理对象。类图如下：

代码如下：

//卖票接口
public interface SellTickets {
    void sell();
}

//火车站  火车站具有卖票功能，所以需要实现SellTickets接口
public class TrainStation implements SellTickets {

    public void sell() {
        System.out.println("火车站卖票");
    }
}

//代售点
public class ProxyPoint implements SellTickets {

    private TrainStation station = new TrainStation();

    public void sell() {
        System.out.println("代理点收取一些服务费用");
        station.sell();
    }
}

//测试类
public class Client {
    public static void main(String[] args) {
        ProxyPoint pp = new ProxyPoint();
        pp.sell();
    }
}

从上面代码中可以看出测试类直接访问的是ProxyPoint类对象，也就是说ProxyPoint作为访问对象和目标对象的中介。同时也对sell方法进行了增强（代理点收取一些服务费用）。

JDK动态代理（主要讲点）

大纲：

在这里我主要是根据下面三点来阐述

1、与静态代理的联系
2、JDK动态代理的主流程
3、java中提供的Proxy的源码

1、与静态代码的联系

前文所讲，静态代码实际就是多写了一个代理类，在调用的时候调用的是代理类，但这就还需要我们自己手写代理类了，接口不同所写的代理类就不同，这太麻烦了。那么JAVA开发组，就有个点子。

Java开发组：

我给你提供一个创建代理对象静态方法不就行了，这样以后你只需要给我代理类所需要的东西，传给我这个静态方法体里面的参数，不就好了。所以，Java中提供了一个动态代理类Proxy，Proxy并不是我们上述所说的代理对象的类，而是提供了一个创建代理对象的静态方法newProxyInstance来获取代理对象。至于Proxy中的这个方法，我们先不急说，先说说它的主流程。

2、JDK动态代理的主流程

我们在静态代理不变的逻辑上，进行思考。我们需要自己写一个代理类，代理类需要什么？代理的对象，还有其代理的对象的接口。我在前面也说了，动态代理实际就是让我们自己不需要重复的去写代理类，它给你了一个类可以创建你想要的代理对象。那么如何自动化去创建代理对象，只需要把代理对象所需要的东西给补全不就行了。的确，这个静态方法也是这样干的。

我们还是以上面的买票为例，将静态代理改为动态代理。来看一下，下面这串代码：

//卖票接口
public interface SellTickets {
    void sell();
}

//火车站  火车站具有卖票功能，所以需要实现SellTickets接口
public class TrainStation implements SellTickets {

    public void sell() {
        System.out.println("火车站卖票");
    }
}

//代理工厂，用来创建代理对象
public class ProxyFactory {

    private TrainStation station = new TrainStation();

    public SellTickets getProxyObject() {
        //使用Proxy获取代理对象
        /*
            newProxyInstance()方法参数说明：
                ClassLoader loader ： 类加载器，用于加载代理类，使用真实对象的类加载器即可
                Class<?>[] interfaces ： 真实对象所实现的接口，代理模式真实对象和代理对象实现相同的接口
                InvocationHandler h ： 代理对象的调用处理程序
         */
        SellTickets sellTickets = (SellTickets) Proxy.newProxyInstance(station.getClass().getClassLoader(),
                station.getClass().getInterfaces(),
                new InvocationHandler() {
                    /*
                        InvocationHandler中invoke方法参数说明：
                            proxy ： 代理对象
                            method ： 对应于在代理对象上调用的接口方法的 Method 实例
                            args ： 代理对象调用接口方法时传递的实际参数
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        System.out.println("代理点收取一些服务费用(JDK动态代理方式)");
                        //执行真实对象
                        Object result = method.invoke(station, args);
                        return result;
                    }
                });
        return sellTickets;
    }
}

//测试类
public class Client {
    public static void main(String[] args) {
        //提供了一个创建代理对象的类
        ProxyFactory factory = new ProxyFactory();
        //获取代理对象
        SellTickets proxyObject = factory.getProxyObject();//
        proxyObject.sell();
    }
}

看完这个代码，再结合我说的就很清晰了吧。那么接下来我们从java中提供的Proxy的源码，来打通你的任督二脉。

3、Proxy的源码

整体概述：

先来看这坨绿色玩意

用一下翻译器，再加点我这四级都没过的英语水平，为大家概述一下再讲什么东西

重要点的翻译：

翻译：Proxy提供静态方法来创建类似于接口实例的对象，但允许自定义方法调用

注：开发者规定的使用格式，没其他含义

翻译：代理类是在运行时创建的类，它实现了指定的接口列表，称为代理接口。代理实例是代理类的实例。每个代理实例都有一个关联的调用处理程序对象，该对象实现了接口InvocationHandler。通过代理实例的一个代理接口对代理实例的方法调用将被分派到实例调用处理程序的invoke方法，并传递代理实例java.lang.reflect。方法对象标识被调用的方法，以及包含参数的object类型的数组。调用处理程序根据需要处理编码的方法调用，它返回的结果将作为代理实例上方法调用的结果返回。

注：这里再讲其工作流程

注：这里在讲它提供的类的属性

下面具体看一下静态方法

newProxyInstance

开发者对它的阐述。

这里就不一一去翻译了，就把一些我自己认为很重要的翻译给放下面，如果想看就自己去java程序找找看吧：

返回指定接口的代理实例，该实例将方法调用分派给指定的调用处理程序。

参数：

loader–定义代理类的类加载器

interfaces–代理类要实现的接口列表

h–用于将方法调用分派到的调用处理程序
大概，就这样了，其他的巴拉巴拉的描述，感觉目前还接触不到那个等级，接下来看看人家写的源码

newProxyInstance源码：

private static Object newProxyInstance(Class<?> caller, // null if no SecurityManager
                                           Constructor<?> cons,
                                           InvocationHandler h) {
        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (caller != null) {
                checkNewProxyPermission(caller, cons.getDeclaringClass());
            }

            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException | InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        }
    }

注：

InvocationHandler是由代理实例的调用处理程序实现的接口。每个代理实例都有一个关联的调用处理程序。当在代理实例上调用方法时，方法调用会被编码并分派给其调用处理程序的invoke方法。

Invoke its constructor with the designated invocation handler.
使用指定的调用处理程序调用其构造函数

它让我们通过invoke来构造，InvocationHandler这个类。我们进入InvocationHandler，看看它的invoke源码

处理代理实例上的方法调用并返回结果。当在与其关联的代理实例上调用方法时，将在调用处理程序上调用此方法。

参数：

proxy-调用该方法的代理实例

method–与代理实例上调用的接口方法对应的method实例。Method对象的声明类将是声明该方法的接口，它可能是代理类继承该方法的代理接口的超级接口。

args–一个对象数组，包含代理实例上方法调用中传递的参数值，如果接口方法不接受参数，则为null。基元类型的参数被包装在相应的基元包装器类的实例中，例如java.lang.Integer或java.lang.Boolean。

返回：

从代理实例上的方法调用返回的值。如果接口方法的声明返回类型是基元类型，则此方法返回的值必须是相应基元包装器类的实例；否则，它必须是可分配给声明的返回类型的类型。如果此方法返回的值为null，并且接口方法的返回类型为基元，则代理实例上的方法调用将抛出NullPointerException。如果此方法返回的值与上述接口方法声明的返回类型不兼容，则代理实例上的方法调用将抛出ClassCastException。

投掷：

Throwable——从代理实例的方法调用中抛出的异常。异常的类型必须可分配给接口方法的throws子句中声明的任何异常类型，也可以分配给未经检查的异常类型java.lang.RuntimeException或java.lang.Error。如果此方法抛出的选中异常不可分配给接口方法的throws子句中声明的任何异常类型，则代理实例上的方法调用将抛出包含此方法抛出异常的UnclaredThrowableException。

好了不看源码了，再看我要昏了。继续捡起来刚才火车站的例子，来打断点，看运行

进入

factory.getProxyObject()

函数里面

发现没有，它并没有执行

new InvocationHandler() {}

里面的东西，而是直接返回了sellTickets这个对象，我们继续执行

发现没有，当我们调用了

proxyObject.sell();

的时候，它才进入

new InvocationHandler()

里面继续执行，这是为啥呢？

这就要提调用处理机制了。

调用处理机制：

每一个动态代理类的调用处理程序都必须实现InvocationHandler接口，并且每个代理类的实例都关联到了实现该接口的动态代理类调用处理程序中，当我们通过动态代理对象调用一个方法时候，这个方法的调用就会被转发到实现InvocationHandler接口类的invoke方法来调用。如此这般来实现对于方法的增强。

详解调用处理机制：

程序运行过程中动态生成的代理类

//程序运行过程中动态生成的代理类
public final class $Proxy0 extends Proxy implements SellTickets {
    private static Method m3;

    public $Proxy0(InvocationHandler invocationHandler) {
        super(invocationHandler);
    }

    static {
        m3 = Class.forName("com.itheima.proxy.dynamic.jdk.SellTickets").getMethod("sell", new Class[0]);
    }

    public final void sell() {
        this.h.invoke(this, m3, null);
    }
}

其中h为：

public class Proxy implements java.io.Serializable {
	protected InvocationHandler h;
	 
	protected Proxy(InvocationHandler h) {
        this.h = h;
    }
}