java 动态代理分析

为什么要使用代理。

先看一个简单的使用案例

import java.lang.reflect.Proxy;

public class ProxyTest {

    public static void main(String[] args) {
　　　　　//开启保存代理类
        System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
　　　　　
        Proxy.newProxyInstance(ProxyTest.class.getClassLoader(), new Class[]{ProxyDemo.class}, new InvocationHandlerDemo());

    }
}

Proxy.newProxyInstance方法传入三个参数，类加载器，需要被代理的接口，代理类处理接口。结果返回的是Object对象。
jdk版本1.7，源码如下：

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        if (h == null) {
            throw new NullPointerException();
        }
　　　　　//检查权限
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, interfaces);
        }

        //生成代理类，核心是这个方法
        Class<?> cl = getProxyClass0(loader, interfaces);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
　　　　　　　//获取构造器
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
                // create proxy instance with doPrivilege as the proxy class may
                // implement non-public interfaces that requires a special permission
                return AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    public Object run() {
　　　　　　　　　　　　　　//创建对象
                        return newInstance(cons, ih);
                    }
                });
            } else {
　　　　　　　　　　//创建对象
                return newInstance(cons, ih);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString());
        }
    }

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

　　　　　//首先从缓存中获取代理类，如果没有，通过Proxy.ProxyClassFactory类生成代理类并放入缓存，然后返回代理类。
        return proxyClassCache.get(loader, interfaces);
    }

下面分析 Proxy.ProxyClassFactory 类的apply方法：

@Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
                /*
                 * 验证代理接口
                 * 
                 */
                Class<?> interfaceClass = null;
                try {
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
                /*
                 * 验证是否是接口
                 * 
                 */
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                /*
                 * 验证接口是否有多个
                 */
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }

            String proxyPkg = null;     // package to define proxy class in

            /*
             *  
             *  验证同一包下非公共接口，包名是否一致
             *  
             */
            for (Class<?> intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {
                // 如果是pulic接口，采用默认包名
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            /*
             * 组装代理类名
             */
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            /*
             * 生成代理类，核心方法是ProxyGenerator 中的 generateClassFile方法。
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces);
            try {
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                /*
                 * A ClassFormatError here means that (barring bugs in the
                 * proxy class generation code) there was some other
                 * invalid aspect of the arguments supplied to the proxy
                 * class creation (such as virtual machine limitations
                 * exceeded).
                 */
                throw new IllegalArgumentException(e.toString());
            }
        }

 private byte[] generateClassFile() {
　　　　　//添加hashCode、equals、toString方法，到代理方法集合中
        this.addProxyMethod(hashCodeMethod, Object.class);
        this.addProxyMethod(equalsMethod, Object.class);
        this.addProxyMethod(toStringMethod, Object.class);

        int var1;
        int var3;
　　　　　//遍历代理接口，将接口中的方法添加到代理方法集合中
        for(var1 = 0; var1 < this.interfaces.length; ++var1) {
            Method[] var2 = this.interfaces[var1].getMethods();

            for(var3 = 0; var3 < var2.length; ++var3) {
                this.addProxyMethod(var2[var3], this.interfaces[var1]);
            }
        }

        Iterator var7 = this.proxyMethods.values().iterator();
　　　　　//验证代理方法集合中返回类型
        List var8;
        while(var7.hasNext()) {
            var8 = (List)var7.next();
            checkReturnTypes(var8);
        }

        Iterator var11;
        try {
　　　　　　　//生成含有InvoicationHandler参数的构造方法，并添加到方法集合中
            this.methods.add(this.generateConstructor());
            var7 = this.proxyMethods.values().iterator();
　　　　　　　//遍历代理方法集合，生成方法，字段，放入到方法集合，字段集合中
            while(var7.hasNext()) {
                var8 = (List)var7.next();
                var11 = var8.iterator();

                while(var11.hasNext()) {
                    ProxyGenerator.ProxyMethod var4 = (ProxyGenerator.ProxyMethod)var11.next();
                    this.fields.add(new ProxyGenerator.FieldInfo(var4.methodFieldName, "Ljava/lang/reflect/Method;", 10));
                    this.methods.add(var4.generateMethod());
                }
            }
　　　　　　　//生成类构造器，添加到方法中
            this.methods.add(this.generateStaticInitializer());
        } catch (IOException var6) {
            throw new InternalError("unexpected I/O Exception");
        }

        if (this.methods.size() > 65535) {
            throw new IllegalArgumentException("method limit exceeded");
        } else if (this.fields.size() > 65535) {
            throw new IllegalArgumentException("field limit exceeded");
        } else {
            this.cp.getClass(dotToSlash(this.className));
            this.cp.getClass("java/lang/reflect/Proxy");

            for(var1 = 0; var1 < this.interfaces.length; ++var1) {
                this.cp.getClass(dotToSlash(this.interfaces[var1].getName()));
            }

            this.cp.setReadOnly();
　　　　　　　//构造字节输出流，按照class文件格式，顺序输出到字节数组中
            ByteArrayOutputStream var9 = new ByteArrayOutputStream();
            DataOutputStream var10 = new DataOutputStream(var9);

            try {
　　　　　　　　　　//写入魔数
                var10.writeInt(-889275714);
　　　　　　　　　　//写入此版本号
                var10.writeShort(0);
　　　　　　　　　　//写入主版本号
                var10.writeShort(49);
　　　　　　　　　　//写入常量池
                this.cp.write(var10);
　　　　　　　　　　//写入访问修饰符
                var10.writeShort(49);
　　　　　　　　　　//写入类索引
                var10.writeShort(this.cp.getClass(dotToSlash(this.className)));
　　　　　　　　　　//写入父类索引
                var10.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
　　　　　　　　　　//写入接口数量
                var10.writeShort(this.interfaces.length);
　　　　　　　　　　//写入接口
                for(var3 = 0; var3 < this.interfaces.length; ++var3) {
                    var10.writeShort(this.cp.getClass(dotToSlash(this.interfaces[var3].getName())));
                }
　　　　　　　　　　//写入字段计数
                var10.writeShort(this.fields.size());
                var11 = this.fields.iterator();
　　　　　　　　　　//写入字段
                while(var11.hasNext()) {
                    ProxyGenerator.FieldInfo var12 = (ProxyGenerator.FieldInfo)var11.next();
                    var12.write(var10);
                }　
　　　　　　　　　　//写入方法计数
                var10.writeShort(this.methods.size());
                var11 = this.methods.iterator();
　　　　　　　　　　//写入方法
                while(var11.hasNext()) {
                    ProxyGenerator.MethodInfo var13 = (ProxyGenerator.MethodInfo)var11.next();
                    var13.write(var10);
                }
　　　　　　　　　　//写入属性计数
                var10.writeShort(0);
                return var9.toByteArray();
            } catch (IOException var5) {
                throw new InternalError("unexpected I/O Exception");
            }
        }
    }

