动态代理原理解析

注:源自于Android

一、代理模式

代理模式是java23种设计模式常用的一种设计模式。
代理模式是客户端不直接调用实际对象,而是通过调用代理对象来间接调用使用实际对象。
为什么使用代理模式来间接调用使用实际对象,而不是直接使用实际对象呢?这里主要有两方面的考量:

  • 出于安全、封装性的考量,不想直接使用实际对象
  • 使用实际对象比较麻烦
    现实生活中律师、房屋中介其实就是活生生的代理模式
    我们来看下代理模式的关系图:


    image

    java中代理模式分为静态代理和动态代理的不同实现

1、静态代理的实现:
public interface Subject {
    void test();
}

public class RealSubject implements Subject {
    @Override
    public void test() {
        System.out.println("this is RealSubject test");
    }
}

public class ProxySubject implements Subject {
    Subject mSubject;

    public ProxySubject(Subject pSubject){
        mSubject = pSubject;
    }

    @Override
    public void test() {
        if(mSubject != null){
            mSubject.test();
        }
    }
}

public class Client {
    public static void main(String[] args){
        RealSubject realSubject = new RealSubject();
        ProxySubject proxySubject = new ProxySubject(realSubject);
        proxySubject.test();
    }
}

通过上面的代码我们可以看出静态代理的优缺点:

  • 优点:代理类可以接受一个已经实现了Subject接口的对象,任何实现了Subject接口的对象都可以通过代理类进行代理,实现了通用型
  • 缺点:当接口增删改方法,那么代理类已得要跟着修改;代理类的每个接口对象对应一个委托对象,如果委托对象很多,代理类就会变得异常臃肿
2、动态代理

动态代理有别用静态代理,它是通过要代理的类,动态的生成代理类。这样可以避免静态代理中代理类接口过多的问题。
动态代理的实现方式是借助java.lang.Reflect.Proxy进行反射实现的,其步骤如下:
a、编写一个委托类接口,对应的静态代理的Subject接口
b、编写一个委托类接口的实现类,对应的是静态代理的RealSubject
c、创建动态代理类方法调用处理程序,实现InvocationHandler接口,并重写invoke方法
d、在测试类中生成动态代理对象
定义委托对象接口:

public interface Subject {
    void test();
}

委托对象接口实现类:

public class RealSubject implements Subject {
    @Override
    public void test() {
        System.out.print("this is dynamic RealSubject test");
    }
}

动态代理类方法调用处理程序:

public class DynamicProxy implements InvocationHandler {
    Object mObj;
    public DynamicProxy(Object pObj){
        mObj = pObj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        System.out.println("this is Dynamic proxy invode");
        if(mObj != null){
            result = method.invoke(mObj, args);
        }
        return result;
    }
}

使用动态代理:

public class Client {
    public static void main(String[] args){
        RealSubject realSubject = new RealSubject();
        DynamicProxy proxy = new DynamicProxy(realSubject);
        Subject subject = (Subject) Proxy.newProxyInstance(
                realSubject.getClass().getClassLoader(),
                realSubject.getClass().getInterfaces(),
                proxy
                );
        subject.test();
    }
}
二、动态代理原理

通过上面动态代理的使用,它看似并没有代理类,那么它是什么进入DynamicProxy的invoke方法实现实际委托对象方法的调用呢?
下面我们通过源码一步一步解析揭开它什么的面纱:
动态代理使用了Proxy.newProxyInstance方法动态创建代理类,我们看下newProxyInstance源码:

/**
@params loader 用于从动态生成的class字节流中加载创建代理类
@params interfaces 委托对象实现的接口列表
@params h 代理类方法调用处理器
@return 返回动态创建的代理类
*/
public static Object newProxyInstance(ClassLoader loader,
                                          Class[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        //动态代理类方法调用处理程序即这里的h不能为空
        Objects.requireNonNull(h);
        //委托对象的接口列表
        final Class[] intfs = interfaces.clone();
        //android中移除了安全相关的校验
        // Android-removed: SecurityManager calls
        /*
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
        */

        /*
         * Look up or generate the designated proxy class.
         */
        //动态生成class文件字节流,然后通过loader加载此字节流创建代理类class
        Class cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            // Android-removed: SecurityManager / permission checks.
            /*
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            */
            //获取代理类的类构造对象
            final Constructor cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            //如果class对象不可访问,则修改为可访问
            if (!Modifier.isPublic(cl.getModifiers())) {
                // BEGIN Android-changed: Excluded AccessController.doPrivileged call.
                /*
                AccessController.doPrivileged(new PrivilegedAction() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
                */

                cons.setAccessible(true);
                // END Android-removed: Excluded AccessController.doPrivileged call.
            }
            // 通过类构造器创建代理实现类并返回
            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);
        }
    }

