jdk源码分析(3) 动态代理实现

最新推荐文章于 2024-03-06 16:44:35 发布

曳凡

最新推荐文章于 2024-03-06 16:44:35 发布

阅读量111

点赞数

分类专栏：【曳凡】- JDK技术栈

本文链接：https://blog.csdn.net/weixin_36488231/article/details/105285624

版权

【曳凡】- JDK技术栈专栏收录该内容

9 篇文章 0 订阅

订阅专栏

文章目录

1、动态代理介绍及示例

首先我们先来看个例子

public interface UserInterface {

    public void printUserInfo();
}

有一个实现了这个接口的实现类

public class UserImpl implements UserInterface{

    @Override
    public void printUserInfo(){
        System.out.println("i am jdq");
    }

}

有一个中介类为

public class UserProxy implements InvocationHandler {

    private Object object;

    public UserProxy(Object object){
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("我这里是代理实现，下面就将要调用具体实现类");
        Object result = method.invoke(object, args);
        System.out.println("我这里是代理实现，调用具体实现类函数结束");
        return null;
    }
}

这个中介类必须要实现InvocationHandler接口，并且需要实现invoke函数，稍后再给出其机制分析。最后我们在UserTest进行调用执行

public class UserTest {

    public static void main(String[] args) {
        /*创建中介类实例，将UserImpl和UserProxy进行联系，这样在UserProxy可以调用到UserImpl的方法*/
        UserProxy userProxy = new UserProxy(new UserImpl());

        //获取代理类类实例
        UserInterface userInterface = (UserInterface)(Proxy.newProxyInstance(UserInterface.class.getClassLoader(), new Class[]{UserInterface.class}, userProxy));

		/*实际上调用的是中介类中的invoke函数，在这个invoke函数中我们可以调用UserImpl的具体实现*/
        userInterface.printUserInfo();
    }

}

最后程序结果为
在这里插入图片描述
根据结果我们可以看到调用接口的函数就是调用其中介类的invoke函数，然后在这个invoke函数中我们可以加上UserImpl函数的具体实现类函数，也可以在调用这个具体实现类函数之前对其进行增强操作，例如我们在这个例子中就是在调用具体实现前输出了"我这里是代理实现，下面就将要调用具体实现类"这样的语句进行增强。

简单的UML之间的结构是：
在这里插入图片描述

这种方式的优势：

可以进行解耦，因为现在可以系统自动生成一个代理类对象，这样我们只需要进行接口编程，而不需要了解其具体实现。可以联想到mybatis利用xml写入sql语句，然后我们只需要定义一个接口就进行调用。
可以进行自定义的增加效果，例如我们在实际工程中可以在此前进行校验，加日志等操作，可以联想到Spring aop的实现。

2、Proxy类源码分析

UserInterface userInterface = (UserInterface)(Proxy.newProxyInstance(UserInterface.class.getClassLoader(), new Class[]{UserInterface.class}, userProxy));

这边传入UserInterface的类装载器和Class类信息和一个UserPorxy的对象，可以返回一个userInterface的接口的代理对象，从某种意义上来讲，可以认为UserPorxy也是一种UserInterface的实现，但是这并不是真正意义上的实现，因为一般的实现如果调用接口函数，那么实际上调用的是实现类中相应的同名函数。但是这里调用的是UserPorxy类对象的invoke函数，这个函数的参数中会有具体实现类函数名，从而可以调用到具体实现类的函数。

