JAVA设计模式之【代理模式】二（jdk动态代理）

接上篇JAVA设计模式之【代理模式】二（静态代理）http://blog.csdn.net/emma_joans/article/details/78564585

动态代理

上述代理方式为静态代理，下面讲述两种动态代理方式：

• jdk动态代理： 面向接口
• cglib动态代理：面向无接口

jdk动态代理

java动态代理类位于java.lang.reflect.Proxy包下，创建代理类对象的方式是：
1. 创建被代理的类以及接口
2. 创建一个实现接口InvocationHandler的类，也就是处理器对象，它必须实现invoke方法
3. 通过Proxy的静态方法 newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h)创建一个代理对象
4. 通过代理对象调用方法

创建处理器对象类源码参数说明:

实现InvocationHandler类，重写invoke方法/**    invoke方法参数说明*  public Object invoke(Object obj, Object... args)*  反射机制*  obj      被代理的对象（实际的对象）*  args method方法的参数*/

创建代理对象源码及参数说明：

public static Object newProxyInstance(ClassLoader loader,          Class<?>[] interfaces, InvocationHandler h)        throws IllegalArgumentException    {        ....    }

参数说明：

/*     * static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)      * 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。      *  参数:     *      ClassLoader loader:传递类加载器,加载类到内存中,创建class文件对象;可以传递本类的类加载器     *      Class<?>[] interfaces:传递ArrayList实现的接口List/Collection的Class文件对象     *      InvocationHandler h:创建一个InvocationHandler的实现类,重写接口中的方法invoke,对集合的方法进行判断     *       如果调用add方法,没有对集合进行修改,则允许执行     * 返回值类型:     *      Object:返回被代理后的方法返回值    */  

一个小栗子说明动态代理的实现过程：

1. 首先我们要定义一个接口：

/** * 接口 * @author wuqiong * */public interface IStudent {    public void study();    public int totalCourse(String name);}

定义一个实现类，实现这个接口：

/** * 实现接口，重写方法 * @author wuqiong * */public class StudentImpl implements IStudent {    public void study() {        System.out.println("学生学习...");    }    public int totalCourse(String name) {        return 9;    }}

利用java反射机制，创建处理器对象。真实对象需要实现InvocationHandler接口，重写invoke（）方法。

处理器对象如下：

/** * 处理器对象，反射机制 * @author wuqiong * */public class JDKDynamicInvocation implements InvocationHandler{    private Object target;    public JDKDynamicInvocation(Object target) {        this.target = target;    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        // 增强方法在真正方法执行之前执行        before();        Object result = method.invoke(target, args);        // 增强方法在真正方法执行之前执行        after();        return result;    }    /**     * 增强方法     */    public void before() {        System.out.println("起床去上学...");    }    /**     * 增强方法     */    public void after() {        System.out.println("骑自行车放学");    }}

下面是对代理类对象的测试：

/** * 动态代理类方法测试 * @author wuqiong * */public class JDKProxyTest{    public static void main(String[] args) {    // 创建真实对象    IStudent student = new StudentImpl();    // 创建处理器对象，将真实对象作为参数传给处理器对象    JDKDynamicInvocation jdkDynamicProxcy = new JDKDynamicInvocation(student);    // 创建代理类对象            IStudent studentProxy = (IStudent) Proxy.newProxyInstance(student.getClass().getClassLoader(),    student.getClass().getInterfaces(), jdkDynamicProxcy);    // 执行代理了对象的study（）方法    studentProxy.study();    }}

打印结果如下：

起床去上学...学生学习...骑自行车放学

我们可以看到，在执行study()方法之前执行了before()方法，打印“起床去上学…”，执行study()方法之后执行了after()方法，打印“骑自行车放学”。

老大让我干活了。下次继续。。。