JAVA动态代理机制解析

1. 概述
　　首先，我们来思考如下两个问题：
　　什么是代理模式？为什么要使用代理模式？

　　简单总结一下，所谓的代理模式就是在原有的服务上多加一个占位，通过这个占位去控制服务的访问。通过代理模式，一方面可以控制如何访问真正的服务对象，提供额外服务；另一方面，有机会通过重写一些类来满足特定的需要。

　　在java的动态代理机制中，有两个重要的类或接口，一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class)，这一个类和接口是实现动态代理所必须用到的。下面我们具体分析一下：
　　（1）InvocationHandler接口：当通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler接口的 invoke 方法来进行调用。InvocationHanler的 invoke 方法如下：
　　Object invoke(Object proxy, Method method, Object[] args) throws Throwable
　　三个参数的具体含义如下：
　　　　proxy:　 代理的真实对象
　　　　method: 调用真实对象的某个方法的Method对象
　　　　args:　　调用真实对象某个方法时接收的参数

　　（2）Proxy类：这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是 newProxyInstance 这个方法，如下：
　　　　public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

　　这个方法的作用就是得到一个动态的代理对象，其接收三个参数，我们来看看这三个参数所代表的含义：

　　　　loader:　一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载；
　　　　interfaces:　一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了；
　　　　h:　　一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上

2. 示例

　　（1）我们先定义一个接口：

public interface Library {
    void isAvalid();
    void sayHello(String name);
}

　　（2）接口的实现类:

public class Book implements Library {
    @Override
    public void isAvalid() {
        System.out.println("This book can be borrowed! ");
    }

    @Override
    public void sayHello(String name) {
        System.out.println("Book name is: "+ name);
    }
}

　　（3）动态代理：

public class DynamicProxy implements InvocationHandler {
    private Object object;

    public DynamicProxy(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Bollow flow begin...");
        System.out.println("Method name is: "+ method);

        method.invoke(object, args);

        System.out.println("Bollow flow end...");
        return null;
    }
}

　　（4）测试类：

public class Reader {
    public static void main(String[] args) {
        Book book = new Book();
        InvocationHandler handler = new DynamicProxy(book);

        Library library = (Library) Proxy.newProxyInstance(handler.getClass().getClassLoader(),
                book.getClass().getInterfaces(), handler);

        System.out.println(library.getClass().getName());
        library.isAvalid();
        library.sayHello("<JAVA Concurrency In Practice>");
    }
}
结果输出：
$Proxy0
Bollow flow begin...
Method name is: public abstract void com.cn.dynamicProxy.Library.isAvalid()
This book can be borrowed! 
Bollow flow end...
Bollow flow begin...
Method name is: public abstract void com.cn.dynamicProxy.Library.sayHello(java.lang.String)
Book name is: <JAVA Concurrency In Practice>
Bollow flow end...

说明：

　　通过 Proxy.newProxyInstance 创建的代理对象是在jvm运行时动态生成的一个对象，它并不是我们的InvocationHandler类型，也不是我们定义的那组接口的类型，而是在运行是动态生成的一个对象，并且命名方式都是这样的形式，以$开头，proxy为中，最后一个数字表示对象的标号。

　　实际的运行方法：
　　　　Method name is: public abstract void com.cn.dynamicProxy.Library.isAvalid()
　　　　Method name is: public abstract void com.cn.dynamicProxy.Library.sayHello(java.lang.String)
　　所以，当我通过代理对象来调用方法的时候，实际上就是委托由其关联到的 handler 对象的invoke方法中来调用，并不是自己来真实调用，而是通过代理的方式来调用的。这就是java的动态代理机制。