设计模式四—"代理模式"（动态代理）

动态代理

动态代理就是通过使用字节码动态生成加载技术，在运行时生成并加载类。

常用的动态代理技术包括JDK动态代理，CGLIB等，其中JDK自带的动态代理使用简单，但是功能较弱，CGLIB是高级的字节码生成库，性能更好，而且功能强大。

先说说JDK动态代理的使用

动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 

JDK动态代理的使用核心是实现一个用来处理方法调用的接口InvocationHandler，在java.lang.reflect包中

public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

Object proxy指被代理的对象。

Method method指被调用的方法。

Object[] args方法调用传递的参数。

一个实现了InvocationHandler接口的类，就是我们使用的代理类。

Proxy类:Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：

使用的核心方法是该类提供的

 public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        if (h == null) {
            throw new NullPointerException();
        }

        /*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass(loader, interfaces);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            Constructor cons = cl.getConstructor(constructorParams);
            return 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());
        }
    }

ClassLoader loader：用来定义代理类的的类加载器

Class<?>[] interfaces：代理类需要实现的一系列接口

InvocationHandler h：实现分发方法调用的的InvocationHandler

这个工厂方法根据需求生成指定的代理类。

实现一个示例，还是一个与静态代理例子的类似的sample

（1）主题接口IDBQuery

package com.sample;

public interface IDBQuery {
    public String query();
    public void insert();
    public void update();
    public void delete();
}

（2）真实主题类，封装了实际业务逻辑，无聊的模拟了一个权限验证所需要的身份证明“admin”

package com.sample;

public class DBQuery implements IDBQuery {
    private String authority = "admin";
    public DBQuery(){
        try{
            Thread.sleep(10000);//simulate ops creating connections between
        }
        catch(Exception ie){
            ie.printStackTrace();
        }
    }
    
    public String query() {
        return "this is a record";
    }
        public void update() {
        System.out.println("update a record");
    }

    public void insert() {
        System.out.println("insert a record");
    }

    public void delete() {
        System.out.println("delete a record");
    }

    public String getAuthority() {
        return authority;
    }

    public void setAuthority(String authority) {
        this.authority = authority;
    }
}

（3）替换静态代理中代理类的JDK动态代理，在方法调用时加上身份检测，当然了，还可以根据身份决定方法能否被调用即method.getName()来判断

package com.sample;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JdkDBProxy implements InvocationHandler {

    private Object targetObject = null;

    public Object createProxyInstance(Object targetObject) {
        this.targetObject = targetObject;
        return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),
                                    this.targetObject.getClass().getInterfaces(),
                                    this);
    }

    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        DBQuery dbQuery = (DBQuery) this.targetObject;
        Object result = null;
        if (dbQuery.getAuthority().equals("admin")) {
            System.out.println("call method：" + method.toString());
            result = method.invoke(targetObject, args);
        }
        return result;
    }
}

（4）测试使用动态代理

package com.sample;

public class Test {
    public static void main(String[] args) {
        JdkDBProxy jdkProxy = new JdkDBProxy();
        long begTime = System.currentTimeMillis();
        IDBQuery dbQuery = (IDBQuery)jdkProxy.createProxyInstance(new DBQuery());
        long endTime = System.currentTimeMillis();
        System.out.println("create dynamic proxy cost:" + (endTime-begTime));
        System.out.println(dbQuery.query());
        dbQuery.insert();
        dbQuery.update();
        dbQuery.delete();
    }

}

执行结果

create dynamic proxy cost:10009
call method：public abstract java.lang.String com.sample.IDBQuery.query()
this is a record
call method：public abstract void com.sample.IDBQuery.insert()
insert a record
call method：public abstract void com.sample.IDBQuery.update()
update a record
call method：public abstract void com.sample.IDBQuery.delete()
delete a record