java代理（Java动态代理机制之JDK动态代理）

前言

代理模式（Proxy Pattern）是23种常用的面向对象软件的设计模式之一，作用是为其他对象提供一种代理以控制对这个对象的访问，直白说就是中间商或代购

如图，client发起请求到接口，正常是通过接口实现类impl来调用方法完成请求，但是增加了代理类后，可以直接用proxy的实例来调用interface的实现类的方法，并且可以增加额外的功能。

为什么要增加一层代理类呢，有两个优点：

隐藏和保护接口实现类， 控制对接口实现类对象的直接访问可以增加新的功能实现，提高了系统的可扩展性

而JDK动态代理则是常用的代理机制之一，主要是通过反射来实现的，实现JDK动态代理，必须要实现 InvocationHandler 接口，实现这个接口同时，会要求重写invoke()方法，如下，参数列表中

proxy：动态代理类（给你代购的那个人）method：被调用的方法args：被调用的方法的参数

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

实践

使用JDK动态代理步骤

创建被代理的接口和类；创建InvocationHandler接口的实现类，在invoke方法中实现代理逻辑；通过Proxy的静态方法newProxyInstance( ClassLoaderloader, Class[] interfaces, InvocationHandler h)创建一个代理对象使用代理对象。

来写个栗子展示动态代理的调用过程

首先是动态代理的接口，写了一个方法，并重载了这个方法

public interface TicketProvider {    public void getTrainTicket();    public void getTrainTicket(int count);}

然后是它的实现类

public class TicketProviderImpl implements TicketProvider {    @Override    public void getTrainTicket() {        System.out.println("购买火车票");    }    @Override    public void getTrainTicket(int count) {        System.out.println("购买火车票"+count+"张");    }}

然后是代理类，实现了InvocationHandler接口，重写了invoke方法

public class TicketProviderProxy implements InvocationHandler {    //实际对象，也就是代购要去的商店    private Object target;    //构造器赋值    public TicketProviderProxy(Object target) {        this.target = target;    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        System.out.println("-----before in method invoke-----");        //invoke()方法通过是实际对象和参数，找到对应的方法        method.invoke(target, args);        System.out.println("Add functionality to the method");        System.out.println("-----after in method invoke-----");        return null;    }}

让我们来代理测试一下

public class ProxyTest {    public static void main(String[] args) {        //接口实现类        TicketProvider ticketProvider = new TicketProviderImpl();        //InvocationHandler实现类，用到了刚才定义的构造器        InvocationHandler handler = new TicketProviderProxy(ticketProvider);        //newProxyInstance（）生成动态代理类实例，args[0]是实现类，args[1]是要接口类，        //args[2]是InvocationHandler实现类，即处理器，处理传入的需要被代理的真实对象        TicketProvider ticketProviderProxy = (TicketProvider) Proxy.newProxyInstance(                ticketProvider.getClass().getClassLoader(),                ticketProvider.getClass().getInterfaces(),                handler);        //传入参数测试        ticketProviderProxy.getTrainTicket();        ticketProviderProxy.getTrainTicket(5);    }}

可以看到输出结果是

可以看到，通过newProxyInstance()方法创建的代理对象可以调用到接口实现类的方法，并且还输出了增加的的方法。这样动态代理就实现了。

源码

Proxy.newProxyInstance( ClassLoaderloader, Class[] interfaces, InvocationHandler h)产生了代理对象，所以我们进到newProxyInstance的实现：

public static Object newProxyInstance(ClassLoader loader,                                          Class[] interfaces,                                          InvocationHandler h)        throws IllegalArgumentException    {        // 检验h不为空        Objects.requireNonNull(h);        // 拷贝接口的类对象        final Class[] intfs = interfaces.clone();        // 进行一些安全性检查        final SecurityManager sm = System.getSecurityManager();        if (sm != null) {            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);        }        /*         * Look up or generate the designated proxy class.         *  查询（在缓存中已经有）或生成指定的代理类的class对象。         */        Class cl = getProxyClass0(loader, intfs);        /*         * Invoke its constructor with the designated invocation handler.         */        try {            if (sm != null) {                checkNewProxyPermission(Reflection.getCallerClass(), cl);            }            // 得到代理类对象的构造函数，这个构造函数的参数由constructorParams指定，参数constructorParames为常量值：private static final Class[] constructorParams = { InvocationHandler.class };            final Constructor cons = cl.getConstructor(constructorParams);            final InvocationHandler ih = h;            if (!Modifier.isPublic(cl.getModifiers())) {                AccessController.doPrivileged(new PrivilegedAction() {                    public Void run() {                        cons.setAccessible(true);                        return null;                    }                });            }            // 生成代理对象，传入的参数new Object[]{h}后面讲            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);        }    }

这段代码核心就是通过getProxyClass0(loader, intfs)得到代理类的Class对象，然后通过Class对象得到构造方法，进而创建代理对象。

反射的使用地方在于动态代理类proxy的生成，即newProxyInstance()方法，他实现了第二个参数，也就是接口类，然后在实现接口方法的内部，通过反射调用了handler的invoke()方法，invoke()方法再通过内部的method.invoke()校验传入的参数，然后根据参数的不同去调用接口实现类的方法。

这点在SpringAOP中的实现也是一样的，只不过AOP的动态代理机制多了cglib动态代理，用来代理没有实现接口的对象。像bean这种，就是用cglib来进行代理的。

我的微信公众号：Java架构师进阶编程

专注分享Java技术干货，包括JVM、SpringBoot、SpringCloud、数据库、架构设计，还有我整理的上百份面试题库，持续更新中！期待你的关注！