面试重点：来说说DubboSPI机制

 [[357484]]

创新互联是一家专业提供大安市企业网站建设,专注与成都做网站、成都网站设计、H5高端网站建设、小程序制作等业务。10年已为大安市众多企业、政府机构等服务。创新互联专业的建站公司优惠进行中。

SPI是什么

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

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

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

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

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

3.两种实现应该如何写出来

Java SPI是如何实现的

先定义一个接口：

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

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

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

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

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

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

最后写一个测试代码：

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

执行完的输出结果：

 
 
 
 
    
  
  
  
  
  1. The train started 
    2. 
  
  
  
  
  2. The truck started 
    3.

Dubbo SPI是如何实现的

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

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

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

实现类不需要改动

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

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

最后就是测试类了，先看代码：

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

执行结果：

 
 
 
 
    
  
  
  
  
  1. The train started 
    2.

Dubbo SPI中常用的注解

  • @SPI 标记为扩展接口
  • @Adaptive自适应拓展实现类标志
  • @Activate 自动激活条件的标记

总结一下两者区别：

  • 使用上的区别Dubbo使用ExtensionLoader而不是ServiceLoader了，其主要逻辑都封装在这个类中
  • 配置文件存放目录不一样，Java的在META-INF/services，Dubbo在META-INF/dubbo，META-INF/dubbo/internal
  • Java SPI 会一次性实例化扩展点所有实现，如果有扩展实现初始化很耗时，并且又用不上，会造成大量资源被浪费
  • Dubbo SPI 增加了对扩展点 IOC 和 AOP 的支持，一个扩展点可以直接 setter 注入其它扩展点
  • Java SPI加载过程失败，扩展点的名称是拿不到的。比如：JDK 标准的 ScriptEngine，getName() 获取脚本类型的名称，如果 RubyScriptEngine 因为所依赖的 jruby.jar 不存在，导致 RubyScriptEngine 类加载失败，这个失败原因是不会有任何提示的，当用户执行 ruby 脚本时，会报不支持 ruby，而不是真正失败的原因

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