从上面源码，可以看出生成的代理类应该包括代理接口中所有方法，Object的hashcode，equals，toString方法，一个含有InvocationHandler参数的实例构造方法，一个类初始方法。下面让我们看下生成的代理类源码：

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

    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})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

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

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

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

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.yishi.invoice.proxy.ProxyDemo").getMethod("sayHello", Class.forName("java.lang.String"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

我们可以看到，调用代理类的sayHello方法，实际上调用的是InvocationHandler.invoke方法。

需要注意：代理类中通过反射获取到代理接口的Method对象，并传入到InvocationHandler.invoke方法中。也就是说invoke方法中需要通过Method发射来调用被代理类的方法。

下面看一个复杂的例子：

包结构如下：

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Modifier;
import java.net.URL;
import java.util.*;

public class DaoContainer {

    /**
     * 存储代理类
     * key为接口名称
     * value为代理类
     */
    private static Map<String, Object> daoMap = new HashMap<String, Object>();

    /**
     * 接口class对象
     */
    private static List<Class<?>> interfaces = new ArrayList<Class<?>>();

    /**
     * 存储实例对象
     * key 为 接口class对象
     * value为 实例对象
     */
    private static Map<Class<?>, List<Object>> maps = new HashMap<Class<?>, List<Object>>();

