> 欢迎大家关注 [github.com/hsfxuebao](https://link.juejin.cn/?target=https%3A%2F%2Fgithub.com%2Fhsfxuebao "https://github.com/hsfxuebao") ，希望对大家有所帮助，要是觉得可以的话麻烦给点一下Star哈所谓 Dubbo 的内核是指， Dubbo 中所有功能都是基于它之上完成的，都是由它作为基础的。 Dubbo 内核的工作原理由四部分构成：`服务发现机制 SPI、自适应机制 Adaptive、包装机制 Wrapper 与激活机制 Activate`。 Dubbo 通过这四种机制实现了对插件的 IoC、 AOP，实现了对自动生成类的动态编译 Compile。 # 1. SPI机制 SPI 全称为 `Service Provider Interface`，是一种`服务发现机制`。SPI 的本质是`将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类`。这样可以在运行时，`动态为接口替换实现类`。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。 ## 1.1 JDK 服务发现SPI机制 JDK 的 SPI 规范规定： - `接口名`：可随意定义 - `实现类名`：可随意定义 - `提供者配置文件路径`：其查找的目录为 META-INF/services - `提供者配置文件名称`：接口的全限定性类名，没有扩展名。 - `提供者配置文件内容`：该接口的所有实现类的全限类性类名写入到该文件中，一个类名占一行 Java SPI 实际上是“`基于接口的编程＋策略模式＋配置文件`”组合实现的动态加载机制。 ### 1.1.1 入门案例定义接口： ```java public interface SomeService { void hello(); } ``` 接下来定义两个实现类: ```java public class OneServiceImpl implements SomeService { @Override public void hello() { System.out.println("执行OneServiceImpl的hello()方法"); } } public class TwoServiceImpl implements SomeService { @Override public void hello() { System.out.println("执行TwoServiceImpl的hello()方法"); } } ``` 接下来 META-INF/services 文件夹下创建一个文件，名称为 SomeService 的全限定名`com.abc.jdkspi.SomeService`。 ![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/8448a69ca3a24e9c96d0519fdbf1c2e4~tplv-k3u1fbpfcp-watermark.image?) 文件内容为实现类的全限定的类名，如下： ```java com.abc.jdkspi.OneServiceImpl com.abc.jdkspi.TwoServiceImpl ``` 定义服务消费者类: ```java public class JdkSPITest { public static void main(String[] args) { // load()中放的是业务接口，其就相当于要加载的配置文件名 ServiceLoader loader = ServiceLoader.load(SomeService.class); Iterator it = loader.iterator(); while (it.hasNext()) { SomeService service = it.next(); service.hello(); } } } ``` 执行结果如下： ``` 执行OneServiceImpl的hello()方法执行TwoServiceImpl的hello()方法 ``` ### 1.1.2 总结 **调用过程**： - 应用程序调用ServiceLoader.load方法，创建一个新的ServiceLoader，并实例化该类中的成员变量应用程序通过迭代器接口获取对象实例，ServiceLoader先判断成员变量providers对象中(LinkedHashMap类型)是否有缓存实例对象，如果有缓存，直接返回. 如果没有缓存，执行类的装载。 **优点**： - 使用 Java SPI 机制的优势是实现解耦，使得接口的定义与具体业务实现分离，而不是耦合在一起。应用进程可以根据实际业务情况启用或替换具体组件。 **缺点**： - `不能按需加载`。虽然 ServiceLoader 做了延迟载入，但是基本只能通过遍历全部获取，也就是接口的实现类得全部载入并实例化一遍。如果你并不想用某些实现类，或者某些类实例化很耗时，它也被载入并实例化了，这就造成了浪费。 - `获取某个实现类的方式不够灵活`，只能通过 Iterator 形式获取，`不能根据某个参数来获取对应的实现类`。 - 多个并发多线程使用 ServiceLoader 类的实例是不安全的。 - 加载不到实现类时抛出并不是真正原因的异常，错误很难定位 ## 1.2 Dubbo的服务发现机制SPI ### 1.2.1 概述 Dubbo 并未使用 Java SPI，而是重新实现了一套`功能更强的 SPI 机制`。Dubbo SPI 的相关逻辑被封装在了 `ExtensionLoader` 类中，通过 ExtensionLoader，我们可以加载指定的实现类 ### 1.2.2 规范定义 - 接口名：可以随意定义，但接口必须被`@SPI 注解修饰` - 实现类名：在接口名前添加一个用于表示自身功能的“标识前辍”字符串 - 提供者配置文件路径：在依次查找的目录为 - META-INF/dubbo/internal - META-INF/dubbo - META-INF/services - 提供者配置文件名称：接口的全限定性类名，无需扩展名 - 提供者配置文件内容：文件的内容为 `key=value 形式`， value 为该接口的实现类的全限类性类名， key 可以随意，但一般为该实现类的“标识前辍”（首字母小写）。一个类名占一行。 - 提供者加载： ExtensionLoader 类相当于 JDK SPI 中的 ServiceLoader 类，用于加载提供者配置文件中所有的实现类，并创建相应的实例。 - 增加了对扩展点 IoC 和 AOP 的支持，一个扩展点可以直接使用 setter() 方法注入其他扩展点，也可以对扩展点使用 Wrapper 类进行功能增强。 ### 1.2.3 入门案例 SPI接口类： ```java @SPI("wechat") public interface Order { // 支付方式 String way(); } ``` 两个实现类： ```java public class AlipayOrder implements Order { @Override public String way() { System.out.println("--- 使用支付宝支付 ---"); return "支付宝支付"; } } public class WechatOrder implements Order { @Override public String way() { System.out.println("--- 使用微信支付 ---"); return "微信支付"; } } ``` 定义扩展类配置文件： ``` alipay=com.abc.spi.AlipayOrder wechat=com.abc.spi.WechatOrder ``` 测试类： ```java public class OrderTest { public static void main(String[] args) { // 获取到用于加载Order类型扩展类实例的extensionLoader实例 ExtensionLoader loader = ExtensionLoader.getExtensionLoader(Order.class); Order alipay = loader.getExtension("alipay"); System.out.println(alipay.way()); } } ``` # 2. 自适应机制 Adaptive Adaptive 机制，即`扩展类的自适应机制`。即其可以指定想要加载的扩展名，也可以不指定。若不指定，则直接加载默认的扩展类。即其会自动匹配，做到自适应。其是通过`@Adaptive`注解实现的。 ## 2.1 @Adaptive 注解 @Adaptive 注解可以修饰类与方法，其作用相差很大。 ```java @Documented @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE, ElementType.METHOD}) public @interface Adaptive { String[] value() default {}; } ``` ### 2.1.1 @Adaptive 修饰方法被@Adapative 修饰的 SPI 接口中的方法称为 Adaptive 方法。在 SPI 扩展类中若没有找到 Adaptive 类，但系统却发现了 Adapative 方法，就会`根据 Adaptive 方法自动为该 SPI 接口动态生成一个 Adaptive 扩展类，并自动将其编译`。例如 Protocol 接口中就包含两个 Adaptive 方法。 ### 2.1.2 @Adaptive 修饰类有些 SPI 接口中的方法不需要 URL 相关的参数，此时就可以直接让@Adaptivate 来修饰某个 SPI 接口的实现类，由该类实现对 SPI 扩展类的自适应。其是装饰者设计模式的应用。 ## 2.2 Adaptive 方法规范下面我们准备要定义 Adaptive 方法。那么 Adaptive 方法的定义有什么要求呢？我们通过查看动态生成的 Adaptive 类来总结 Adaptive 方法的要求。 ### 2.2.1 动态生成 Adaptive 类格式 ```java package ; public class SPI 接口名$Adpative implements SPI 接口 { public adaptiveMethod (arg0, arg1, ...) { // 注意，下面的判断仅对 URL 类型，或可以获取到 URL 类型值的参数进行判断 // 例如， dubbo 的 Invoker 类型中就包含有 URL 属性 if(arg1==null) throw new IllegalArgumentException(异常信息)； if(arg1.getUrl()==null) throw new IllegalArgumentException(异常信息)； URL url = arg1.getUrl(); // 其会根据@Adaptive 注解上声明的 Key 的顺序，从 URL 获取 Value， // 作为实际扩展类。若有默认扩展类，则获取默认扩展类名；否则获取 // 指定扩展名名。 String extName = url.get 接口名() == null?默认扩展前辍名:url.get 接口名(); if(extName==null) throw new IllegalStateException(异常信息); SPI 接口 extension = ExtensionLoader.getExtensionLoader(SPI 接口.class) .getExtension(extName); return extension. adaptiveMethod(arg0, arg1, ...); } public unAdaptiveMethod( arg0, arg1, ...) { throw new UnsupportedOperationException(异常信息); } } ``` ### 2.2.2 方法规范从前面的动态生成的 Adaptive 类中的 adaptiveMethod()方法体可知，其对于要加载的扩展名的指定方式是`通过 URL 类型的方法参数指定`的。所以对于 Adaptive 方法的定义规范仅一条：`其参数包含 URL 类型的参数，或参数可以获取到 URL 类型的值`。方法调用者是通过 URL 传递要加载的扩展名的。 ## 2.3 Adaptive方法案例接口类： ```java @SPI("wechat") public interface Order { String way(); @Adaptive String pay(URL url); } ``` 实现类： ```java public class AlipayOrder implements Order { @Override public String way() { System.out.println("--- 使用支付宝支付 ---"); return "支付宝支付"; } @Override public String pay(URL url) { System.out.println("--- pay 使用支付宝支付 ---"); return "pay 支付宝支付"; } } public class WechatOrder implements Order { @Override public String way() { System.out.println("--- 使用微信支付 ---"); return "微信支付"; } @Override public String pay(URL url) { System.out.println("--- pay 使用微信支付 ---"); return "pay 微信支付"; } } ``` 配置文件： ``` alipay=com.abc.adaptive.method.AlipayOrder wechat=com.abc.adaptive.method.WechatOrder ``` 测试类： ```java public class AdaptiveMethodTest { @Test public void test01() { ExtensionLoader loader = ExtensionLoader.getExtensionLoader(Order.class); // 获取Order的自适应类，不是任何一个Order的实现类 Order order = loader.getAdaptiveExtension(); URL url = URL.valueOf("xxx://localhost:8080/ooo/jjj"); System.out.println(order.pay(url)); // way()不是自适应方法，其调用会报错 // System.out.println(order.way()); } @Test public void test02() { ExtensionLoader loader = ExtensionLoader.getExtensionLoader(Order.class); // 获取Order的自适应类，不是任何一个Order的实现类 Order order = loader.getAdaptiveExtension(); URL url = URL.valueOf("xxx://localhost:8080/ooo/jjj?order=alipay"); System.out.println(order.pay(url)); // way()不是自适应方法，其调用会报错 // System.out.println(order.way()); } } ``` 在执行时，会生成`Order$Adaptive`类，如下： ```java public class Order$Adaptive implements com.abc.adaptive.method.Order { public java.lang.String pay(org.apache.dubbo.common.URL arg0) { if (arg0 == null) { throw new IllegalArgumentException("url == null"); } org.apache.dubbo.common.URL url = arg0; // order 参数是根据接口类名生成的，如GoodOrder 参数为good.order String extName = url.getParameter("order", "wechat"); if (extName == null) { throw new IllegalStateException( "Failed to get extension (com.abc.adaptive.method.Order) name from url (" + url.toString() + ") use keys([order])"); } com.abc.adaptive.method.Order extension = (com.abc.adaptive.method.Order) ExtensionLoader.getExtensionLoader(com.abc.adaptive.method.Order.class) .getExtension(extName); return extension.pay(arg0); } public java.lang.String way() { throw new UnsupportedOperationException( "The method public abstract java.lang.String com.abc.adaptive.method.Order.way() of interface com.abc.adaptive.method.Order is not adaptive method!"); } } ``` 执行结果： ``` --- pay 使用微信支付 --- pay 微信支付 --- pay 使用支付宝支付 --- pay 支付宝支付 ``` ## 2.4 Adaptive 类案例接口： ```java @SPI("wechat") public interface Order { String way(); } ``` 实现类： ```java public class AlipayOrder implements Order { @Override public String way() { System.out.println("--- 使用支付宝支付 ---"); return "支付宝支付"; } } public class WechatOrder implements Order { @Override public String way() { System.out.println("--- 使用微信支付 ---"); return "微信支付"; } } @Adaptive public class AdaptiveOrder implements Order { private String defaultName; // 指定要加载扩展类的名称 public void setDefaultName(String defaultName) { this.defaultName = defaultName; } @Override public String way() { ExtensionLoader loader = ExtensionLoader.getExtensionLoader(Order.class); Order order; if (StringUtils.isEmpty(defaultName)) { // 加载SPI默认名称的扩展类 order = loader.getDefaultExtension(); } else { // 加载指定名称的扩展类 order = loader.getExtension(defaultName); } return order.way(); } } ``` 配置： ``` alipay=com.abc.adaptive.aclass.AlipayOrder wechat=com.abc.adaptive.aclass.WechatOrder adaptive=com.abc.adaptive.aclass.AdaptiveOrder ``` 测试类: ```java public class AdaptiveClassTest { @Test public void test01() { ExtensionLoader loader = ExtensionLoader.getExtensionLoader(Order.class); Order order = loader.getAdaptiveExtension(); System.out.println(order.way()); } @Test public void test02() { ExtensionLoader loader = ExtensionLoader.getExtensionLoader(Order.class); Order order = loader.getAdaptiveExtension(); ((AdaptiveOrder) order).setDefaultName("alipay"); System.out.println(order.way()); } // adaptive类不是直接扩展类 @Test public void test04() { ExtensionLoader loader = ExtensionLoader.getExtensionLoader(Order.class); // 获取到该SPI接口的所有直接扩展类 Set supportedExtensions = loader.getSupportedExtensions(); System.out.println(supportedExtensions); } } ``` 执行结果： ``` --- 使用微信支付 --- 微信支付 --- 使用支付宝支付 --- 支付宝支付 [alipay, wechat] ``` # 3. 包装机制 Wrapper Wrapper 机制，即`扩展类的包装机制`。就是对扩展类中的 SPI 接口方法进行增强，进行包装，是 `AOP 思想的体现`，是 Wrapper 设计模式的应用。一个 SPI 可以包含多个 Wrapper。 ## 3.1 Wrapper 类规范 Wrapper 机制可以通过注解实现（dubbo3.0），也可以通过一套 Wrapper 规范实现的。Wrapper 类在定义时需要遵循如下规范： - 该类要实现 SPI 接口 - 该类中要有 SPI 接口的引用 - 该类中 SPI 接口实例是通过仅包含一个 SPI 接口参数的带参构造器传的 - 在接口实现方法中要调用 SPI 接口引用对象的相应方法 - 该类名称以 Wrapper 结尾 ## 3.2 案例接口： ```java @SPI("wechat") public interface Order { // 支持方式 String way(); @Adaptive String pay(URL url); } ``` 实现类: ```java public class AlipayOrder implements Order { @Override public String way() { System.out.println("--- 使用支付宝支付 ---"); return "支付宝支付"; } @Override public String pay(URL url) { System.out.println("--- pay 使用支付宝支付 ---"); return "pay 支付宝支付"; } } public class WechatOrder implements Order { @Override public String way() { System.out.println("--- 使用微信支付 ---"); return "微信支付"; } @Override public String pay(URL url) { System.out.println("--- pay 使用微信支付 ---"); return "pay 微信支付"; } } ``` wrapper包装类： ```java public class OrderWrapper implements Order { private Order order; public OrderWrapper(Order order) { this.order = order; } @Override public String way() { System.out.println("before-OrderWrapper对way()的增强"); String way = order.way(); System.out.println("after-OrderWrapper对way()的增强"); return way; } @Override public String pay(URL url) { System.out.println("before-OrderWrapper对pay()的增强"); String pay = order.pay(url); System.out.println("after-OrderWrapper对pay()的增强"); return pay; } } public class OrderWrapper2 implements Order { private Order order; public OrderWrapper2(Order order) { this.order = order; } @Override public String way() { System.out.println("before-OrderWrapper222对way()的增强"); String way = order.way(); System.out.println("after-OrderWrapper222对way()的增强"); return way; } @Override public String pay(URL url) { System.out.println("before-OrderWrapper222对pay()的增强"); String pay = order.pay(url); System.out.println("after-OrderWrapper222对pay()的增强"); return pay; } } ``` 配置文件： ``` alipay=com.abc.wrapper.AlipayOrder wechat=com.abc.wrapper.WechatOrder wrapper=com.abc.wrapper.OrderWrapper wrapper2=com.abc.wrapper.OrderWrapper2 ``` 测试类： ```java public class WrapperTest { @Test public void test01() { ExtensionLoader loader = ExtensionLoader.getExtensionLoader(Order.class); Order order = loader.getAdaptiveExtension(); URL url = URL.valueOf("xxx://localhost:8080/ooo/jjj"); System.out.println(order.pay(url)); } @Test public void test02() { ExtensionLoader loader = ExtensionLoader.getExtensionLoader(Order.class); Order order = loader.getAdaptiveExtension(); URL url = URL.valueOf("xxx://localhost:8080/ooo/jjj?order=alipay"); System.out.println(order.pay(url)); } // wrapper类不是直接扩展类 @Test public void test03() { ExtensionLoader loader = ExtensionLoader.getExtensionLoader(Order.class); // 获取到该SPI接口的所有直接扩展类 Set supportedExtensions = loader.getSupportedExtensions(); System.out.println(supportedExtensions); } } ``` 执行结果： ``` before-OrderWrapper对pay()的增强 before-OrderWrapper222对pay()的增强 --- pay 使用微信支付 --- after-OrderWrapper222对pay()的增强 after-OrderWrapper对pay()的增强 pay 微信支付 before-OrderWrapper对pay()的增强 before-OrderWrapper222对pay()的增强 --- pay 使用支付宝支付 --- after-OrderWrapper222对pay()的增强 after-OrderWrapper对pay()的增强 pay 支付宝支付 [alipay, wechat] ``` # 4. 激活机制 Activate 用于激活扩展类的。Activate 机制，即`扩展类的激活机制`。`通过指定的条件来激活当前的扩展类`。其是通过 `@Active` 注解实现的。 ## 4.1 @Activate 注解 ```java @Documented @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE, ElementType.METHOD}) public @interface Activate { String[] group() default {}; String[] value() default {}; String[] before() default {}; String[] after() default {}; int order() default 0; } ``` 在@Activate 注解中共有五个属性，其中 before、 after 两个属性已经过时，剩余有效属性还有三个。它们的意义为： - `group`：为扩展类指定所属的组别，是当前扩展类的一个标识。 `String[]`类型，表示一个扩展类可以属于多个组。 - `value`：为当前扩展类指定的 key，是当前扩展类的一个标识。 `String[]`类型，表示一个扩展类可以有多个指定的 key。 - `order`：指定筛选条件相同的扩展类的加载顺序。`序号越小，优先级越高`。默认值为 0。 ## 4.2 案例接口： ```java @SPI("wechat") public interface Order { String way(); } ``` 实现类： ```java // @Activate的order属性默认为0，order属性越小，其优先级越高 // @Activate的group属性与value属性均是用于给当前扩展类添加的标识 // group是一个“大范围标识”，value为一个“小范围标识”。 // 一个扩展类一旦指定了小范围标识value，那么这个大范围标识就不再起作用了 @Activate(group = "online", value = "alipay") public class AlipayOrder implements Order { @Override public String way() { System.out.println("--- 使用支付宝支付 ---"); return "支付宝支付"; } } @Activate(group = {"online", "offline"}, order = 3) public class CardOrder implements Order { @Override public String way() { System.out.println("--- 使用银联卡支付 ---"); return "银联卡支付"; } } @Activate(group = "offline", order = 4) public class CashOrder implements Order { @Override public String way() { System.out.println("--- 使用现金支付 ---"); return "现金支付"; } } @Activate(group = "offline", order = 5) public class CouponOrder implements Order { @Override public String way() { System.out.println("--- 使用购物券支付 ---"); return "购物券支付"; } } @Activate(group = "online") public class WechatOrder implements Order { @Override public String way() { System.out.println("--- 使用微信支付 ---"); return "微信支付"; } } ``` 配置文件： ``` alipay=com.abc.active.AlipayOrder wechat=com.abc.active.WechatOrder card=com.abc.active.CardOrder cash=com.abc.active.CashOrder coupon=com.abc.active.CouponOrder ``` 测试类： ```java public class ActiveTest { @Test public void test01() { ExtensionLoader loader = ExtensionLoader.getExtensionLoader(Order.class); URL url = URL.valueOf("xxx://localhost:8080/ooo/jjj"); // 一次性激活（加载）一批扩展类实例，这里指定的是激活所有group为“online"的扩展类 List online = loader.getActivateExtension(url, "", "online"); for (Order order : online) { System.out.println(order.way()); } } @Test public void test02() { ExtensionLoader loader = ExtensionLoader.getExtensionLoader(Order.class); URL url = URL.valueOf("xxx://localhost:8080/ooo/jjj"); // 一次性激活（加载）一批扩展类实例，这里指定的是激活所有group为“offline"的扩展类 List online = loader.getActivateExtension(url, "", "offline"); for (Order order : online) { System.out.println(order.way()); } } @Test public void test03() { ExtensionLoader loader = ExtensionLoader.getExtensionLoader(Order.class); URL url = URL.valueOf("xxx://localhost:8080/ooo/jjj?ooo=alipay"); // getActivateExtension()的参数二与三的关系是“或” // 参数二指定的是要激活的value // 参数三指定的是要激活的group List online = loader.getActivateExtension(url, "ooo", "online"); for (Order order : online) { System.out.println(order.way()); } } @Test public void test04() { ExtensionLoader loader = ExtensionLoader.getExtensionLoader(Order.class); URL url = URL.valueOf("xxx://localhost:8080/ooo/jjj?ooo=alipay"); List online = loader.getActivateExtension(url, "ooo", "offline"); for (Order order : online) { System.out.println(order.way()); } } // activate类是直接扩展类 @Test public void test05() { ExtensionLoader loader = ExtensionLoader.getExtensionLoader(Order.class); // 获取到该SPI接口的所有直接扩展类 Set supportedExtensions = loader.getSupportedExtensions(); System.out.println(supportedExtensions); } } ``` 执行结果： ``` --- 使用微信支付 --- 微信支付 --- 使用银联卡支付 --- 银联卡支付 --- 使用银联卡支付 --- 银联卡支付 --- 使用现金支付 --- 现金支付 --- 使用购物券支付 --- 购物券支付 --- 使用支付宝支付 --- 支付宝支付 --- 使用微信支付 --- 微信支付 --- 使用银联卡支付 --- 银联卡支付 --- 使用支付宝支付 --- 支付宝支付 --- 使用银联卡支付 --- 银联卡支付 --- 使用现金支付 --- 现金支付 --- 使用购物券支付 --- 购物券支付 [alipay, card, cash, coupon, wechat] ``` # 5. 总结在配置文件中可能会存在四种类：`普通扩展类、 Adaptive 类、 Wrapper 类，及 Activate 类`。它们的共同点是：都实现了 SPI 接口。不同点是： - `定义方式`： Adaptive 类与 Activate 类都是通过注解定义的。 - `数量`：一个 SPI 接口的 `Adaptive 类（无论是否是自动生成的）只会有一个`； Wrapper 类与 Activate 类是可以有多个的。 - `直接扩展类`：只有普通扩展类与 Activate 类是直接扩展类， Adaptive 类与 Wrapper 类不是直接扩展类。以上代码均在：[Dubbo3.0源码注释githud地址](https://github.com/hsfxuebao/dubbo-3.0) 中dubbo-demo-xml-provider项目中。 # 6. 创建ExtensionLoader对象 ExtensionLoader类中的属性定义： ```java public class ExtensionLoader { private static final Logger logger = LoggerFactory.getLogger(ExtensionLoader.class); // ,分隔 private static final Pattern NAME_SEPARATOR = Pattern.compile("\s*[,]+\s*"); // 接下来是两个重要的静态变量，所有ExtensionLoader实例都共享这两个变量的值 // 静态变量存储的是SPI接口类和ExtensionLoader对象的映射关系.Dubble会为每一个SPI接口都会创建一个ExtensionLoader对象，并保存到EXTENSION_LOADERS变量中。 private static final ConcurrentMap, ExtensionLoader> EXTENSION_LOADERS = new ConcurrentHashMap<>(64); // 静态变量存储的是每个SPI接口的多个实现类和对应实例之间的关系。因此java进程中通常对应接口实现类对象是单例的。 private static final ConcurrentMap, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<>(64); // 当前SPI接口类 private final Class type; // 扩展类工厂 private final ExtensionFactory objectFactory; // 扩展类和扩展名称映射关系 private final ConcurrentMap, String> cachedNames = new ConcurrentHashMap<>(); // 扩展名称和扩展类类型映射关系 private final Holder>> cachedClasses = new Holder<>(); // 扩展名称和自动激活扩展类映射关系 private final Map cachedActivates = Collections.synchronizedMap(new LinkedHashMap<>()); // 扩展名称和自动激活扩展类的group属性集合 private final Map> cachedActivateGroups = Collections.synchronizedMap(new LinkedHashMap<>()); // 扩展名称和自动激活扩展类的value属性集合 private final Map cachedActivateValues = Collections.synchronizedMap(new LinkedHashMap<>()); // 扩展名称和扩展类实例映射关系，SPI类对应的实例，懒加载 private final ConcurrentMap> cachedInstances = new ConcurrentHashMap<>(); // 自适应扩展类实例缓存,只能有一个 private final Holder