newProxyInstance动态创建代理类的步骤是:

  • 校验代理类方法调用处理程序h不能为空
  • 动态生成代理类class文件格式字节流
  • 通过loader加载创建代表代理类的class对象
  • 根据代理类的构造器创建代理类
  • 返回动态创建生成的代理类
    怎么生成代理类class文件格式字节流的呢?
    我们先看下getProxyClass0方法:
private static Class getProxyClass0(ClassLoader loader,
                                           Class... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        // If the proxy class defined by the given loader implementing
        // the given interfaces exists, this will simply return the cached copy;
        // otherwise, it will create the proxy class via the ProxyClassFactory
        return proxyClassCache.get(loader, interfaces);
    }

通过上面的代码告诉我们委托对象能实现的接口数量不能超过65535,就是Short类型的最大值
我们再看proxyCache.get的实现,其中proxyCache是WeakCache的实现对象:

//WeakCache.java
/**
@params key 此处是类加载器loader
@params parameter 此处是代理类接口列表
*/
public V get(K key, P parameter) {
        //此处要求代理类接口不能为空
        Objects.requireNonNull(parameter);
      
        expungeStaleEntries();
        //生成CacheKey对象
        Object cacheKey = CacheKey.valueOf(key, refQueue);

        // lazily install the 2nd level valuesMap for the particular cacheKey
        //根据cachekey获取键值对valuesMap, valuesMap的key是接口列表的包装类,value是动态生成代理类的包装类
        ConcurrentMap> valuesMap = map.get(cacheKey);
        if (valuesMap == null) {
            ConcurrentMap> oldValuesMap
                = map.putIfAbsent(cacheKey,
                                  valuesMap = new ConcurrentHashMap<>());
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }

        // create subKey and retrieve the possible Supplier stored by that
        // subKey from valuesMap
        //根据代理类接口生成的key
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        //动态生成代理类的包装类
        Supplier supplier = valuesMap.get(subKey);
        //生成动态代理类的工厂类
        Factory factory = null;

        while (true) {
            //如果动态代理类包装类supplier不为空,则使用supplier 中的工厂类factory加载动态生成的class文件格式的代理类的字节流
            if (supplier != null) {
                // supplier might be a Factory or a CacheValue instance
                //此处是factory加载动态生成的class文件格式的代理类的字节流的实现
                V value = supplier.get();
                if (value != null) {
                    //此处返回动态生成的代理类
                    return value;
                }
            }
            // else no supplier in cache
            // or a supplier that returned null (could be a cleared CacheValue
            // or a Factory that wasn't successful in installing the CacheValue)

            // lazily construct a Factory
            //如果动态生成代理类的工厂类为空,则创建新的工厂类
            if (factory == null) {
                factory = new Factory(key, parameter, subKey, valuesMap);
            }
           
            if (supplier == null) {
               //工厂类的包装类为空,则创建新的包装类supplier 
                supplier = valuesMap.putIfAbsent(subKey, factory);
                if (supplier == null) {
                    // successfully installed Factory
                    supplier = factory;
                }
                // else retry with winning supplier
            } else {
               //工厂类的包装类不为空,则替换包装类中的工作累
                if (valuesMap.replace(subKey, supplier, factory)) {
                    // successfully replaced
                    // cleared CacheEntry / unsuccessful Factory
                    // with our Factory
                    supplier = factory;
                } else {
                    // retry with current supplier
                    supplier = valuesMap.get(subKey);
                }
            }
        }
    }

由上面的代码,大概知道通过map来存储动态生成的代理类,其中key是接口的包装类,value是动态代理类的包装类。

  • key的生成是通过subKeyFactory,subKeyFactory是KeyFactory的实现类,其实现很简单,只是对代理类接口进行包装:
private static final class KeyFactory
        implements BiFunction[], Object>
    {
        @Override
        public Object apply(ClassLoader classLoader, Class[] interfaces) {
            switch (interfaces.length) {
                case 1: return new Key1(interfaces[0]); // the most frequent
                case 2: return new Key2(interfaces[0], interfaces[1]);
                case 0: return key0;
                default: return new KeyX(interfaces);
            }
        }
    }

private static final class Key1 extends WeakReference> {
        private final int hash;

        Key1(Class intf) {
            super(intf);
            this.hash = intf.hashCode();
        }

        @Override
        public int hashCode() {
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            Class intf;
            return this == obj ||
                   obj != null &&
                   obj.getClass() == Key1.class &&
                   (intf = get()) != null &&
                   intf == ((Key1) obj).get();
        }
    }

