Java代理模式详解及案例分析：静态代理/动态代理

标题：Java代理模式详解及案例分析：静态代理/动态代理

我们以几个问题，来开始我们今天的学习，如果下面几个问题，你都能说出个一二，那么恭喜你，你已经掌握了这方面的知识。
1，什么是代理模式？
2，Java中，静态代理与动态代理的区别？
3，Spring使用的是JDK的动态代理，还是CGLIB的动态代理？
4，JDK的动态代理的实现原理？
5，JDK的动态代理与CGLIB的动态代理的实现上，有何不同？
6，你知道的，还有其他动态代理技术吗？请简述实现原理。

OK，言归正传。



    Java的代理模式分为：静态代理和动态代理。首先我们需要搞清楚，什么是代理模式？注意，我们这里说的是JDK的代理模式。代理模式中，代
理类和委托类具有相同的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间
通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，
来提供特定的服务。
    说白了，JDK的代理模式，提供了另一种生成对象的方式。从程序结构上来说，JDK的代理模式，把代理类作为对象，代理代理类完成基本的功能，
并且增加了其他行为，我们可以在代理类执行之前（后），插入一段代码，完成其他的附加功能。我们可以把这种模式，看做是对生成对象的一种控制，
或者说是一种管理。Spring管理bean使用的就是动态代理。
    代理模式是23种设计模式之一，我们来回顾一下23种设计模式：
Factory（工厂模式）  
Builder（建造模式）  
Factory Method（工厂方法模式）  
Prototype（原始模型模式）  
Singleton（单例模式）  
Facade（门面模式）  
Adapter（适配器模式）  
Bridge（桥梁模式）  
Composite（合成模式）  
Decorator（装饰模式）  
Flyweight（享元模式）  
Proxy（代理模式）  
Command（命令模式）  
Interpreter（解释器模式）  
Visitor（访问者模式）  
Iterator（迭代子模式）  
Mediator（调停者模式）  
Memento（备忘录模式）  
Observer（观察者模式）  
State（状态模式）  
Strategy（策略模式）  
Template Method（模板方法模式）  
Chain Of Responsibleity（责任链模式）

    按照代理的创建时期，代理类可以分为：静态代理和动态代理。静态代理指的是，由程序员创建或特定工具自动生成源代码，再对其进行编译。
在程序运行前，代理类的.class文件就已经存在了。动态代理指的是，在程序运行时，运用反射机制动态生成源代码，再对其进行编译。
    只看概念，比较抽象，我们下面来看一下代码示例。我们先来看一下静态代理的组成要素：
* 一个接口
* 一个接口实现类
* 一个代理类，也实现了接口，是增强版的实现类[java] view plain copy/** 
 * @description 代理模式 之 静态代理 -- StaticProxyInterface接口 
 * @description 一个接口 
 */  
public interface StaticProxyInterface {  
    public void queryInfo();  
}  

[java] view plain copy/** 
 * @description 代理模式 之 静态代理 -- StaticProxyImpl实现类  
 * @description StaticProxyImpl，在代理模式中，叫做委托类，包含业务逻辑 
 * @description 一个接口实现类 
 */  
public class StaticProxyImpl implements StaticProxyInterface{  
    public void queryInfo() {  
        System.out.println("代理模式 之 静态代理 -- StaticProxyImpl实现类   查看信息...");  
    }  
}  

[java] view plain copy/** 
 * @description 代理模式 之 静态代理 -- StaticProxy代理类 
 * @description StaticProxy，在代理模式中，叫做代理类，增强StaticProxyImpl实现类  
 * @description 一个代理类，也实现了接口，是增强版的实现类 
 */  
public class StaticProxy  implements StaticProxyInterface{  
  
    private StaticProxyImpl staticProxyImpl;  
    public StaticProxy(StaticProxyImpl staticProxyImpl){  
        this.staticProxyImpl = staticProxyImpl;  
    }  
    public void queryInfo() {  
        // 事务处理之前，可以执行一段代码  
        System.out.println("事务处理之前...");  
        // 调用委托类的方法  
        staticProxyImpl.queryInfo();  
        // 事务处理之后，可以执行一段代码  
        System.out.println("事务处理之后...");  
    }  
}  