    /**
     * 解析包下的接口
     * @param pkgBase
     */
    public void parseInterface(String pkgBase) {
        //解析包路径
        //此处简单处理，支持单路劲
        String[] p = splitPkg(pkgBase);
        for (String str:p) {
            Enumeration<URL> resources = null;
            try {
                resources = DaoContainer.class.getClassLoader().getResources(str);
                while (resources.hasMoreElements()){
                    URL url = resources.nextElement();
                    File rootFile = new File(url.getFile());
                    if (rootFile.exists()) {
                        if (rootFile.isDirectory()) {
                            File[] subFiles = rootFile.listFiles();
                            for (File f : subFiles) {
                                String interfaceName = pkgBase+ "." + f.getName().substring(0,f.getName().lastIndexOf("."));
                                System.out.println(interfaceName);
                                try {
                                    /**
                                     * 可以通过解析class文件，获取类属性，减少不必要的类加载。然后通过判断哪些类是需要加载的
                                     * 此处简单处理
                                     */
                                    Class<?> cl = Class.forName(interfaceName,false, DaoContainer.class.getClassLoader());
                                    if (Modifier.isInterface(cl.getModifiers())) {
                                        interfaces.add(cl);
                                    } else if (!Modifier.isInterface(cl.getModifiers()) && !Modifier.isAbstract(cl.getModifiers()) && Modifier.isPublic(cl.getModifiers())) {
                                        //如果不是接口，分析父类接口
                                        Class<?>[] inter = cl.getInterfaces();
                                        for (Class i : inter ) {
                                            if (Modifier.isPublic(i.getModifiers())) {
                                                List<Object> objs = maps.get(i);
                                                if (objs == null) {
                                                    objs = new ArrayList<Object>();
                                                    maps.put(i, objs);
                                                }
                                                objs.add(cl.newInstance());
                                            }
                                        }
                                    }
                                } catch (ClassNotFoundException e) {
                                    e.printStackTrace();
                                } catch (IllegalAccessException e) {
                                    e.printStackTrace();
                                } catch (InstantiationException e) {
                                    e.printStackTrace();
                                }
                            }
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 以 ,或者; 作为分隔符
     * @param pkgBase
     * @return
     */
    private String[] splitPkg(String pkgBase) {
        //简单处理
        pkgBase = pkgBase.replace(".","/");
        return new String[]{pkgBase};
    }

    /**
     * 创建代理类
     */
    private void createProxy() {
        for (Class<?> cl : interfaces) {
            //创建代理类
            Object proxy = DaoProxyFactory.proxyInstance(cl);

            daoMap.put(cl.getName(),proxy);
        }

        Set<Map.Entry<Class<?>, List<Object>>> keys = maps.entrySet();
        Iterator<Map.Entry<Class<?>, List<Object>>> iterator = keys.iterator();

        while (iterator.hasNext()) {
            Map.Entry<Class<?>, List<Object>> entry = iterator.next();

            Class<?> key = entry.getKey();

            List<Object> objs = entry.getValue();

            for (int i = 0; null != objs && i < objs.size(); i++) {
                Object o = objs.get(i);
                Object obj = DaoProxyFactory.proxyInstance(key, o);
                daoMap.put(o.getClass().getName(), obj);
            }
        }

    }

    /**
     * 搜索包下接口
     * @param pkgBase
     */
    public void searchPkgBean(String pkgBase) {
        parseInterface(pkgBase);
        createProxy();
    }

    /**
     * 通过key获取代理类
     * @return
     */
    public Object getProxyObjectByKey(String key) {
        return daoMap.get(key);
    }

}

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

public class DaoProxyFactory {

    private static CommonSolvDemo commonSolvDemo = new CommonSolvDemo();

    public DaoProxyFactory() {
    }

    public DaoProxyFactory(CommonSolvDemo com) {
        this.commonSolvDemo = com;
    }

    //代理接口
    public static Object proxyInstance(Class<?> inter) {
        Object obj = null;
        try {
            obj = Proxy.newProxyInstance(DaoProxyFactory.class.getClassLoader(), new Class[]{inter}, new DaoInvocationHandler());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return obj;
    }

    //代理实现共同接口的实例
    public static Object proxyInstance(Class<?> inter, Object obj) {
        Object res = null;
        try {
            res =  Proxy.newProxyInstance(DaoProxyFactory.class.getClassLoader(), new Class[]{inter}, new DaoInvocationHandler1(obj));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return res;
    }

    private static class DaoInvocationHandler implements InvocationHandler {

        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

            commonSolvDemo.commonSolvStart();

            commonSolvDemo.commonSolvEnd();

            return null;
        }
    }

    private static class DaoInvocationHandler1 implements InvocationHandler {

        private Object target;

        public DaoInvocationHandler1(Object target) {
            this.target = target;
        }

        public DaoInvocationHandler1() {
        }

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

public class CommonSolvDemo {


    public void commonSolvStart() {
        System.out.println("公共处理开始");
    }


    public void commonSolvEnd() {
        System.out.println("公共处理结束");
    }

}

import java.lang.reflect.Proxy;

public class ProxyTest {

    public static void main(String[] args) {
//        test1();
        test2();
    }

    public static void test2() {
        DaoContainer container = new DaoContainer();
        container.searchPkgBean("com.yishi.invoice.proxy");
//        //这种情况类似mybatis底层的代理生成方式
        ProxyDemo p = (ProxyDemo) container.getProxyObjectByKey("com.yishi.invoice.proxy.ProxyDemo");
        p.sayHello("haha");

        //代理实现统一接口的实例，类似spring底层代理的一种
        SqlSession sql = (SqlSession) container.getProxyObjectByKey("com.yishi.invoice.proxy.SqlSessionTemplete");
        sql.selectLIst("312","21");
    }

    public static void test1() {
        System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles","true");

        Proxy.newProxyInstance(ProxyTest.class.getClassLoader(), new Class[]{ProxyDemo.class}, new InvocationHandlerDemo());
    }

}

总结下，动态代理底层是字节码层面的技术，利用反射获取到需要代理接口方法，然后根据class字节码标准，生成二进制数据。

回到最开始的问题，为什么要使用代理？当需要对一些类，接口提供统一功能的时候，可以考虑使用代理模式。静态代理采用硬编码的方式实现，其思想本质上是一样的。

spring采用两种代理，cglib与jdk代理。如果是接口的话，采用jdk方式，如果是非接口，采用cglib方式。

后面将分析cglib代理原理，敬请期待。