文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

面试重点: 来说说Dubbo SPI 机制

2024-12-03 16:08

关注

SPI是什么

SPI是一种简称,全名叫 Service Provider Interface,Java本身提供了一套SPI机制,SPI 的本质是将接口实现类的全限定名配置在文件中,并由服务加载器读取配置文件,加载实现类,这样可以在运行时,动态为接口替换实现类,这也是很多框架组件实现扩展功能的一种手段。

而今天要说的Dubbo SPI机制和Java SPI还是有一点区别的,Dubbo 并未使用 Java 原生的 SPI 机制,而是对他进行了改进增强,进而可以很容易地对Dubbo进行功能上的扩展。

学东西得带着问题去学,我们先提几个问题,再接着看

什么是SPI(开头已经解释了)

Dubbo SPI和Java原生的有什么区别

两种实现应该如何写出来

Java SPI是如何实现的

先定义一个接口:

 

  1. public interface Car { 
  2.  void startUp(); 

然后创建两个类,都实现这个Car接口

 

  1. public class Truck implements Car{ 
  2.  @Override 
  3.  public void startUp() { 
  4.   System.out.println("The truck started"); 
  5.  } 
  6.  
  7. public class Train implements Car{ 
  8.  @Override 
  9.  public void startUp() { 
  10.   System.out.println("The train started"); 
  11.  } 

然后在项目META-INF/services文件夹下创建一个名称为接口的全限定名,com.example.demo.spi.Car。

文件内容写上实现类的全限定名,如下:

 

  1. com.example.demo.spi.Train 
  2. com.example.demo.spi.Truck 

最后写一个测试代码:

 

  1. public class JavaSPITest { 
  2.  @Test 
  3.  public void testCar() { 
  4.   ServiceLoader serviceLoader = ServiceLoader.load(Car.class); 
  5.   serviceLoader.forEach(Car::startUp); 
  6.  } 

执行完的输出结果:

 

  1. The train started 
  2. The truck started 

Dubbo SPI是如何实现的

Dubbo 使用的SPI并不是Java原生的,而是重新实现了一套,其主要逻辑都在ExtensionLoader类中,逻辑也不难,后面会稍带讲一下

看看使用,和Java的差不了太多,基于前面的例子来看下,接口类需要加上@SPI注解:

 

  1. @SPI 
  2. public interface Car { 
  3.  void startUp(); 

实现类不需要改动

配置文件需要放在META-INF/dubbo下面,配置写法有些区别,直接看代码:

 

  1. train = com.example.demo.spi.Train 
  2. truck = com.example.demo.spi.Truck 

最后就是测试类了,先看代码:

 

  1. public class JavaSPITest { 
  2.  @Test 
  3.  public void testCar() { 
  4.   ExtensionLoader extensionLoader = ExtensionLoader.getExtensionLoader(Car.class); 
  5.   Car car = extensionLoader.getExtension("train"); 
  6.   car.startUp(); 
  7.  } 

执行结果:

  1. The train started 

Dubbo SPI中常用的注解

总结一下两者区别:

前面的3个问题是不是已经能回答出来了?是不是非常简单

Dubbo SPI源码分析

Dubbo SPI使用上是通过ExtensionLoader的getExtensionLoader方法获取一个 ExtensionLoader 实例,然后再通过 ExtensionLoader 的 getExtension 方法获取拓展类对象。这其中,getExtensionLoader 方法用于从缓存中获取与拓展类对应的 ExtensionLoader,如果没有缓存,则创建一个新的实例,直接上代码:

 

  1. public T getExtension(String name) { 
  2.     if (name == null || name.length() == 0) { 
  3.         throw new IllegalArgumentException("Extension name == null"); 
  4.     } 
  5.     if ("true".equals(name)) { 
  6.         // 获取默认的拓展实现类 
  7.         return getDefaultExtension(); 
  8.     } 
  9.     // 用于持有目标对象 
  10.     Holder holder = cachedInstances.get(name); 
  11.     if (holder == null) { 
  12.         cachedInstances.putIfAbsent(name, new Holder()); 
  13.         holder = cachedInstances.get(name); 
  14.     } 
  15.     Object instance = holder.get(); 
  16.     // DCL 
  17.     if (instance == null) { 
  18.         synchronized (holder) { 
  19.             instance = holder.get(); 
  20.             if (instance == null) { 
  21.                 // 创建扩展实例 
  22.                 instance = createExtension(name); 
  23.                 // 设置实例到 holder 中 
  24.                 holder.set(instance); 
  25.             } 
  26.         } 
  27.     } 
  28.     return (T) instance; 
  29. 上面这一段代码主要做的事情就是先检查缓存,缓存不存在创建扩展对象

    接下来我们看看创建的过程:

     

    1. private T createExtension(String name) { 
    2.     // 从配置文件中加载所有的扩展类,可得到“配置项名称”到“配置类”的映射关系表 
    3.     Class clazz = getExtensionClasses().get(name); 
    4.     if (clazz == null) { 
    5.         throw findException(name); 
    6.     } 
    7.     try { 
    8.         T instance = (T) EXTENSION_INSTANCES.get(clazz); 
    9.         if (instance == null) { 
    10.             // 反射创建实例 
    11.             EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance()); 
    12.             instance = (T) EXTENSION_INSTANCES.get(clazz); 
    13.         } 
    14.         // 向实例中注入依赖 
    15.         injectExtension(instance); 
    16.         Set> wrapperClasses = cachedWrapperClasses; 
    17.         if (wrapperClasses != null && !wrapperClasses.isEmpty()) { 
    18.             // 循环创建 Wrapper 实例 
    19.             for (Class wrapperClass : wrapperClasses) { 
    20.                 // 将当前 instance 作为参数传给 Wrapper 的构造方法,并通过反射创建 Wrapper 实例。 
    21.                 // 然后向 Wrapper 实例中注入依赖,最后将 Wrapper 实例再次赋值给 instance 变量 
    22.                 instance = injectExtension( 
    23.                     (T) wrapperClass.getConstructor(type).newInstance(instance)); 
    24.             } 
    25.         } 
    26.         return instance; 
    27.     } catch (Throwable t) { 
    28.         throw new IllegalStateException("Extension instance (name: " + name + ", class: " + 
    29.                     type + ") couldn't be instantiated: " + t.getMessage(), t); 
    30.     } 

    这段代码看着繁琐,其实也不难,一共只做了4件事情:

    通过getExtensionClasses获取所有配置扩展类

    反射创建对象

    给扩展类注入依赖

    将扩展类对象包裹在对应的Wrapper对象里面

    我们在通过名称获取扩展类之前,首先需要根据配置文件解析出扩展类名称到扩展类的映射关系表,之后再根据扩展项名称从映射关系表中取出相应的拓展类即可。相关过程的代码如下:

     

    1. private Map> getExtensionClasses() { 
    2.     // 从缓存中获取已加载的拓展类 
    3.     Map> classes = cachedClasses.get(); 
    4.     // DCL 
    5.     if (classes == null) { 
    6.         synchronized (cachedClasses) { 
    7.             classes = cachedClasses.get(); 
    8.             if (classes == null) { 
    9.                 // 加载扩展类 
    10.                 classes = loadExtensionClasses(); 
    11.                 cachedClasses.set(classes); 
    12.             } 
    13.         } 
    14.     } 
    15.     return classes; 

    这里也是先检查缓存,若缓存没有,则通过一次双重锁检查缓存,判空。此时如果 classes 仍为 null,则通过 loadExtensionClasses 加载拓展类。下面是 loadExtensionClasses 方法的代码

     

    1. private Map> loadExtensionClasses() { 
    2.     // 获取 SPI 注解,这里的 type 变量是在调用 getExtensionLoader 方法时传入的 
    3.     final SPI defaultAnnotation = type.getAnnotation(SPI.class); 
    4.     if (defaultAnnotation != null) { 
    5.         String value = defaultAnnotation.value(); 
    6.         if ((value = value.trim()).length() > 0) { 
    7.             // 对 SPI 注解内容进行切分 
    8.             String[] names = NAME_SEPARATOR.split(value); 
    9.             // 检测 SPI 注解内容是否合法,不合法则抛出异常 
    10.             if (names.length > 1) { 
    11.                 throw new IllegalStateException("more than 1 default extension name on extension..."); 
    12.             } 
    13.  
    14.             // 设置默认名称,参考 getDefaultExtension 方法 
    15.             if (names.length == 1) { 
    16.                 cachedDefaultName = names[0]; 
    17.             } 
    18.         } 
    19.     } 
    20.  
    21.     Map> extensionClasses = new HashMap>(); 
    22.     // 加载指定文件夹下的配置文件 
    23.     loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY); 
    24.     loadDirectory(extensionClasses, DUBBO_DIRECTORY); 
    25.     loadDirectory(extensionClasses, SERVICES_DIRECTORY); 
    26.     return extensionClasses; 

    loadExtensionClasses 方法总共做了两件事情,一是对 SPI 注解进行解析,二是调用 loadDirectory 方法加载指定文件夹配置文件。SPI 注解解析过程比较简单,无需多说。下面我们来看一下 loadDirectory 做了哪些事情

     

    1. private void loadDirectory(Map> extensionClasses, String dir) { 
    2.     // fileName = 文件夹路径 + type 全限定名  
    3.     String fileName = dir + type.getName(); 
    4.     try { 
    5.         Enumeration urls; 
    6.         ClassLoader classLoader = findClassLoader(); 
    7.         // 根据文件名加载所有的同名文件 
    8.         if (classLoader != null) { 
    9.             urls = classLoader.getResources(fileName); 
    10.         } else { 
    11.             urls = ClassLoader.getSystemResources(fileName); 
    12.         } 
    13.         if (urls != null) { 
    14.             while (urls.hasMoreElements()) { 
    15.                 java.net.URL resourceURL = urls.nextElement(); 
    16.                 // 加载资源 
    17.                 loadResource(extensionClasses, classLoader, resourceURL); 
    18.             } 
    19.         } 
    20.     } catch (Throwable t) { 
    21.         logger.error("Exception occurred when loading extension class (interface: " + 
    22.                     type + ", description file: " + fileName + ").", t); 
    23.     } 

    loadDirectory 方法先通过 classLoader 获取所有资源链接,然后再通过 loadResource 方法加载资源。我们继续跟下去,看一下 loadResource 方法的实现

     

    1. private void loadResource(Map> extensionClasses, ClassLoader classLoader, 
    2.                           java.net.URL resourceURL) { 
    3.     try { 
    4.         BufferedReader reader = new BufferedReader( 
    5.             new InputStreamReader(resourceURL.openStream(), "utf-8")); 
    6.         try { 
    7.             String line; 
    8.             // 按行读取配置内容 
    9.             while ((line = reader.readLine()) != null) { 
    10.                 // 定位 # 字符 
    11.                 final int ci = line.indexOf('#'); 
    12.                 if (ci >= 0) { 
    13.                     // 截取 # 之前的字符串,# 之后的内容为注释,需要忽略 
    14.                     line = line.substring(0, ci); 
    15.                 } 
    16.                 line = line.trim(); 
    17.                 if (line.length() > 0) { 
    18.                     try { 
    19.                         String name = null
    20.                         int i = line.indexOf('='); 
    21.                         if (i > 0) { 
    22.                             // 以等于号 = 为界,截取键与值 
    23.                             name = line.substring(0, i).trim(); 
    24.                             line = line.substring(i + 1).trim(); 
    25.                         } 
    26.                         if (line.length() > 0) { 
    27.                             // 加载类,并通过 loadClass 方法对类进行缓存 
    28.                             loadClass(extensionClasses, resourceURL,  
    29.                                       Class.forName(line, true, classLoader), name); 
    30.                         } 
    31.                     } catch (Throwable t) { 
    32.                         IllegalStateException e = 
    33.                           new IllegalStateException("Failed to load extension class..."); 
    34.                     } 
    35.                 } 
    36.             } 
    37.         } finally { 
    38.             reader.close(); 
    39.         } 
    40.     } catch (Throwable t) { 
    41.         logger.error("Exception when load extension class..."); 
    42.     } 

    loadResource 方法用于读取和解析配置文件,并通过反射加载类,最后调用 loadClass 方法进行其他操作。loadClass 方法用于主要用于操作缓存,该方法的逻辑如下:

     

    1. private void loadClass(Map> extensionClasses, java.net.URL resourceURL,  
    2.     Class clazz, String name) throws NoSuchMethodException { 
    3.      
    4.     if (!type.isAssignableFrom(clazz)) { 
    5.         throw new IllegalStateException("..."); 
    6.     } 
    7.  
    8.     // 检测目标类上是否有 Adaptive 注解 
    9.     if (clazz.isAnnotationPresent(Adaptive.class)) { 
    10.         if (cachedAdaptiveClass == null) { 
    11.             // 设置 cachedAdaptiveClass缓存 
    12.             cachedAdaptiveClass = clazz; 
    13.         } else if (!cachedAdaptiveClass.equals(clazz)) { 
    14.             throw new IllegalStateException("..."); 
    15.         } 
    16.          
    17.     // 检测 clazz 是否是 Wrapper 类型 
    18.     } else if (isWrapperClass(clazz)) { 
    19.         Set> wrappers = cachedWrapperClasses; 
    20.         if (wrappers == null) { 
    21.             cachedWrapperClasses = new ConcurrentHashSet>(); 
    22.             wrappers = cachedWrapperClasses; 
    23.         } 
    24.         // 存储 clazz 到 cachedWrapperClasses 缓存中 
    25.         wrappers.add(clazz); 
    26.          
    27.     // 程序进入此分支,表明 clazz 是一个普通的拓展类 
    28.     } else { 
    29.         // 检测 clazz 是否有默认的构造方法,如果没有,则抛出异常 
    30.         clazz.getConstructor(); 
    31.         if (name == null || name.length() == 0) { 
    32.             // 如果 name 为空,则尝试从 Extension 注解中获取 name,或使用小写的类名作为 name 
    33.             name = findAnnotationName(clazz); 
    34.             if (name.length() == 0) { 
    35.                 throw new IllegalStateException("..."); 
    36.             } 
    37.         } 
    38.         // 切分 name 
    39.         String[] names = NAME_SEPARATOR.split(name); 
    40.         if (names != null && names.length > 0) { 
    41.             Activate activate = clazz.getAnnotation(Activate.class); 
    42.             if (activate != null) { 
    43.                 // 如果类上有 Activate 注解,则使用 names 数组的第一个元素作为键, 
    44.                 // 存储 name 到 Activate 注解对象的映射关系 
    45.                 cachedActivates.put(names[0], activate); 
    46.             } 
    47.             for (String n : names) { 
    48.                 if (!cachedNames.containsKey(clazz)) { 
    49.                     // 存储 Class 到名称的映射关系 
    50.                     cachedNames.put(clazz, n); 
    51.                 } 
    52.                 Class c = extensionClasses.get(n); 
    53.                 if (c == null) { 
    54.                     // 存储名称到 Class 的映射关系 
    55.                     extensionClasses.put(n, clazz); 
    56.                 } else if (c != clazz) { 
    57.                     throw new IllegalStateException("..."); 
    58.                 } 
    59.             } 
    60.         } 
    61.     } 

    综上,loadClass方法操作了不同的缓存,比如cachedAdaptiveClass、cachedWrapperClasses和cachedNames等等

    到这里基本上关于缓存类加载的过程就分析完了,其他逻辑不难,认真地读下来加上Debug一下都能看懂的。

    总结

    从设计思想上来看的话,SPI是对迪米特法则和开闭原则的一种实现。

    开闭原则:对修改关闭对扩展开放。这个原则在众多开源框架中都非常常见,Spring的IOC容器也是大量使用。

    迪米特法则:也叫最小知识原则,可以解释为,不该直接依赖关系的类之间,不要依赖;有依赖关系的类之间,尽量只依赖必要的接口。

    那Dubbo的SPI为什么不直接使用Spring的呢,这一点从众多开源框架中也许都能窥探一点端倪出来,因为本身作为开源框架是要融入其他框架或者一起运行的,不能作为依赖被依赖对象存在。

    再者对于Dubbo来说,直接用Spring IOC AOP的话有一些架构臃肿,完全没必要,所以自己实现一套轻量级反而是最优解

     本文转载自微信公众号「 架构技术专栏」,可以通过以下二维码关注。转载本文请联系 架构技术专栏公众号。

     

    免责声明:

    ① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

    ② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

    软考中级精品资料免费领

    • 历年真题答案解析
    • 备考技巧名师总结
    • 高频考点精准押题
    • 资料下载
    • 历年真题
    • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

      难度     813人已做
      查看
    • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

      难度     354人已做
      查看
    • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

      难度     318人已做
      查看
    • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

      难度     435人已做
      查看
    • 2024年上半年系统架构设计师考试综合知识真题

      难度     224人已做
      查看

    相关文章

    发现更多好内容
    咦!没有更多了?去看看其它编程学习网 内容吧