接下来我们来看下newProxyInstance的源码实现

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
  {
  	/*判断传入的中介类对象是否为null，如果为null，则直接报错，因为中介类是联系具体实现类的桥梁，没有这个无法进行真正的调用*/
      Objects.requireNonNull(h);
	  /*复制传入接口类的属性信息*/
      final Class<?>[] intfs = interfaces.clone();
      final SecurityManager sm = System.getSecurityManager();
      /*如果存在安全管理器，那么需要判断是否有权限创建这个接口的代理对象*/
      if (sm != null) {
          checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
      }

      /*查找或生成指定的代理类，函数的详细分析在下面,c1就存放了相应代理类的信息*/
      Class<?> cl = getProxyClass0(loader, intfs);

      /*
       * Invoke its constructor with the designated invocation handler.
       */
      try {
          if (sm != null) {
              checkNewProxyPermission(Reflection.getCallerClass(), cl);
          }
		  /*获取一个InvocationHandler类型的构造器*/
          final Constructor<?> cons = cl.getConstructor(constructorParams);
          /*将我们实现了InvocationHandler的中介类传入ih*/
          final InvocationHandler ih = h;
          /*判断安全性和pulic的可进入性*/
          if (!Modifier.isPublic(cl.getModifiers())) {
              AccessController.doPrivileged(new PrivilegedAction<Void>() {
                  public Void run() {
                      cons.setAccessible(true);
                      return null;
                  }
              });
          }
          /*利用InvocationHandler的构造器生成一个自己实现了的中介类的对象实例，同时这个对象是Object类型，可以强制转换成其他类型，
          但是内存空间上的对象还是没有变，内部实现的方法区还是和原来的中介类的方法区一致。
          具体可以去学习下c中强制类型转换的实现，对一个对象转换类型本质上就是改变了其指针指向的内存区域的范围和修改了一些属性值
          */
          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是Proxy类用来创建一个接口对应的代理类对象的。首先可以发现我们在函数调用中传入的接口对象在函数中是重新clone了一个，所以这个函数是不会产生对接口对象的影响。

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

     /*如果存在由实现了给定接口的给定加载器定义的代理类，则将仅返回缓存的副本；否则，它将通过ProxyClassFactory创建代理类。具体get的实现在下面*/
     return proxyClassCache.get(loader, interfaces);
 }

给定类加载器和接口数组的代理类的java.lang.Class对象。代理类将由指定的类加载器定义，并将实现所有提供的接口。如果任何给定的接口是非公开的，则代理类将是非公开的。如果类加载器已经定义了接口相同置换的代理类，那么将返回现有的代理类; 否则，这些接口的代理类将被动态生成并由类加载器定义。
在这里插入图片描述

WeakCache类的get函数分析

public V get(K key, P parameter) {
	 /*key为类的装载器信息，patameter为接口类信息*/
     Objects.requireNonNull(parameter);
	/*擦除无效的缓存值(weakReference发生fullgc会回收掉)*/
     expungeStaleEntries();
	 /*将ClassLoader包装成CacheKey, 作为一级缓存的key*/
     Object cacheKey = CacheKey.valueOf(key, refQueue);
	  /*懒加载的方式获取得到二级缓存*/
     // lazily install the 2nd level valuesMap for the particular cacheKey
     ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
     if (valuesMap == null) {
     	/*以CAS方式放入, 如果一级key值对应的二级缓存不存在则新建一个放入，否则返回原先的值*/
         ConcurrentMap<Object, Supplier<V>> oldValuesMap
             = map.putIfAbsent(cacheKey,
                               valuesMap = new ConcurrentHashMap<>());
         if (oldValuesMap != null) {
             valuesMap = oldValuesMap;
         }
     }

     /*根据代理类实现的接口数组来生成二级缓存key, 分为key0, key1, key2, keyx
     可以看到一级缓存的key只和ClassLoader有关，而二级缓存的key值和ClassLoader与interface有关
     */
     Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
     /*这里通过subKey获取到二级缓存的值*/
     Supplier<V> supplier = valuesMap.get(subKey);
     Factory factory = null;

     while (true) {
         if (supplier != null) {
             /*根据get中来得到真正的factory或者CacheValue<V> instance，这里factory中有CacheValue<V> instance这样的对象
             这边的get函数就是调用了Factory的get函数，用来返回ProxyClassFactory生成的代理类对象，同时因为supplier的实现类是Factory，Factory中把代理类包装成弱引用类型的cacheValue，然后放入valuesMap中，这样下次可以直接进行读入*/
             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)

         // 懒加载，直到需要使用的时候再去创建
         if (factory == null) {
         	 /*新建一个Factory实例作为subKey对应的值*/
             factory = new Factory(key, parameter, subKey, valuesMap);
         }
		 /*到这里表明subKey没有对应的值, 就将factory作为subKey的值放入*/
         if (supplier == null) {
         	/*根据concurrentHashmap的putIfAbsent函数知道这个返回的supplier对象就是根据subKey查出来的原来map表里的值，如果原来没有subKey对应的value，则返回null*/
             supplier = valuesMap.putIfAbsent(subKey, factory);
             /*说明二级缓存表中没有subKey对应的value，说明上面已经成功将subkey和对应的factroy放入到了二级缓存表中*/
             if (supplier == null) {
                 // 复制facory的值到supplier对象上
                 supplier = factory;
             }
             // 如果原来表中已经有了subKey对应的value的值，可能是之前的缓存值，这时候我们需要进行替换
         } else {
             if (valuesMap.replace(subKey, supplier, factory)) {
                 /*成功进行替换*/
                 supplier = factory;
             } else {
                /*替换失败，将获取到的最新subkey对应的value值放入到supplier，然后在下一个while循环中重试*/
                 supplier = valuesMap.get(subKey);
             }
         }
     }
 }

WeakCache的get方法并没有用锁进行同步，而他的成功都使用了ConcurrentMap，从而保证了相对的线程安全。我们看到ClassLoader作为了一级缓存的key，这样可以首先根据ClassLoader筛选一遍，因为不同ClassLoader加载的类是不同的。然后它用接口数组来生成二级缓存的key，这里它进行了一些优化，因为大部分类都是实现了一个或两个接口，所以二级缓存key分为key0，key1，key2，keyX。key0到key2分别表示实现了0到2个接口，keyX表示实现了3个或以上的接口，事实上大部分都只会用到key1和key2。这些key的生成工厂是在Proxy类中，通过WeakCache的构造器将key工厂传入。

如果没有找到代理类，那么就需要创建一个相应的代理类，这个是用ProxyClassFactory#apply函数来创建的。在一开始会获取到所有的需要创建的代理类接口的class对象，然后对是是否是public属性的proxy进行分包处理。最主要我们来看下这个函数最后部分的实现


        /*
         * 生成代理类的报名和类名
         */
        long num = nextUniqueNumber.getAndIncrement();
        String proxyName = proxyPkg + proxyClassNamePrefix + num;

        /*
         * 通过ProxyGenerator.generateProxyClass() 方法动态生成代理类字节码。
         */
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);
		/*
		 *通过classloader 动态加载 字节码，并生成动态代理类的Class实例，并返回
		 */
        try {
            return defineClass0(loader, proxyName,
                                proxyClassFile, 0, proxyClassFile.length);

这样就可以创建一个新的代理对象，然后最后获得这个代理对象对应的factory，这个factory的创建语句是
factory = new Factory(key, parameter, subKey, valuesMap)。我们可以通过这个factory的代理类工厂对象来创建对应的代理实例

Factory类分析

private final class Factory implements Supplier<V> {

        private final K key;
        private final P parameter;
        private final Object subKey;
        private final ConcurrentMap<Object, Supplier<V>> valuesMap;

        Factory(K key, P parameter, Object subKey,
                ConcurrentMap<Object, Supplier<V>> valuesMap) {
            this.key = key;
            this.parameter = parameter;
            this.subKey = subKey;
            this.valuesMap = valuesMap;
        }

        @Override
        public synchronized V get() { // serialize access
   
            Supplier<V> supplier = valuesMap.get(subKey);
             /*在这里验证supplier是否是Factory实例本身, 如果不则返回null让调用者继续轮询重试
               期间supplier可能替换成了CacheValue, 或者由于生成代理类失败被从二级缓存中移除了
            */
            if (supplier != this) {
                return null;
            }

            // create new value
            V value = null;
            try {
            	/*委托valueFactory去生成代理类, 这里会通过传入的ProxyClassFactory去生成代理类，返回代理类的参数*/
                value = Objects.requireNonNull(valueFactory.apply(key, parameter));
            } finally {
                if (value == null) { // 如果生成代理类失败, 就将这个二级缓存删除
                    valuesMap.remove(subKey, this);
                }
            }
            // the only path to reach here is with non-null value
            assert value != null;

            //将这个代理类对象包装成CacheValue（WeakReference）
            CacheValue<V> cacheValue = new CacheValue<>(value);

            // 将这个cacheValue放入缓存map中
            reverseMap.put(cacheValue, Boolean.TRUE);

            /* 尝试进行更新，这一操作必须成功,可以看到二级缓存中存放的对象是CacheValue类型的，这是 */
            if (!valuesMap.replace(subKey, this, cacheValue)) {
                throw new AssertionError("Should not reach here");
            }

          	/*返回代理类对象*/
            return value;
        }
    }

我们看到了Proxy内部用到了缓存机制，如果根据提供的类加载器和接口数组能在缓存中找到代理类就直接返回该代理类，否则会调用ProxyClassFactory工厂去生成代理类。这里用到的缓存是二级缓存，它的一级缓存key是根据类加载器生成的，二级缓存key是根据接口数组生成的。

3、总结

在这里插入图片描述

动态代理最重要的类是Proxy类，这个类特点是这个类的对象可以包含具体的实现类，然后返回这个具体实现类的接口对象（这个对象我们就称为代理类对象），这个代理对象非常特殊，因为他对外是我们定义的接口类型的，所以这个对象也能够通过接口知道这个接口里的方法哟哪些。但是这个对象实际实现是Proxy类型的，这个Proxy类型实现了InvocationHandler接口，这样我们调用相应的接口函数会自动调用到InvocationHandler里的invoke函数。个人自己可以将这个代理对象当做红娘，她将接口和我们实现的了InvocationHandler的中介函数绑定在一起，调用接口函数就是相当于调用中介函数中的invoke函数。同时我们的中介函数中又存在具体实现类的对象，那么最后我们就可以调用到具体实现类的函数实现。
Proxy.newInstance就是为我们创建了非常厉害的一个代理类对象，首先在查找代理类信息时用到了缓存技术，既保证了高效性，也保证了安全性。同时里面用到了newInstance这个动态创建对象的方法，正是这些方面共同实现了动态代理的方法。

曳凡

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
jdk源码分析(3) 动态代理实现

文章目录1、动态代理介绍及示例2、Proxy类源码分析3、总结1、动态代理介绍及示例首先我们先来看个例子public interface UserInterface { public void printUserInfo();}有一个实现了这个接口的实现类public class UserImpl implements UserInterface{ @Overr...
复制链接

扫一扫

专栏目录