Dubbo SPI源码分析

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

 
 
 
 
    
  
  
  
  
  1. public T getExtension(String name) { 
    2. 
  
  
  
  
  2.     if (name == null || name.length() == 0) { 
    3. 
  
  
  
  
  3.         throw new IllegalArgumentException("Extension name == null"); 
    4. 
  
  
  
  
  4.     } 
    5. 
  
  
  
  
  5.     if ("true".equals(name)) { 
    6. 
  
  
  
  
  6.         // 获取默认的拓展实现类 
    7. 
  
  
  
  
  7.         return getDefaultExtension(); 
    8. 
  
  
  
  
  8.     } 
    9. 
  
  
  
  
  9.     // 用于持有目标对象 
    10. 
  
  
  
  
  10.     Holder holder = cachedInstances.get(name); 
  
  
  
  
  11.     if (holder == null) { 
    12. 
  
  
  
  
  12.         cachedInstances.putIfAbsent(name, new Holder()); 
  
  
  
  
  13.         holder = cachedInstances.get(name); 
    14. 
  
  
  
  
  14.     } 
    15. 
  
  
  
  
  15.     Object instance = holder.get(); 
    16. 
  
  
  
  
  16.     // DCL 
    17. 
  
  
  
  
  17.     if (instance == null) { 
    18. 
  
  
  
  
  18.         synchronized (holder) { 
    19. 
  
  
  
  
  19.             instance = holder.get(); 
    20. 
  
  
  
  
  20.             if (instance == null) { 
    21. 
  
  
  
  
  21.                 // 创建扩展实例 
    22. 
  
  
  
  
  22.                 instance = createExtension(name); 
    23. 
  
  
  
  
  23.                 // 设置实例到 holder 中 
    24. 
  
  
  
  
  24.                 holder.set(instance); 
    25. 
  
  
  
  
  25.             } 
    26. 
  
  
  
  
  26.         } 
    27. 
  
  
  
  
  27.     } 
    28. 
  
  
  
  
  28.     return (T) instance; 
    29. 
  
  
  
  
  29. } 
    30. 
 
 
 
 
    上面这一段代码主要做的事情就是先检查缓存，缓存不存在创建扩展对象
    接下来我们看看创建的过程：
     
 
 
 
      
  
  
  
  
    1. private T createExtension(String name) { 
      2. 
  
  
  
  
    2.     // 从配置文件中加载所有的扩展类，可得到“配置项名称”到“配置类”的映射关系表 
      3. 
  
  
  
  
    3.     Class clazz = getExtensionClasses().get(name); 
      4. 
  
  
  
  
    4.     if (clazz == null) { 
      5. 
  
  
  
  
    5.         throw findException(name); 
      6. 
  
  
  
  
    6.     } 
      7. 
  
  
  
  
    7.     try { 
      8. 
  
  
  
  
    8.         T instance = (T) EXTENSION_INSTANCES.get(clazz); 
      9. 
  
  
  
  
    9.         if (instance == null) { 
      10. 
  
  
  
  
    10.             // 反射创建实例 
      11. 
  
  
  
  
    11.             EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance()); 
      12. 
  
  
  
  
    12.             instance = (T) EXTENSION_INSTANCES.get(clazz); 
      13. 
  
  
  
  
    13.         } 
      14. 
  
  
  
  
    14.         // 向实例中注入依赖 
      15. 
  
  
  
  
    15.         injectExtension(instance); 
      16. 
  
  
  
  
    16.         Set> wrapperClasses = cachedWrapperClasses; 
      17. 
  
  
  
  
    17.         if (wrapperClasses != null && !wrapperClasses.isEmpty()) { 
      18. 
  
  
  
  
    18.             // 循环创建 Wrapper 实例 
      19. 
  
  
  
  
    19.             for (Class wrapperClass : wrapperClasses) { 
      20. 
  
  
  
  
    20.                 // 将当前 instance 作为参数传给 Wrapper 的构造方法，并通过反射创建 Wrapper 实例。 
      21. 
  
  
  
  
    21.                 // 然后向 Wrapper 实例中注入依赖，最后将 Wrapper 实例再次赋值给 instance 变量 
      22. 
  
  
  
  
    22.                 instance = injectExtension( 
      23. 
  
  
  
  
    23.                     (T) wrapperClass.getConstructor(type).newInstance(instance)); 
      24. 
  
  
  
  
    24.             } 
      25. 
  
  
  
  
    25.         } 
      26. 
  
  
  
  
    26.         return instance; 
      27. 
  
  
  
  
    27.     } catch (Throwable t) { 
      28. 
  
  
  
  
    28.         throw new IllegalStateException("Extension instance (name: " + name + ", class: " + 
      29. 
  
  
  
  
    29.                     type + ") couldn't be instantiated: " + t.getMessage(), t); 
      30. 
  
  
  
  
    30.     } 
      31. 
  
  
  
  
    31. } 
      32. 
 
 
 
 
    这段代码看着繁琐，其实也不难，一共只做了4件事情：
    1.通过getExtensionClasses获取所有配置扩展类
    2.反射创建对象
    3.给扩展类注入依赖
    4.将扩展类对象包裹在对应的Wrapper对象里面
    我们在通过名称获取扩展类之前，首先需要根据配置文件解析出扩展类名称到扩展类的映射关系表，之后再根据扩展项名称从映射关系表中取出相应的拓展类即可。相关过程的代码如下：
     
 
 
 
      
  
  
  
  
    1. private Map> getExtensionClasses() { 
      2. 
  
  
  
  
    2.     // 从缓存中获取已加载的拓展类 
      3. 
  
  
  
  
    3.     Map> classes = cachedClasses.get(); 
      4. 
  
  
  
  
    4.     // DCL 
      5. 
  
  
  
  
    5.     if (classes == null) { 
      6. 
  
  
  
  
    6.         synchronized (cachedClasses) { 
      7. 
  
  
  
  
    7.             classes = cachedClasses.get(); 
      8. 
  
  
  
  
    8.             if (classes == null) { 
      9. 
  
  
  
  
    9.                 // 加载扩展类 
      10. 
  
  
  
  
    10.                 classes = loadExtensionClasses(); 
      11. 
  
  
  
  
    11.                 cachedClasses.set(classes); 
      12. 
  
  
  
  
    12.             } 
      13. 
  
  
  
  
    13.         } 
      14. 
  
  
  
  
    14.     } 
      15. 
  
  
  
  
    15.     return classes; 
      16. 
  
  
  
  
    16. } 
      17. 
 
 
 
 
    这里也是先检查缓存，若缓存没有，则通过一次双重锁检查缓存，判空。此时如果 classes 仍为 null，则通过 loadExtensionClasses 加载拓展类。下面是 loadExtensionClasses 方法的代码
     
 
 
 
      
  
  
  
  
    1. private Map> loadExtensionClasses() { 
      2. 
  
  
  
  
    2.     // 获取 SPI 注解，这里的 type 变量是在调用 getExtensionLoader 方法时传入的 
      3. 
  
  
  
  
    3.     final SPI defaultAnnotation = type.getAnnotation(SPI.class); 
      4. 
  
  
  
  
    4.     if (defaultAnnotation != null) { 
      5. 
  
  
  
  
    5.         String value = defaultAnnotation.value(); 
      6. 
  
  
  
  
    6.         if ((value = value.trim()).length() > 0) { 
      7. 
  
  
  
  
    7.             // 对 SPI 注解内容进行切分 
      8. 
  
  
  
  
    8.             String[] names = NAME_SEPARATOR.split(value); 
      9. 
  
  
  
  
    9.             // 检测 SPI 注解内容是否合法，不合法则抛出异常 
      10. 
  
  
  
  
    10.             if (names.length > 1) { 
      11. 
  
  
  
  
    11.                 throw new IllegalStateException("more than 1 default extension name on extension..."); 
      12. 
  
  
  
  
    12.             } 
      13. 
  
  
  
  
    13.  
      14. 
  
  
  
  
    14.             // 设置默认名称，参考 getDefaultExtension 方法 
      15. 
  
  
  
  
    15.             if (names.length == 1) { 
      16. 
  
  
  
  
    16.                 cachedDefaultName = names[0]; 
      17. 
  
  
  
  
    17.             } 
      18. 
  
  
  
  
    18.         } 
      19. 
  
  
  
  
    19.     } 
      20. 
  
  
  
  
    20.  
      21. 
  
  
  
  
    21.     Map> extensionClasses = new HashMap>(); 
      22. 
  
  
  
  
    22.     // 加载指定文件夹下的配置文件 
      23. 
  
  
  
  
    23.     loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY); 
      24. 
  
  
  
  
    24.     loadDirectory(extensionClasses, DUBBO_DIRECTORY); 
      25. 
  
  
  
  
    25.     loadDirectory(extensionClasses, SERVICES_DIRECTORY); 
      26. 
  
  
  
  
    26.     return extensionClasses; 
      27. 
  
  
  
  
    27. } 
      28. 
 
 
 
 
    loadExtensionClasses 方法总共做了两件事情，一是对 SPI 注解进行解析，二是调用 loadDirectory 方法加载指定文件夹配置文件。SPI 注解解析过程比较简单，无需多说。下面我们来看一下 loadDirectory 做了哪些事情
     
 
 
 
      
  
  
  
  
    1. private void loadDirectory(Map> extensionClasses, String dir) { 
      2. 
  
  
  
  
    2.     // fileName = 文件夹路径 + type 全限定名  
      3. 
  
  
  
  
    3.     String fileName = dir + type.getName(); 
      4. 
  
  
  
  
    4.     try { 
      5. 
  
  
  
  
    5.         Enumeration urls; 
      6. 
  
  
  
  
    6.         ClassLoader classLoader = findClassLoader(); 
      7. 
  
  
  
  
    7.         // 根据文件名加载所有的同名文件 
      8. 
  
  
  
  
    8.         if (classLoader != null) { 
      9. 
  
  
  
  
    9.             urls = classLoader.getResources(fileName); 
      10. 
  
  
  
  
    10.         } else { 
      11. 
  
  
  
  
    11.             urls = ClassLoader.getSystemResources(fileName); 
      12. 
  
  
  
  
    12.         } 
      13. 
  
  
  
  
    13.         if (urls != null) { 
      14. 
  
  
  
  
    14.             while (urls.hasMoreElements()) { 
      15. 
  
  
  
  
    15.                 java.net.URL resourceURL = urls.nextElement(); 
      16. 
  
  
  
  
    16.                 // 加载资源 
      17. 
  
  
  
  
    17.                 loadResource(extensionClasses, classLoader, resourceURL); 
      18. 
  
  
  
  
    18.             } 
      19. 
  
  
  
  
    19.         } 
      20. 
  
  
  
  
    20.     } catch (Throwable t) { 
      21. 
  
  
  
  
    21.         logger.error("Exception occurred when loading extension class (interface: " + 
      22. 
  
  
  
  
    22.                     type + ", description file: " + fileName + ").", t); 
      23. 
  
  
  
  
    23.     } 
      24. 
  
  
  
  
    24. } 
      25. 
 
 
 
 
    loadDirectory 方法先通过 classLoader 获取所有资源链接，然后再通过 loadResource 方法加载资源。我们继续跟下去，看一下 loadResource 方法的实现
     
 
 
 
      
  
  
  
  
    1. private void loadResource(Map> extensionClasses, ClassLoader classLoader, 
      2. 
  
  
  
  
    2.                           java.net.URL resourceURL) { 
      3. 
  
  
  
  
    3.     try { 
      4. 
  
  
  
  
    4.         BufferedReader reader = new BufferedReader( 
      5. 
  
  
  
  
    5.             new InputStreamReader(resourceURL.openStream(), "utf-8")); 
      6. 
  
  
  
  
    6.         try { 
      7. 
  
  
  
  
    7.             String line; 
      8. 
  
  
  
  
    8.             // 按行读取配置内容 
      9. 
  
  
  
  
    9.             while ((line = reader.readLine()) != null) { 
      10. 
  
  
  
  
    10.                 // 定位 # 字符 
      11. 
  
  
  
  
    11.                 final int ci = line.indexOf('#'); 
      12. 
  
  
  
  
    12.                 if (ci >= 0) { 
      13. 
  
  
  
  
    13.                     // 截取 # 之前的字符串，# 之后的内容为注释，需要忽略 
      14. 
  
  
  
  
    14.                     line = line.substring(0, ci); 
      15. 
  
  
  
  
    15.                 } 
      16. 
  
  
  
  
    16.                 line = line.trim(); 
      17. 
  
  
  
  
    17.                 if (line.length() > 0) { 
      18. 
  
  
  
  
    18.                     try { 
      19. 
  
  
  
  
    19.                         String name = null; 
      20. 
  
  
  
  
    20.                         int i = line.indexOf('='); 
      21. 
  
  
  
  
    21.                         if (i > 0) { 
      22. 
  
  
  
  
    22.                             // 以等于号 = 为界，截取键与值 
      23. 
  
  
  
  
    23.                             name = line.substring(0, i).trim(); 
      24. 
  
  
  
  
    24.                             line = line.substring(i + 1).trim(); 
      25. 
  
  
  
  
    25.                         } 
      26. 
  
  
  
  
    26.                         if (line.length() > 0) { 
      27. 
  
  
  
  
    27.                             // 加载类，并通过 loadClass 方法对类进行缓存 
      28. 
  
  
  
  
    28.                             loadClass(extensionClasses, resourceURL,  
      29. 
  
  
  
  
    29.                                       Class.forName(line, true, classLoader), name); 
      30. 
  
  
  
  
    30.                         } 
      31. 
  
  
  
  
    31.                     } catch (Throwable t) { 
      32. 
  
  
  
  
    32.                         IllegalStateException e = 
      33. 
  
  
  
  
    33.                           new IllegalStateException("Failed to load extension class..."); 
      34. 
  
  
  
  
    34.                     } 
      35. 
  
  
  
  
    35.                 } 
      36. 
  
  
  
  
    36.             } 
      37. 
  
  
  
  
    37.         } finally { 
      38. 
  
  
  
  
    38.             reader.close(); 
      39. 
  
  
  
  
    39.         } 
      40. 
  
  
  
  
    40.     } catch (Throwable t) { 
      41. 
  
  
  
  
    41.         logger.error("Exception when load extension class..."); 
      42. 
  
  
  
  
    42.     } 
      43. 
  
  
  
  
    43. } 
      44. 
 
 
 
 
    loadResource 方法用于读取和解析配置文件，并通过反射加载类，最后调用 loadClass 方法进行其他操作。loadClass 方法用于主要用于操作缓存，该方法的逻辑如下：
     
 
 
 
      
  
  
  
  
    1. private void loadClass(Map> extensionClasses, java.net.URL resourceURL,  
      2. 
  
  
  
  
    2.     Class clazz, String name) throws NoSuchMethodException { 
      3. 
  
  
  
  
    3.      
      4. 
  
  
  
  
    4.     if (!type.isAssignableFrom(clazz)) { 
      5. 
  
  
  
  
    5.         throw new IllegalStateException("..."); 
      6. 
  
  
  
  
    6.     } 
      7. 
  
  
  
  
    7.  
      8. 
  
  
  
  
    8.     // 检测目标类上是否有 Adaptive 注解 
      9. 
  
  
  
  
    9.     if (clazz.isAnnotationPresent(Adaptive.class)) { 
      10. 
  
  
  
  
    10.         if (cachedAdaptiveClass == null) { 
      11. 
  
  
  
  
    11.             // 设置 cachedAdaptiveClass缓存 
      12. 
  
  
  
  
    12.             cachedAdaptiveClass = clazz; 
      13. 
  
  
  
  
    13.         } else if (!cachedAdaptiveClass.equals(clazz)) { 
      14. 
  
  
  
  
    14.             throw new IllegalStateException("..."); 
      15. 
  
  
  
  
    15.         } 
      16. 
  
  
  
  
    16.          
      17. 
  
  
  
  
    17.     // 检测 clazz 是否是 Wrapper 类型 
      18. 
  
  
  
  
    18.     } else if (isWrapperClass(clazz)) { 
      19. 
  
  
  
  
    19.         Set> wrappers = cachedWrapperClasses; 
      20. 
  
  
  
  
    20.         if (wrappers == null) { 
      21. 
  
  
  
  
    21.             cachedWrapperClasses = new ConcurrentHashSet>(); 
      22. 
  
  
  
  
    22.             wrappers = cachedWrapperClasses; 
      23. 
  
  
  
  
    23.         } 
      24. 
  
  
  
  
    24.         // 存储 clazz 到 cachedWrapperClasses 缓存中 
      25. 
  
  
  
  
    25.         wrappers.add(clazz); 
      26. 
  
  
  
  
    26.          
      27. 
  
  
  
  
    27.     // 程序进入此分支，表明 clazz 是一个普通的拓展类 
      28. 
  
  
  
  
    28.     } else { 
      29. 
  
  
  
  
    29.         // 检测 clazz 是否有默认的构造方法，如果没有，则抛出异常 
      30. 
  
  
  
  
    30.         clazz.getConstructor(); 
      31. 
  
  
  
  
    31.         if (name == null || name.length() == 0) { 
      32. 
  
  
  
  
    32.             // 如果 name 为空，则尝试从 Extension 注解中获取 name，或使用小写的类名作为 name 
      33. 
  
  
  
  
    33.             name = findAnnotationName(clazz); 
      34. 
  
  
  
  
    34.             if (name.length() == 0) { 
      35. 
  
  
  
  
    35.                 throw new IllegalStateException("..."); 
      36. 
  
  
  
  
    36.             } 
      37. 
  
  
  
  
    37.         } 
      38. 
  
  
  
  
    38.         // 切分 name 
      39. 
  
  
  
  
    39.         String[] names = NAME_SEPARATOR.split(name); 
      40. 
  
  
  
  
    40.         if (names != null && names.length > 0) { 
      41. 
  
  
  
  
    41.             Activate activate = clazz.getAnnotation(Activate.class); 
      42. 
  
  
  
  
    42.             if (activate != null) { 
      43. 
  
  
  
  
    43.                 // 如果类上有 Activate 注解，则使用 names 数组的第一个元素作为键， 
      44. 
  
  
  
  
    44.                 // 存储 name 到 Activate 注解对象的映射关系 
      45. 
  
  
  
  
    45.                 cachedActivates.put(names[0], activate); 
      46. 
  
  
  
  
    46.             } 
      47. 
  
  
  
  
    47.             for (String n : names) { 
      48. 
  
  
  
  
    48.                 if (!cachedNames.containsKey(clazz)) { 
      49. 
  
  
  
  
    49.                     // 存储 Class 到名称的映射关系 
      50. 
  
  
  
  
    50.                     cachedNames.put(clazz, n); 
      51. 
  
  
  
  
    51.                 } 
      52. 
  
  
  
  
    52.                 Class c = extensionClasses.get(n); 
      53. 
  
  
  
  
    53.                 if (c == null) { 
      54. 
  
  
  
  
    54.                     // 存储名称到 Class 的映射关系 
      55. 
  
  
  
  
    55.                     extensionClasses.put(n, clazz); 
      56. 
  
  
  
  
    56.                 } else if (c != clazz) { 
      57. 
  
  
  
  
    57.                     throw new IllegalStateException("..."); 
      58. 
  
  
  
  
    58.                 } 
      59. 
  
  
  
  
    59.             } 
      60. 
  
  
  
  
    60.         } 
      61. 
  
  
  
  
    61.     } 
      62. 
  
  
  
  
    62. } 
      63. 
 
 
 
 
    综上，loadClass方法操作了不同的缓存，比如cachedAdaptiveClass、cachedWrapperClasses和cachedNames等等
    到这里基本上关于缓存类加载的过程就分析完了，其他逻辑不难，认真地读下来加上Debug一下都能看懂的。
    总结
    从设计思想上来看的话，SPI是对迪米特法则和开闭原则的一种实现。
    开闭原则：对修改关闭对扩展开放。这个原则在众多开源框架中都非常常见，Spring的IOC容器也是大量使用。
    迪米特法则：也叫最小知识原则，可以解释为，不该直接依赖关系的类之间，不要依赖;有依赖关系的类之间，尽量只依赖必要的接口。
    那Dubbo的SPI为什么不直接使用Spring的呢，这一点从众多开源框架中也许都能窥探一点端倪出来，因为本身作为开源框架是要融入其他框架或者一起运行的，不能作为依赖被依赖对象存在。
    再者对于Dubbo来说，直接用Spring IOC AOP的话有一些架构臃肿，完全没必要，所以自己实现一套轻量级反而是最优解
     本文转载自微信公众号「 架构技术专栏」，可以通过以下二维码关注。转载本文请联系 架构技术专栏公众号。
                
    
                网站栏目：面试重点：来说说DubboSPI机制
                
    
                文章URL：http://www.csdahua.cn/qtweb/news0/37750.html
            
    
            
    
                网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                快上网
            
    
        
        
    
            
    成都快上网为您推荐相关内容
    
            
        
    
    
    
    
        
    
            
    网站内链知识
    
            
        
    
        
    
            
    行业网站建设
    
            
        
    
    
    


    
    
    
        关键词优化　　 　乐山电信机房　　 　门户网站建设方案　　 　成都服务器运维　　 　成都搅拌罐车　　 　绵阳电信机房　　 　西部信息机房　　 　网站建设方案　　 　成都托管服务器　　 　眉山网站建设　　 　seo优化排名　　 　郫县门窗定制　　 　广汉网站建设　　 　定制网站　　 　成都企业注册服务　　 　西信服务器托管　　 　重庆电商网站定制　　 　成都外贸网站优化　　 　成都网站建设　　 　四川平武网站建设