其他key1、keyx不展开说明

  • value是生成动态代理类的包装类,此包装类是实现了Supplier接口的Factory类,通过Factory的get方法动态生成代理类:
@Override
        public synchronized V get() { // serialize access
            // re-check
            //从map中获取已经生成的动态代理类的包装类
            Supplier supplier = valuesMap.get(subKey);
            if (supplier != this) {
                // something changed while we were waiting:
                // might be that we were replaced by a CacheValue
                // or were removed because of failure ->
                // return null to signal WeakCache.get() to retry
                // the loop
                return null;
            }
            // else still us (supplier == this)

            // create new value
            V value = null;
            try {
                //通过valueFactory的apply方法生成动态代理类
                value = Objects.requireNonNull(valueFactory.apply(key, parameter));
            } finally {
                if (value == null) { // remove us on failure
                    valuesMap.remove(subKey, this);
                }
            }
            // the only path to reach here is with non-null value
            assert value != null;

            // wrap value with CacheValue (WeakReference)
            CacheValue cacheValue = new CacheValue<>(value);

            // try replacing us with CacheValue (this should always succeed)
            if (valuesMap.replace(subKey, this, cacheValue)) {
                // put also in reverseMap
                reverseMap.put(cacheValue, Boolean.TRUE);
            } else {
                throw new AssertionError("Should not reach here");
            }

            // successfully replaced us with new CacheValue -> return the value
            // wrapped by it
            return value;
        }

这里核心的实现是valueFactory的apply方法,valueFactory是ProxyClassFactory的实现类,我们来看下ProxyClassFactory的apply方法,看其是怎么实现生成动态代理类的:

public Class apply(ClassLoader loader, Class[] interfaces) {

            Map, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            //获取代理类接口的class对象,并校验是否是接口,如果不是则抛出错误
            for (Class intf : interfaces) {
                /*
                 * Verify that the class loader resolves the name of this
                 * interface to the same Class object.
                 */
                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");
                }
                /*
                 * Verify that the Class object actually represents an
                 * interface.
                 */
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                /*
                 * Verify that this interface is not a duplicate.
                 */
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }
            //动态代理类的包名
            String proxyPkg = null;     // package to define proxy class in
            //动态代理类的访问权限
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

            /*
             * Record the package of a non-public proxy interface so that the
             * proxy class will be defined in the same package.  Verify that
             * all non-public proxy interfaces are in the same package.
             */
            for (Class intf : interfaces) {
                //根据代理类接口生成包名和访问权限
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    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) {
                // if no non-public proxy interfaces, use the default package.
                proxyPkg = "";
            }

            {
                // Android-changed: Generate the proxy directly instead of calling
                // through to ProxyGenerator.
                //获取代理类接口的方法列表,并进行排序和返回类型校验
                List methods = getMethods(interfaces);
                Collections.sort(methods, ORDER_BY_SIGNATURE_AND_SUBTYPE);
                validateReturnTypes(methods);
                //获取方法类别的异常列表
                List[]> exceptions = deduplicateAndGetExceptions(methods);
                //方法列表转为方法数组
                Method[] methodsArray = methods.toArray(new Method[methods.size()]);
               //异常列表转为异常数组
                Class[][] exceptionsArray = exceptions.toArray(new Class[exceptions.size()][]);

                /*
                 * Choose a name for the proxy class to generate.
                 */
                //生成代理类唯一名称
                long num = nextUniqueNumber.getAndIncrement();
                String proxyName = proxyPkg + proxyClassNamePrefix + num;
                //根据类名、接口、类加载器、方法列表、异常列表,按照class文件格式先生成字节流,再生成动态代理类
                return generateProxy(proxyName, interfaces, loader, methodsArray,
                                     exceptionsArray);
            }
        }

//native方法,其实现原理是根据类名、接口、类加载器、方法列表、异常列表,按照class文件格式先生成字节流,再生成动态代理类
@FastNative
private static native Class generateProxy(String name, Class[] interfaces,
                                                 ClassLoader loader, Method[] methods,
                                                 Class[][] exceptions);

按照这样的流程,我们可以总结动态代理的原理如下:
1、根据代理类接口先得到代理类的类全限名、方法列表、异常列表
2、根据步骤1中的类全限名、方法列表、异常列表、接口列表生成class文件格式的字节流,其中方法的实现会最终调用InvoationHanlder的invoke方法
3、使用类加载器加载步骤2中的字节流,创建生成动态代理类对象
4、使用步骤3中创建生成的代理类对象

你可能感兴趣的:(动态代理原理解析)