设计模式之动态代理

        在我的前一篇博文静态代理中，使用静态代理模式时，我们需要在程序加载执行前，手动的创建好每个目标对象类的代理类。这样就导致我们如果有很多个需要被代理的类时，就必须手动的去创建好所有的每一个代理类，这样就会生成很多的代理文件，不易于代理的维护和管理。有没有什么办法可以不用生成这么多代理类呢？动态代理

        一 什么是动态代理

        代理类在程序运行时才被创建出来的方式称为动态代理。在这种方式中，我们不需要在程序执行前去生成对应的代理类，只需要在程序执行过程中，根据我们传递的目标对象去动态的创建即可。相比较静态代理，这种方式不需要我们去手动创建大批量的文件，更易于代理对象及方法的统一管理维护，比如我们需要对代理类做方法增强时就不需要去修改每一个代理类。

        二 动态代理实现

　　创建两个接口

public interface ICatDao {

    /**
     * 描述自己
     */
    void desc();

}

public interface IDogDao {

    /**
     * 描述自己
     */
    void desc();

}

　　创建接口的实现类

public class CatDaoImpl implements ICatDao {
    @Override
    public void desc() {
        System.out.println("<<-----------喵喵----------->>");
    }
}

public class DogDaoImpl implements IDogDao {
    @Override
    public void desc() {
        System.out.println("<<-----------旺旺----------->>");
    }
}

　　创建动态代理类实现 InvocationHandler接口(JDK动态代理必须实现这个接口)，我们使用提供的目标对象调用getProxy方法来生成代理类，执行目标对象提供的方法时会通过反射执行invoke方法执行

public class DynamicProxy implements InvocationHandler {

    /**
     * 目标对象
     */
    private Object target;

    public DynamicProxy() {
    }

    public Object getProxy(Object intf){
        this.target = intf;
        //args1:类加载器
        //args2:目标对象接口方法
        //InvocationHandler接口。所有动态代理类的方法调用，都会交由InvocationHandler接口实现类里的invoke()方法去处理
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        method.invoke(target, args);
        return null;
    }

}

　　测试，创建main方法生成代理类，执行方法

public static void main(String[] args) {

        ICatDao catDao = new CatDaoImpl();
        ICatDao catDaoProxy = (ICatDao) new DynamicProxy().getProxy(catDao);
        catDaoProxy.desc();

        IDogDao dagDao = new DogDaoImpl();
        IDogDao dagDaoProxy = (IDogDao) new DynamicProxy().getProxy(dagDao);
        dagDaoProxy.desc();

    }

　　执行结果如下，可以看到动态的生成了每一个目标对象，且可以正常执行

　　如果我们需要对做方法增强，我们只需要修改invoke就可以了，如

@Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法【"+method.getName()+"】要开始执行了");
        method.invoke(target, args);
        System.out.println("方法【"+method.getName()+"】已经执行结束");
        return null;
    }

　　执行测试方法，结果如下，可以看到对所有的代理类的方法都做了增强

 　　三 源码分析

　　代理对象类生成是调用Proxy类的newProxyInstance方法实现的，我们看看具体的方法

/**
     *
     * @param loader 定义代理类的类加载器
     * @param interfaces 要实现的代理类的接口列表，不能超过 65535
     * @param h
     * @return
     * @throws IllegalArgumentException
     */
    @CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
            throws IllegalArgumentException
    {
        // InvocationHandler 不能为空
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            //校验接口是否可以被访问
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        //生成代理类
        Class<?> cl = getProxyClass0(loader, intfs);

        //用指定的InvocationHandler调用其构造函数
        try {
            if (sm != null) {
                //对代理类进行权限校验
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }

            //根据参数生成构造器
            final Constructor<?> cons = cl.getConstructor(constructorParams);

            final InvocationHandler ih = h;

            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }

            //使用构造器生成实例
            return cons.newInstance(new Object[]{h});

        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        //如果实现给定接口的给定加载器定义的代理类存在，那么它将返回缓存的副本; 否则，它将通过ProxyClassFactory创建代理类
        return proxyClassCache.get(loader, interfaces);
    }