[java] view plain copy/** 
 * @description 代理模式 之 静态代理 
 * @description 测试类StaticProxyTest 
 * @description 什么是静态代理：静态代理指的是，由程序员创建或特定工具自动生成源代码，再对其进行编译。 
 * 在程序运行前，代理类的.class文件就已经存在了。 
 * @description 静态代理组成要素: 
 * 1,一个接口 
 * 2，一个接口实现类 
 * 3，一个代理类，也实现接口，是增强版的接口实现类 
 */  
public class StaticProxyTest {  
    public static void main(String[] args){  
        StaticProxyImpl staticProxyImpl = new StaticProxyImpl();  
        StaticProxy staticProxy = new StaticProxy(staticProxyImpl);  
        staticProxy.queryInfo();  
    }  
    /* 
     *     静态代理的一个缺点就是：我们需要为每一个接口生成一个代理类，也就是一个接口必然要对应一个代理类。这样 
     * 必然会生成很多的代理类，并且这些代理类的代码有很多重复的部分。解决这一问题，最好的办法就是通过一个代理类 
     * 完成全部的代理功能，此时就要使用动态代理。 
     */  
}  

    动态代理又可以分为2种：JDK的动态代理和CGLIB的动态代理，JDK的动态代理依赖具体的接口，需要绑定接口，如果一个类没有实现接口，
则不能使用JDK的动态代理。CGLIB的动态代理不依赖具体的接口，功能更加强大。下面我们分别进行说明，JDK的动态代理的关键是
InvocationHandler接口，先来看JDK的动态代理：[java] view plain copy/** 
 * @description 代理模式 之 JDK的动态代理 -- DynamicProxyInterface接口 
 * @description 一个接口 
 */  
public interface DynamicProxyInterface {  
    public void queryInfo();  
}  

[java] view plain copy/** 
 * @description 代理模式 之 JDK的动态代理 -- DynamicProxyImpl实现类  
 * @description DynamicProxyImpl，在代理模式中，叫做委托类，包含业务逻辑 
 * @description 一个接口实现类 
 */  
public class DynamicProxyImpl implements DynamicProxyInterface {  
  
    public void queryInfo() {  
        // TODO Auto-generated method stub  
        System.out.println("代理模式 之 JDK的动态代理 -- DynamicProxyImpl实现类   查看信息...");  
    }  
}  

[java] view plain copyimport java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
/** 
 * @description 代理模式 之 JDK的动态代理 -- DynamicProxy代理类 
 * @description DynamicProxy，在代理模式中，叫做代理类，增强DynamicProxyImpl实现类  
 * @description 一个代理类，实现了InvocationHandler接口 
 * @description JDK的动态代理 与 静态代理的区别就在这个代理类，静态代理类直接实现接口，而JDK的动态代理类不 
 * 直接实现具体的接口，而是实现了JDK提供的InvocationHandler接口。 
 */  
public class DynamicProxy implements InvocationHandler {  
    // 目标实现类，也就是某个接口的实现类，这里的target_interface_implements，可以看做是一种抽象  
    private Object target_interface_implements;  
    // 带参数构造方法，把目标实现类的对象作为参数传递进去，这里不是覆盖具体某个实现类的构造方法，而是抽象出来一个方法  
    public Object dynamicBindImplToProxyClass(Object target_interface_implements){  
        this.target_interface_implements = target_interface_implements;  
        // 取得代理对象  
        return Proxy.newProxyInstance(target_interface_implements.getClass().getClassLoader(),   
                target_interface_implements.getClass().getInterfaces(), this);  
        // JDK的动态代理依赖具体的接口，需要绑定接口，如果一个类没有实现接口，则不能使用JDK的动态代理  
    }  
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
        // TODO Auto-generated method stub  
        Object result = null;  
        // 事务处理之前，可以执行一段代码  
        System.out.println("事务处理之前...");  
        // 执行方法  
        result = method.invoke(target_interface_implements, args);  
        // 事务处理之后，可以执行一段代码  
        System.out.println("事务处理之后...");  
        return result;  
    }  
}  

