jdk动态代理简析

本文是根据所学对jdk动态代理做一个简单的源码分析，更深层次的源码可参考其他博主的文章。

先来一个简单的动态代理的例子。

//接口
public interface IBank {

    /**
     * 查询账户信息
     */
    public void queryInfo();
}
//实现类
public class BankImpl implements IBank {

    @Override
    public void queryInfo()
    {
        System.out.println("您的账户连一分钱都没有!");
    }
}
//动态代理处理器
public class JDKBankHandler implements InvocationHandler {
    private  Object target;

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

    @Override
    public Object invoke(Object proxy, Method method,Object[] args) throws  Exception
    {
        System.out.println("jdk代理开始了....");
        Object result= method.invoke(target,args);
        System.out.println("jdk代理结束了....");
        return  result;
    }
}

public class test {
    public static void main(String[] args) {
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        IBank bank=new BankImpl();
        JDKBankHandler bankHandler=new JDKBankHandler();
        IBank bankProxy=(IBank) bankHandler.newProxyInstance(bank);
        bankProxy.queryInfo();
    }
}

上述代码就是平常我们写的jdk的动态代理方法。

下面分析下，为什么我们通过bankProxy.queryInfo()就可以访问到BankImpl下的queryInfo方法。

根据代码，我们首先会通过

IBank bankProxy=(IBank) bankHandler.newProxyInstance(bank);

生成一个代理类，我们先看下newProxyInstance方法的源码

@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);
        }
    }

可以看到，源码通过getProxyClass0方法生成一个接口代理类的字节码文件$Proxy0类，这个方法比较复杂，我没有深究，知道在这里生成了这么一个文件就行。下面我附上这个文件的源码：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.sun.proxy;

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

public final class $Proxy0 extends Proxy implements IBank {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void queryInfo() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("IBank").getMethod("queryInfo");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

然后调用$Proxy0的构造函数cons.newInstance(new Object[]{h})生成实例，$Proxy0的构造函数会调用super(var1)，此时的super就是$Proxy0的父类Proxy，因此会调用Proxy的构造函数

因此，当我们再通过生成的代理类对象调用queryInfo接口的时候，首先会调用$Proxy0的queryInfo，通过$Proxy0的源码我们可以看到他会调用它父类Proxy对象的h对象的invoke方法，

而h就是我们的代理处理类JDKBankHandler。因此调用时会走到我们的代理处理类JDKBankHandler的invoke方法。在JDKBankHandler的invoke中会调用实例target也就是BankImpl的queryInfo方法。

至此，也就说明了为什么调用bankProxy.queryInfo()就可以访问到BankImpl下的queryInfo方法。