Java动态代理技术-我的浅显认识

    说到代理，大家不由想到23种设计模式中的代理模式。JDK的动态代理技术正是基于代理模式，并且核心使用了反射机制实现的。首先，便于理解，我们看看demo级别的代理模式（也就对应地叫做静态代理）：

interface Person {public void doSomething();    }    class User implements Person {    public void doSomething() {    System.out.print("基类方法");    }    }      class Proxy implements Person {    User  user;     public Proxy() { // 初始类时得到被代理类的实例         this.user = new User();    }    public void doSomething() {    System.out.print("前-");    user.doSomething();    System.out.print("-后");    }    }     /////////////////////////////////////////////////////////////////////////////////   public void main(String[] strs){        Person proxy=new Proxy();        proxy.doSomething();    }

    输出：前-基类方法-后
    对于以上实现，我们发现了静态代理模式的一些繁琐之处：每需要代理一个类时，需要程序员手动为其构造类似如上代理类代码。于是JDK出现了动态代理技术来解决这一窘境。下面先看看它的基本使用方式：

    

// 调用处理器：代理类的相应方法被执行会均会调用该处理器，而该处理器则会调用被代理类方法完成操作    class MyInvocationHandler implements InvocationHandler {private Object metaObj;public MyInvocationHandler(Object obj) {this.metaObj = obj;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.print("前-");Object obj = method.invoke(metaObj, args);                System.out.println("-后");                return obj;}    }     /////////////////////////////////////////////////////////////////////////////////    public static void main(String[] args) {MyInvocationHandler myHandler = new MyInvocationHandler(new User());Person proxy= (Person) Proxy.newProxyInstance(User.class.getClassLoader(), User.class.getInterfaces(),myHandler);proxy.doSomething();} 

    输出：前-基类方法-后

    对于以上就是动态代理的一个简单使用，我们可以发现：使用动态代理，我们将能够应对任何需要代理的类，并为其生产代理类。仅需要在调用生成代理实例的newProxyInstance方法时传入适当的参数（该类的类加载器，该类所实现的所有接口，调用处理器）。我们来看看它的大概实现，下面给出关键代码（我只是将核心代码进行内联，便于观看，其实远不止这点代码）：

     @CallerSensitive     public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h){                Class<?> proxyClass = null;  //待生成的代理类的类类型              //根据提供的接口生成代理类字节数组流。ProxyGenerator为rt.jar包中负责生成代理类字节数组流工具，proxyName为生成的代理           //class文件的名字，由省略代码给出        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);                 //由类加载器将字节数组流生成为一个新类，并加载到内存中，然后返回其类类型。        proxyClass = defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);        //根据代理类的类类型获取其中含有{ InvocationHandler.class } 参数的构造器        final Constructor<?> cons = proxyClass .getConstructor({ InvocationHandler.class });        //根据该构造器，实例化代理类，并让调用处理器进入该实例中        return cons.newInstance(new Object[] {h} );    }

由上代码，我们可以看到，通过指定类装载器和一组相关接口就可以生成代理类实例。而InvocationHandler调用处理器仅是作为一个参数进入到了生成的这个实例中。那么此时有两个问题：

      1.上面含有{ InvocationHandler.class } 参数的构造器是怎么产生的？

     代理类起自ProxyGenerator.generateProxyClass方法，究其实现可发现如下代码：

methods.add(generateConstructor());     private MethodInfo generateConstructor()throws IOException{        MethodInfo methodinfo = new MethodInfo("<init>", "(Ljava/lang/reflect/InvocationHandler;)V", 1);        DataOutputStream dataoutputstream = new DataOutputStream(methodinfo.code);        code_aload(0, dataoutputstream);        code_aload(1, dataoutputstream);        dataoutputstream.writeByte(183);        dataoutputstream.writeShort(cp.getMethodRef("java/lang/reflect/Proxy", "<init>", "(Ljava/lang/reflect/InvocationHandler;)V"));        dataoutputstream.writeByte(177);        methodinfo.maxStack = 10;        methodinfo.maxLocals = 2;        methodinfo.declaredExceptions = new short[0];        return methodinfo;    }

      很明显，构造器就是在这里被加入进去的，且参数类型明确指出是Ljava/lang/reflect/InvocationHandler。

    2.InvocationHandler的作用又到底是什么呢？

  先看看代理类生成为class文件的相关核心代码：

public final void doSomething(){        this.invocationHandler.invoke(this, m3, null); //this表示代理类实例        return;    }    static{        m3 = Class.forName("My程序.动态代理.Person").getMethod("doSomething", new Class[0]);        return;    }结合调用处理器看：    // 调用处理器：代理类的相应方法被执行会均会调用该处理器，而该处理器则会调用被代理类方法完成操作    class MyInvocationHandler implements InvocationHandler {private Object metaObj;public MyInvocationHandler(Object obj) {this.metaObj = obj;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.print("前-");Object obj = method.invoke(metaObj, args);                System.out.println("-后");                return obj;}    } 

    我们需要让代理类去管控被代理类（代理模式设计原则），也就是比如在调用之前或者之后能进行一些额外操作（如上面的“前-”、“-后”）。而代理类都是运行时动态生成的，那么这些额外操作怎么才能放进去呢？这时，InvocationHandler作用就出现了。额外操作的编码就放在Invocation中，然后让InvocationHandler进入动态生成的代理类实例，实例来调用InvocationHandler的方法即可。