[java] view plain copypackage com.ebank.action;  
/** 
 * @description 代理模式 之 JDK的动态代理 
 * @description 测试类DynamicProxyTest 
 * @description 动态代理指的是，在程序运行时，运用反射机制动态生成源代码，再对其进行编译。 
 * @description JDK的动态代理组成要素: 
 * 1,一个接口 
 * 2，一个接口实现类 
 * 3，一个代理类，实现了InvocationHandler接口 
 */  
public class DynamicProxyTest {  
    public static void main(String[] args){  
        DynamicProxy dynamicProxy = new DynamicProxy();  
        DynamicProxyInterface dynamicProxyForImpl = (DynamicProxyInterface) dynamicProxy.dynamicBindImplToProxyClass(new DynamicProxyImpl());  
        dynamicProxyForImpl.queryInfo();  
    }  
    /* 
     *    JDK的动态代理依靠具体的接口，如果有些类并没有实现，则不能使用JDK的动态代理，这时候就需要 
     * 使用CGLIB的动态代理 
     * // JDK的动态代理的关键是InvocationHandler接口 
     */  
}  

    接下来我们来分析一下JDK的动态代理的实现原理，JDK实现的动态代理，我们可以狭义的理解为，通过实现InvocationHandler接口，而实现的
动态代理。JDK的动态代理的实现需要依赖接口。拿上面的JDK的动态代理的示例代码来说，DynamicProxyImpl这个类，必须要实现某个接口，才
能借助InvocationHandler来实现动态代理，因为Proxy.newProxyInstance()这个方法中，需要传入代理类的接口作为参数。在示例中，我们的
DynamicProxyImpl类实现了DynamicProxyInterface接口。我们实现首先来看InvocationHandler接口的源代码：[java] view plain copypackage java.lang.reflect;  
public interface InvocationHandler {  
    /** 
     * Processes a method invocation on a proxy instance and returns the result.  This method will be invoked on an invocation  
     * handler when a method is invoked on a proxy instance that it is associated with. 
     * Processes ： 处理，加工，审核 
     * @param   proxy--the proxy instance that the method was invoked on 
     * 
     * @param   method--the Method instance corresponding to the interface method invoked on the proxy instance.  The declaring 
     * class of the Method object will be the interface that the method was declared in, which may be a  
     * superinterface of the proxy interface that the proxy class inherits the method through. 
     * 
     * @param   args--an array of objects containing the values of the arguments passed in the method invocation on the proxy  
     * instance, or null if interface method takes no arguments.Arguments of primitive types are wrapped in instances of the 
     * appropriate primitive wrapper class, such as Integer or Boolean. 
     * primitive ： 简单的，这里个人理解为基本的，primitive type 意为基本数据类型 
     * @return  the value to return from the method invocation on the proxy instance.  If the declared return type of the interface 
     * method is a primitive type, then the value returned by this method must be an instance of the corresponding primitive 
     * wrapper class; otherwise, it must be a type assignable to the declared return type.  If the value returned by this method is 
     * null and the interface method's return type is primitive, then a NullPointerException will be 
     * thrown by the method invocation on the proxy instance.  If the value returned by this method is otherwise not compatible with 
     * the interface method's declared return type as described above, a ClassCastException will be thrown by the method 
     * invocation on the proxy instance. 
     */  
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;  
}  

    然后，我们来看CGLIB的动态代理，CGLIB的动态代理的关键是MethodInterceptor接口，这个接口位于：net.sf.cglib.proxy.MethodInterceptor[java] view plain copy/** 
 * @description 代理模式 之 CGLIB的动态代理 -- CglibDynamicProxyImpl类  
 * @description CglibDynamicProxyImpl，在代理模式中，叫做委托类，包含业务逻辑 
 * @description 一个没有实现接口的类 
 */  
