代理模式--动态代理

动态代理：
动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。

1.实现动态代理的基础接口和类

java.lang.reflect.Proxy
这是 Java 动态代理机制生成的所有动态代理类的父类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。

// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器static InvocationHandler getInvocationHandler(Object proxy) // 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象static Class getProxyClass(ClassLoader loader, Class[] interfaces) // 方法 3：该方法用于判断指定类对象是否是一个动态代理类static boolean isProxyClass(Class cl) // 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 

java.lang.reflect.InvocationHandler
这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。每次生成动态代理类对象时都要指定一个对应的调用处理器对象。

/**该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类例，第二个参数是被调用的方法对象。第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行。**/Object invoke(Object proxy, Method method, Object[] args) 

2、动态代理实现步骤

1. 实现InvocationHandler接口创建自己的调用处理器；
2. 给Proxy类提供ClassLoader和代理接口类型数组创建动态代理类 ；
3. 以调用处理器类型为参数，利用反射机制得到动态代理类的构造函数；
4. 以调用处理器对象为参数，利用动态代理类的构造函数创建动态代理类对象。

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用InvocationHandler handler = new InvocationHandlerImpl(..); // 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); // 通过反射从生成的类对象获得构造函数对象Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class }); // 通过构造函数对象创建动态代理类实例Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler }); 

Proxy类的静态方法newProxyInstance对上面具体步骤的后三步做了封装，简化了动态代理对象的获取过程。

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发InvocationHandler handler = new InvocationHandlerImpl(..); // 通过 Proxy 直接创建动态代理类实例Interface proxy = (Interface)Proxy.newProxyInstance( classLoader, new Class[] { Interface.class },  handler ); 

3、动态代理一个示例

InvocationHandlerImpl

package com.think.dynamicproxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;//代理处理器 /** * 该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值； * 此外，在该类还实现了invoke方法，该方法中的 method.invoke(sub,args); * 其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象， * args为执行被代理对象相应操作所需的参数。 * 通过动态代理类，我们可以在调用之前或之后执行一些相关操作 */public class DynamicSubject implements InvocationHandler{    private Object sub;    public DynamicSubject(Object obj){        sub = obj;    }    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        System.out.println("before calling " + method);        //利用反射机制将请求分派给委托类处理。Method的invoke返回Object对象作为方法执行结果。        method.invoke(sub, args);        System.out.println("after calling " + method);        return null;    }}

通过 Proxy 直接创建动态代理类实例

package com.think.dynamicproxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Proxy;public class Client{    public static void main(String[] args) throws Throwable{        // 在这里指定被代理类        RealSubject rs = new RealSubject();         /*         * InvocationHandlerImpl,即ds, 实现了 InvocationHandler 接口，并能实现方法调用从代理类到实际类的分派转发           * 其内部通常包含指向实际类实例的引用，用于真正执行分派转发过来的方法调用         */        InvocationHandler ds = new DynamicSubject(rs);        // 以下是一次性生成代理        Subject subject = (Subject) Proxy.newProxyInstance(rs.getClass().getClassLoader(), rs.getClass().getInterfaces(), ds);        subject.request();    }}

实际类：

package com.think.dynamicproxy;//具体角色public class RealSubject implements Subject{    public void request(){        System.out.println("From real subject.");    }}

静态代理类优缺点
优点：业务类只需要关注业务逻辑本身，保证了业务类的重用性。这是代理的共有优点。
缺点：
1）代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。
2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

5、动态代理的优点和美中不足
优点：
动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。在本示例中看不出来，因为invoke方法体内嵌入了具体的外围业务，实际中可以类似Spring AOP那样配置外围业务。

美中不足：
诚然，Proxy 已经设计得非常优美，但是还是有一点点小小的遗憾之处，那就是它始终无法摆脱仅支持 interface 代理的桎梏，因为它的设计注定了这个遗憾。回想一下那些动态生成的代理类的继承关系图，它们已经注定有一个共同的父类叫 Proxy。Java 的继承机制注定了这些动态代理类们无法实现对 class 的动态代理，原因是多继承在 Java 中本质上就行不通。

有很多条理由，人们可以否定对 class 代理的必要性，但是同样有一些理由，相信支持 class 动态代理会更美好。接口和类的划分，本就不是很明显，只是到了 Java 中才变得如此的细化。如果只从方法的声明及是否被定义来考量，有一种两者的混合体，它的名字叫抽象类。实现对抽象类的动态代理，相信也有其内在的价值。此外，还有一些历史遗留的类，它们将因为没有实现任何接口而从此与动态代理永世无缘。如此种种，不得不说是一个小小的遗憾。

静态代理通常只代理一个类，动态代理是代理一个接口下的多个实现类。
静态代理事先知道要代理的是什么，而动态代理不知道要代理什么东西，只有在运行时才知道，由JVM根据反射等机制动态的生成。
动态代理是实现JDK里的InvocationHandler接口的invoke方法，但注意的是代理的是接口，也就是你的业务类必须要实现接口，通过Proxy里的newProxyInstance得到代理对象。