public class CglibDynamicProxyImpl {  
    public void queryInfo() {  
        // TODO Auto-generated method stub  
        System.out.println("代理模式 之 CGLIB的动态代理 -- CglibDynamicProxyImpl类   查看信息...");  
    }  
}  

[java] view plain copyimport java.lang.reflect.Method;  
import net.sf.cglib.proxy.Enhancer;  
import net.sf.cglib.proxy.MethodInterceptor;  
import net.sf.cglib.proxy.MethodProxy;  
/** 
 * @description 代理模式 之 CGLIB的动态代理 -- CglibDynamicProxy代理类 
 * @description CglibDynamicProxy，在代理模式中，叫做代理类，增强DynamicProxyImpl实现类  
 * @description 一个代理类，实现了MethodInterceptor接口 
 * @description CGLIB的动态代理 与 静态代理的区别就在这个代理类，静态代理类直接实现接口，而CGLIB的动态代理类不 
 * 直接实现具体的接口，而是实现了MethodInterceptor接口。 
 */  
public class CglibDynamicProxy implements MethodInterceptor {  
    // 目标实现类，也就是某个接口的实现类，这里的target_interface_implements，可以看做是一种抽象  
    private Object target_class;  
    // 创建代理对象  
    public Object getInstance(Object target_class){  
        this.target_class = target_class;  
        Enhancer enhancer = new Enhancer();  
        enhancer.setSuperclass(this.target_class.getClass());  
        // 回调方法  
        enhancer.setCallback(this);  
        // 创建代理对象  
        return enhancer.create();  
    }  
    // 回调方法  
    public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy proxy) throws Throwable {  
        // 事务处理之前，可以执行一段代码  
        System.out.println("事务处理之前...");  
        // 执行方法  
        proxy.invokeSuper(arg0, arg2);  
        // 事务处理之后，可以执行一段代码  
        System.out.println("事务处理之后...");  
        return null;  
    }  
}  

[java] view plain copy/** 
 * @description 代理模式 之 CGLIB的动态代理 
 * @description 测试类CglibDynamicProxyTest 
 * @description 动态代理指的是，在程序运行时，运用反射机制动态生成源代码，再对其进行编译。 
 * @description CGLIB的动态代理组成要素: 
 * 1，一个类 
 * 2，一个代理类，实现了MethodInterceptor接口 
 */  
public class CglibDynamicProxyTest {  
      
    public static void main(String[] args){  
        CglibDynamicProxy cglibDynamicProxy = new CglibDynamicProxy();  
        CglibDynamicProxyImpl cglibDynamicProxyImpl = (CglibDynamicProxyImpl) cglibDynamicProxy.getInstance(new CglibDynamicProxyImpl());  
        cglibDynamicProxyImpl.queryInfo();  
    }  
    // CGLIB的动态代理的关键是MethodInterceptor接口  
}  

    CGLIB实现的动态代理，要求委托类不能被final关键字修饰，因为在运行期间，通过Java的反射机制，会生成委托类的子类。我们都知道，一个
类，一旦被final关键字修饰，那么这个类就不能被继承。假如我们使用final关键字修饰了委托类，编译期间不会报错，但是程序运行时，会报错：
不能继承final类，如下：[java] view plain copyException in thread "main" java.lang.IllegalArgumentException: Cannot subclass final class class com.yangcq.CglibDynamicProxyImpl  
at net.sf.cglib.proxy.Enhancer.generateClass(Enhancer.java:446)  
at net.sf.cglib.core.DefaultGeneratorStrategy.generate(DefaultGeneratorStrategy.java:25)  
at net.sf.cglib.core.AbstractClassGenerator.create(AbstractClassGenerator.java:216)  
at net.sf.cglib.proxy.Enhancer.createHelper(Enhancer.java:377)  
at net.sf.cglib.proxy.Enhancer.create(Enhancer.java:285)  
at com.ebank.action.CglibDynamicProxy.getInstance(CglibDynamicProxy.java:24)  
at com.ebank.action.CglibDynamicProxyTest.main(CglibDynamicProxyTest.java:14)  

    CGLIB的动态代理的实现原理是什么样的呢？CGLIB为我们提供了MethodInterceptor接口，我们不需要依赖某个接口，也就是说，即使代理类没有
实现任何接口，也是可以借助CGLIB来实现动态代理的。CGLIB是借助Java反射机制，在运行期间为代理类生成一个子类，通过子类，来完成父类的动
态代理。下面我们来看一下MethodInterceptor的源代码：[java] view plain copypackage net.sf.cglib.proxy;  
import java.lang.reflect.Method;  
public abstract interface MethodInterceptor extends Callback{  
    public abstract Object intercept(Object paramObject, Method paramMethod, Object[] paramArrayOfObject,   
            MethodProxy paramMethodProxy) throws Throwable;  
}  

    实现动态代理，我们需要关注一个关键的类：public class Proxy implements java.io.Serializable
Proxy的源代码[java] view plain copypackage java.lang.reflect;  
import java.lang.ref.Reference;  
import java.lang.ref.WeakReference;  
import java.util.Arrays;  
import java.util.Collections;  
import java.util.HashMap;  
import java.util.HashSet;  
import java.util.Map;  
import java.util.Set;  
import java.util.WeakHashMap;  
import sun.misc.ProxyGenerator;  
public class Proxy implements java.io.Serializable {  
  
    private static final long serialVersionUID = -2222568056686623797L;  
    private final static String proxyClassNamePrefix = "$Proxy";  
    private final static Class[] constructorParams = { InvocationHandler.class };  
    private static Map loaderToCache = new WeakHashMap();  
    private static Object pendingGenerationMarker = new Object();  
    private static long nextUniqueNumber = 0;  
    private static Object nextUniqueNumberLock = new Object();  
    private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap());  
    protected InvocationHandler h;  
    // 私有构造函数，不允许程序员通过构造函数来实例化Proxy，生成Proxy的实例，需要调用newProxyInstance方法  
    private Proxy() {  
    }  
    // 受保护的构造函数，这个函数也不允许程序员直接调用  
    protected Proxy(InvocationHandler h) {  
        this.h = h;  
    }  
  
    public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) throws IllegalArgumentException{  
        // 这行代码，可以说明，在Class类文件的数据结构中，接口interfaces占用2个字节，最大值65535  
        if (interfaces.length > 65535) {  
            throw new IllegalArgumentException("interface limit exceeded");  
        }  
        Class proxyClass = null;  
        String[] interfaceNames = new String[interfaces.length];  
        // Set是无序，不可重复的集合  
        Set interfaceSet = new HashSet();  
        for (int i = 0; i < interfaces.length; i++) {  
            String interfaceName = interfaces[i].getName();  
            Class interfaceClass = null;  
            try {  
                // 通过接口名称和类加载器，获得接口实现类  
                interfaceClass = Class.forName(interfaceName, false, loader);  
            }   
            catch (ClassNotFoundException e) {  
            }  
            if (interfaceClass != interfaces[i]) {  
                throw new IllegalArgumentException(interfaces[i] + " is not visible from class loader");  
            }  
            if (!interfaceClass.isInterface()) {  
                throw new IllegalArgumentException(interfaceClass.getName() + " is not an interface");  
            }  
            if (interfaceSet.contains(interfaceClass)) {  
                throw new IllegalArgumentException("repeated interface: " + interfaceClass.getName());  
            }  
            interfaceSet.add(interfaceClass);  
            interfaceNames[i] = interfaceName;  
        }  
        Object key = Arrays.asList(interfaceNames);  
        Map cache;  
        synchronized (loaderToCache) {  
            cache = (Map) loaderToCache.get(loader);  
            if (cache == null) {  
                cache = new HashMap();  
                loaderToCache.put(loader, cache);  
            }  
        }  
        synchronized (cache) {  
            do {  
                Object value = cache.get(key);  
                if (value instanceof Reference) {  
                    proxyClass = (Class) ((Reference) value).get();  
                }  
                if (proxyClass != null) {  
                    return proxyClass;  
                }   
                else if (value == pendingGenerationMarker) {  
                    try {  
                        cache.wait();  
                    }   
                    catch (InterruptedException e) {  
                    }  
                    continue;  
                }   
                else {  
                    cache.put(key, pendingGenerationMarker);  
                    break;  
                }  
            } while (true);  
        }  
        try {  
            String proxyPkg = null;  
            for (int i = 0; i < interfaces.length; i++) {  
                int flags = interfaces[i].getModifiers();  
                if (!Modifier.isPublic(flags)) {  
                    String name = interfaces[i].getName();  
                    int n = name.lastIndexOf('.');  
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));  
                    if (proxyPkg == null) {  
                        proxyPkg = pkg;  
                    }   
                    else if (!pkg.equals(proxyPkg)) {  
                        throw new IllegalArgumentException("non-public interfaces from different packages");  
                    }  
                }  
            }  
            if (proxyPkg == null) {  
                proxyPkg = "";  
            }  
            {  
                long num;  
                synchronized (nextUniqueNumberLock) {  
                    num = nextUniqueNumber++;  
                }  
                String proxyName = proxyPkg + proxyClassNamePrefix + num;  
                byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);  
                try {  
                    proxyClass = defineClass0(loader, proxyName,  
                    proxyClassFile, 0, proxyClassFile.length);  
                }   
                catch (ClassFormatError e) {  
                    throw new IllegalArgumentException(e.toString());  
                }  
            }  
            proxyClasses.put(proxyClass, null);  
        }   
        finally {  
            synchronized (cache) {  
                if (proxyClass != null) {  
                    cache.put(key, new WeakReference(proxyClass));  
                }   
                else {  
                    cache.remove(key);  
                }  
                cache.notifyAll();  
            }  
        }  
        return proxyClass;  
    }  
  
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)  
            throws IllegalArgumentException{  
        if (h == null) {  
            throw new NullPointerException();  
        }  
        // 获得代理类，需要传递2个参数，类加载器和接口  
        Class cl = getProxyClass(loader, interfaces);  
        try {  
            // 获得代理类的构造函数  
            Constructor cons = cl.getConstructor(constructorParams);  
            // 通过构造函数，生成实例对象  
            return (Object) cons.newInstance(new Object[] { h });  
        }   
        catch (NoSuchMethodException e) {  
            throw new InternalError(e.toString());  
        }   
        catch (IllegalAccessException e) {  
            throw new InternalError(e.toString());  
        }   
        catch (InstantiationException e) {  
            throw new InternalError(e.toString());  
        }   
        catch (InvocationTargetException e) {  
            throw new InternalError(e.toString());  
        }  
    }  
  
    public static boolean isProxyClass(Class<?> cl) {  
        if (cl == null) {  
            throw new NullPointerException();  
        }  
        return proxyClasses.containsKey(cl);  
    }  
  
    public static InvocationHandler getInvocationHandler(Object proxy) throws IllegalArgumentException{  
        if (!isProxyClass(proxy.getClass())) {  
            throw new IllegalArgumentException("not a proxy instance");  
        }  
        Proxy p = (Proxy) proxy;  
        return p.h;  
    }  
    private static native Class defineClass0(ClassLoader loader, String name, byte[] b, int off, int len);  
}  

OK ，我们来回顾一下，开篇提出的几个问题：
1，什么是代理模式？
2，Java中，静态代理与动态代理的区别？
3，Spring使用的是JDK的动态代理，还是CGLIB的动态代理？
4，JDK的动态代理的实现原理？
5，JDK的动态代理与CGLIB的动态代理的实现上，有何不同？
6，你知道的，还有其他动态代理技术吗？请简述实现原理。