【dubbo为什么不采用JDK自带的SPI】
1.JDK自带的SPI（ServiceLoader）会一次性实例化扩展点所有实现，基本只能通过遍历全部获取，也就是接口的实现类全部加载并实例化一遍，如果我们不想使用某些类，它也会被加载并且实例化，这就导致了浪费。
2.增加了对扩展点IOC和AOP的支持，一个扩展点可以直接setter注入其他扩展点。
【dubbo的SPI新增的功能】
1.dubbo的SPI可以方便地获取某一个想要的扩展实现，Java自带的SPI机制没有实现这样的功能。
2.对于扩展实现IOC依赖注入功能：
举例来说：接口A，实现类为A1，A2。接口B，实现类为B1，B2。
现在A1含有setB(B b)方法，会自动注入一个接口B的实现类，此时注入B1还是B2呢？都不是，而是注入一个动态生成的接口B的实现者B$Adpative，该实现者B$Adaptive能够根据参数的不同，自动引用B1或者B2来完成相应的功能。
3.对扩展采用装饰器模式进行功能增强，类似AOP实现的功能。
还是上面的例子，接口A的另一个实现者AWrapper1，大体内容如下：
class AWrapper1 implements A{ private A a; AWrapper1（A a）{ this.a=a; } }
因此，我们在采用某一个接口A的实现者A1的时候，其实已经自动被AWrapper1包装起来了。
【dubbo的SPI的约定】
1.SPI文件存储路径在“META-INF/dubbo/internal” 目录下，并且文件名为接口的全路径名，即为“接口的包名+接口名”
2.每个SPI文件里面的格式定义为：“扩展名=具体的类名”
例如：
dubbo=com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol
【dubbo SPI 分析】
[ 目的 ]：获取一个接口的实现类的对象。
[ 途径 ]：
/*ExtensionLoader类*/ ExtensionLoader.getExtension(String name)
[ 3种实现路径 ]
/** * ExtensionLoader类下的方法得到一个ExtensionLoader实例 * 有三种实现路径 **/ //实现路径1：为改接口new一个ExtensionLoader，然后缓存起来 getExtensionLoader(Class<T> type) //实现路径2:获取一个扩展装饰类，如果@Adaptive注解在类上，就是一个装饰类；如果注解在方法上就是一个动态代理类，例如Protocol$Adaptive getAdaptiveExtension() //实现路径3：获取一个对象 getExtension(String name)
【dubbo SPI 源码分析】
[这三行SPI代码]
package com.dubbo.spi; import com.alibaba.dubbo.common.extension.ExtensionLoader; import com.alibaba.dubbo.rpc.Protocol; /** * Created by HigginCui on 2018/9/5. */ public class ExtensionTest { public static void main(String[] args) { ExtensionLoader<Protocol> loader = ExtensionLoader.getExtensionLoader(Protocol.class); final Protocol dubboProtocol = loader.getExtension("dubbo"); final Protocol adaptiveExtension = loader.getAdaptiveExtension(); } }
【 1.Protocol接口的定义 】
package com.alibaba.dubbo.rpc; import com.alibaba.dubbo.common.URL; import com.alibaba.dubbo.common.extension.Adaptive; import com.alibaba.dubbo.common.extension.SPI; /** * Protocol. (API/SPI, Singleton, ThreadSafe) * * @author william.liangf */ @SPI("dubbo") public interface Protocol { /** * 获取缺省端口，当用户没有配置端口时使用。 * * @return 缺省端口 */ int getDefaultPort(); /** * 暴露远程服务：<br> * 1. 协议在接收请求时，应记录请求来源方地址信息：RpcContext.getContext().setRemoteAddress();<br> * 2. export()必须是幂等的，也就是暴露同一个URL的Invoker两次，和暴露一次没有区别。<br> * 3. export()传入的Invoker由框架实现并传入，协议不需要关心。<br> * * @param <T> 服务的类型 * @param invoker 服务的执行体 * @return exporter 暴露服务的引用，用于取消暴露 * @throws RpcException 当暴露服务出错时抛出，比如端口已占用 */ @Adaptive <T> Exporter<T> export(Invoker<T> invoker) throws RpcException; /** * 引用远程服务：<br> * 1. 当用户调用refer()所返回的Invoker对象的invoke()方法时，协议需相应执行同URL远端export()传入的Invoker对象的invoke()方法。<br> * 2. refer()返回的Invoker由协议实现，协议通常需要在此Invoker中发送远程请求。<br> * 3. 当url中有设置check=false时，连接失败不能抛出异常，并内部自动恢复。<br> * * @param <T> 服务的类型 * @param type 服务的类型 * @param url 远程服务的URL地址 * @return invoker 服务的本地代理 * @throws RpcException 当连接服务提供方失败时抛出 */ @Adaptive <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException; /** * 释放协议：<br> * 1. 取消该协议所有已经暴露和引用的服务。<br> * 2. 释放协议所占用的所有资源，比如连接和端口。<br> * 3. 协议在释放后，依然能暴露和引用新的服务。<br> */ void destroy(); }
[ 两个核心注解 ]
@SPI：指定一个接口为SPI接口（可扩展接口）
package com.alibaba.dubbo.common.extension; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * 扩展点接口的标识。 * 扩展点声明配置文件，格式修改。 * 以Protocol示例，配置文件META-INF/dubbo/com.xxx.Protocol内容： * 由 com.foo.XxxProtocol * com.foo.YyyProtocol * 改成使用KV格式 * xxx=com.foo.XxxProtocol * yyy=com.foo.YyyProtocol * 原因： * 当扩展点的static字段或方法签名上引用了三方库， * 如果三方库不存在，会导致类初始化失败， * Extension标识Dubbo就拿不到了，异常信息就和配置对应不起来。 * * 比如: * Extension("mina")加载失败， * 当用户配置使用mina时，就会报找不到扩展点， * 而不是报加载扩展点失败，以及失败原因。 * */ @Documented @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE}) public @interface SPI { /** * 缺省扩展点名。 */ String value() default ""; }
@Adaptive：该注解可以注解在两个地方
1.接口上：例如AdaptiveExtensionFactory（该类不是工厂类，有特殊逻辑）
AdaptiveCompiler（实际上是工厂类，但是不能动态生成，否则会形成死循环）
2.接口的方法上：会动态生成相应的动态类，（实际上是一个工厂，工厂设计模式），例如Protocol$Adapter，这个接口极其重要，后续的整个服务暴露和服务调用都会调用到该接口的两个方法。
package com.alibaba.dubbo.common.extension; import com.alibaba.dubbo.common.URL; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * 在{@link ExtensionLoader}生成Extension的Adaptive Instance时，为{@link ExtensionLoader}提供信息。 */ @Documented @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE, ElementType.METHOD}) public @interface Adaptive { /** * 从{@link URL}的Key名，对应的Value作为要Adapt成的Extension名。 * 如果{@link URL}这些Key都没有Value，使用 用 缺省的扩展（在接口的{@link SPI}中设定的值）。 * 比如，String[] {"key1", "key2"}，表示 * 先在URL上找key1的Value作为要Adapt成的Extension名； * key1没有Value，则使用key2的Value作为要Adapt成的Extension名。 * key2没有Value，使用缺省的扩展。 * 如果没有设定缺省扩展，则方法调用会抛出{@link IllegalStateException}。 * 如果不设置则缺省使用Extension接口类名的点分隔小写字串。 * 即对于Extension接口{@code com.alibaba.dubbo.xxx.YyyInvokerWrapper}的缺省值为String[] {"yyy.invoker.wrapper"} */ String[] value() default {}; }
【2.获取ExtensionLoader】
ExtensionLoader可以类比JDK-SPI中的ServiceLoader。
[ ExtensionLoader中的类属性 ]
public class ExtensionLoader<T> { /** 存放SPI文件的三个目录,其中META-INF/services/也是jdk的SPI文件的存放目录 */ private static final String SERVICES_DIRECTORY = "META-INF/services/"; private static final String DUBBO_DIRECTORY = "META-INF/dubbo/"; /**这个是最终jar包中存放spi文件的位置**/ private static final String DUBBO_INTERNAL_DIRECTORY = DUBBO_DIRECTORY + "internal/"; private static final Pattern NAME_SEPARATOR = Pattern.compile("\s*[,]+\s*"); /** key: SPI接口Class value: 该接口的ExtensionLoader */ private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>(); /** key: SPI接口Class value: SPI实现类的对象实例 */ private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>(); }
[ ExtensionLoader中的实例属性（上述的是类属性(static)，即所有该类的实例都共享。实例属性是每一个类的实例私有） ]
public class ExtensionLoader<T> { private final Class<?> type; //SPI接口Class private final ExtensionFactory objectFactory; //SPI实现类的对象实例的创建工程 /** key: ExtensionClass的Class value: SPI的实现类的key **/ private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<Class<?>, String>(); /** 存放所有的ExtensionClass **/ private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>(); private final Map<String, Activate> cachedActivates = new ConcurrentHashMap<String, Activate>(); /**缓存创建好的ExtensionClass实例**/ private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<String, Holder<Object>>(); /** 缓存创建好的适配器实例 **/ private final Holder<Object> cachedAdaptiveInstance = new Holder<Object>(); /**存储类上带有@Adaptive注解的Class**/ private volatile Class<?> cachedAdaptiveClass = null; /** 默认SPI文件中的key **/ private String cachedDefaultName; /** 存储在创建适配器实例这个过程中发生的错误 **/ private volatile Throwable createAdaptiveInstanceError; /**存放具有一个type入参构造器的实现类 Class对象**/ private Set<Class<?>> cachedWrapperClasses; /**key:实现列的全类名 value:exception,防止真正的异常被吞掉 **/ private Map<String, IllegalStateException> exceptions = new ConcurrentHashMap<String, IllegalStateException>(); }
[ 注意 ]
com.alibaba.dubbo.rpc.Protocol 文件中整体路径和文件的内容如下
registry=com.alibaba.dubbo.registry.integration.RegistryProtocol dubbo=com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol filter=com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper listener=com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper mock=com.alibaba.dubbo.rpc.support.MockProtocol injvm=com.alibaba.dubbo.rpc.protocol.injvm.InjvmProtocol rmi=com.alibaba.dubbo.rpc.protocol.rmi.RmiProtocol hessian=com.alibaba.dubbo.rpc.protocol.hessian.HessianProtocol com.alibaba.dubbo.rpc.protocol.http.HttpProtocol com.alibaba.dubbo.rpc.protocol.webservice.WebServiceProtocol thrift=com.alibaba.dubbo.rpc.protocol.thrift.ThriftProtocol memcached=com.alibaba.dubbo.rpc.protocol.memcached.MemcachedProtocol redis=com.alibaba.dubbo.rpc.protocol.redis.RedisProtocol
对于上述Protocol接口的实现类，ExtensionLoader分三种情况来分别存储对应的实现者，分别是下面三个实例属性：
private volatile Class<?> cachedAdaptiveClass = null; private Set<Class<?>> cachedWrapperClasses; private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();
情况1：如果这个class含有Adaptive注解，则将这个class设置为Class<?> cacheAdaptiveClass；
情况2：尝试获取带对应接口参数的构造器，如果能够获取到，则说明这个class是一个装饰器类，存放到Set<Class<?>> cachedWraperClasses；
情况3：如果没有上述构造器，则获取class上的SPI注解，根据该注解的定义的name作为key，存放至 Holder<Map<String,Class<?>>> cachedClasses中
[ ExtensionLoader.getExtensionLoader(Protocol.class)方法 ]
/** * 1.校验参数type：非空+是接口+含有@SPI注解 * 2.根据type接口，从全局缓存EXTENSIONS_LOADERS中获取ExtensionLoader，若有直接返回；如果没有则先创建，放入缓存，再返回 */ public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) { if (type == null) throw new IllegalArgumentException("Extension type == null"); if (!type.isInterface()) { throw new IllegalArgumentException("Extension type(" + type + ") is not interface!"); } if (!withExtensionAnnotation(type)) { throw new IllegalArgumentException("Extension type(" + type + ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!"); } ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type); if (loader == null) { EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type)); loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type); } return loader; }
[ new ExtensionLoader<T>(type)构造方法 ]
private ExtensionLoader(Class<?> type) { this.type = type; objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension()); }
分析：
当前目标创建的ExtensionLoader对象(自行命名为ExtensionLoader对象1)的type为com.alibaba.dubbo.rpc.Protocol，所以会执行
ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
那需要首先创建ExtensionFactory，可以看出对应的ExtensionFactory同样也是一个SPI接口，且没有指定默认的实现类。
@SPI public interface ExtensionFactory { /** * Get extension.*/ <T> T getExtension(Class<T> type, String name); }
ExtensionLoader.getExtensionLoader(ExtensionFactory.class)过程与上面类似，只是我们需要创建另外一个ExtensionLoader对象（我们取名为ExtensionLoader对象2），type为com.alibaba.dubbo.common.extension.ExtensionFactory，而objectFactory是null，之后这个ExtensionLoader对象2会被放入EXTENSION_LOADERS缓存中。
之后执行ExtensionLoader对象2的getAdaptiveExtension()方法：
/** * 首先从cahcedAdaptiveInstance缓存中取得AdaptiveExtension实例 * 如果不为null，直接返回 * 如果为null，先createAdaptiveExtension()创建AdaptiveExtension实例，之后放入cachedAdaptiveInstance缓存中，最后返回 */ public T getAdaptiveExtension() { Object instance = cachedAdaptiveInstance.get(); if (instance == null) { if (createAdaptiveInstanceError == null) { synchronized (cachedAdaptiveInstance) { instance = cachedAdaptiveInstance.get(); if (instance == null) { try { instance = createAdaptiveExtension(); //创建AdaptiveExtension实例 cachedAdaptiveInstance.set(instance); //之后放入cachedAdaptiveInstance缓存中 } catch (Throwable t) { createAdaptiveInstanceError = t; throw new IllegalStateException("fail to create adaptive instance: " + t.toString(), t); } } } } else { throw new IllegalStateException("fail to create adaptive instance: " + createAdaptiveInstanceError.toString(), createAdaptiveInstanceError); } } return (T) instance; }
再看createAdaptiveExtension()创建AdaptiveExtension源码
/** * createAdaptiveExtension() * -- getAdaptiveExtensionClass() //从dubbo-spi配置文件中获取AdaptiveExtensionClass * --getExtensionClasses() * --loadExtensionClasses() * --loadFile(Map<String,Class<?>> extensionClasses, String dir) * -- getAdaptiveExtensionClass() //创建动态代理类 * --injectExtension(T instance) //dubbo的ioc */ private T createAdaptiveExtension() { try { return injectExtension((T) getAdaptiveExtensionClass().newInstance()); } catch (Exception e) { throw new IllegalStateException("Can not create adaptive extenstion " + type + ", cause: " + e.getMessage(), e); } }
再看getAdaptiveExtensionClass()方法
/** * 获取ExtensionClasses和适配类 * 如果实现类上有带有@Adaptive注解，直接创建修饰类 * 如果方法上带有@Adaptive注解，动态生成代理类 **/ private Class<?> getAdaptiveExtensionClass() { getExtensionClasses(); if (cachedAdaptiveClass != null) { return cachedAdaptiveClass; } return cachedAdaptiveClass = createAdaptiveExtensionClass(); }
再看getExtensionClasses()方法
/** * 先从Holder<Map<String, Class<?>>> cachedClasses缓存中获取所有的ExtensionClass，如果有，直接返回； * 如果没有，通过loadExtensionClasses()从SPI文件中取读取，之后写入缓存 **/ private Map<String, Class<?>> getExtensionClasses() { Map<String, Class<?>> classes = cachedClasses.get(); if (classes == null) { synchronized (cachedClasses) { classes = cachedClasses.get(); if (classes == null) { classes = loadExtensionClasses(); cachedClasses.set(classes); } } } return classes; }
再看loadExtensionClasses()方法
/** * 1.从@SPI注解中将默认值解析出来，并缓存到String cachedDefaultName 中 * 2.从SPI文件中获取对应的value（SPI文件中是key-value格式）并存储到Map<String, Class<?>> extensionClasses局部变量上 * 注意：loadExtensionClasses方法已经同步过 **/ private Map<String, Class<?>> loadExtensionClasses() { final SPI defaultAnnotation = type.getAnnotation(SPI.class); if (defaultAnnotation != null) { String value = defaultAnnotation.value(); if (value != null && (value = value.trim()).length() > 0) { String[] names = NAME_SEPARATOR.split(value); if (names.length > 1) { throw new IllegalStateException("more than 1 default extension name on extension " + type.getName() + ": " + Arrays.toString(names)); } if (names.length == 1) cachedDefaultName = names[0]; } } Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>(); loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY); loadFile(extensionClasses, DUBBO_DIRECTORY); loadFile(extensionClasses, SERVICES_DIRECTORY); return extensionClasses; }
再看非常重要的方法：loadFile(Map<String,Class<?>> extensionClasses, String dir)方法：
/** * 1.加载dir目录下的指定type的文件（如：/META-INF/dubbo/internal/com.alibaba.dubbo.common.extension.ExtensionFactory） * 2.遍历文件中的每一行 * 2.1 获取实现类key和value，例如 name=spi，line=com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory * 2.2 根据line创建Class对象 * 2.3 将具有@Adaptive注解的实现类的Class对象放在 volatile Class<?> cachedAdaptiveClass缓存中，注意该缓存只能存放一个具有@Adaptive注解的实现类的Class对象，如果有两个同时满足，则抛异常 * 2.4~2.6都是针对不含@Adaptive注解的实现类的Class对象 * 2.4 查看类是否含有一个type入参的构造方法，如果有（就是wrapper类），将当前的Class对象存放至Set<Class<?>> cachedWrapperClasses缓存中 * 2.5 如果类不含有一个type入参的构造方法，获取无参构造方法，如果Class对象具有@Active注解，将改对象以<实现类的key, active>格式存储起来，即Map<String, Activate> cachedActivates * 2.6 最后，将<Class对象， 实现类的key>存入ConcurrentMap<Class<?>, String> cachedNames进行缓存，并将这些Class存入loadFile(Map<String, Class<?>> extensionClasses, String dir)的入参extensionClasses中 * **/ private void loadFile(Map<String, Class<?>> extensionClasses, String dir) { ...... }
上述的方法，分别从三个目录里查找SPI文件并进行加载，在这里只有META-INF/dubbo/internal/com.alibaba.dubbo.common.extension.ExtensionFactory中有值，内容如下：
其中，AdaptiveExtensionFactory在类上有@Adaptive注解。
执行过后，
cachedAdaptiveClass=class com.alibaba.dubbo.common.extension.factory.AdaptiveExtensionFactory
extendionClasses = [{"spring","class com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory"}, {"spi", "class com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory"}]，后续这个集合会存储在cachedClasses缓存中。
上面一直在讲getAdaptiveExtensionClass().newInstance()这句代码中的getAdaptiveExtensionClass()方法，
该方法返回一个com.alibaba.dubbo.common.extension.factory.AdaptiveExtensionFactory类，在看下其newInstance()代码，之后再来看下其newInstance()代码，调用这个方法，默认会执行AdaptiveExtensionFactory的无参构造方法，这里给出AdaptiveExtensionFactory的完整代码。
package com.alibaba.dubbo.common.extension.factory; import com.alibaba.dubbo.common.extension.Adaptive; import com.alibaba.dubbo.common.extension.ExtensionFactory; import com.alibaba.dubbo.common.extension.ExtensionLoader; import java.util.ArrayList; import java.util.Collections; import java.util.List; /** * AdaptiveExtensionFactory * * @author william.liangf */ @Adaptive public class AdaptiveExtensionFactory implements ExtensionFactory { private final List<ExtensionFactory> factories; /** * 遍历cachedClasses中缓存的extensionClasses的key，之后根据key来实例化对应的实现类，最后放置到EXTENSION_INSTANCES缓存中 **/ public AdaptiveExtensionFactory() { ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class); List<ExtensionFactory> list = new ArrayList<ExtensionFactory>(); for (String name : loader.getSupportedExtensions()) { list.add(loader.getExtension(name)); } factories = Collections.unmodifiableList(list); } public <T> T getExtension(Class<T> type, String name) { for (ExtensionFactory factory : factories) { T extension = factory.getExtension(type, name); if (extension != null) { return extension; } } return null; } }
从上可以看出，这个装饰器类只是实例化好了各个ExtensionFactory（这里是指SpiExtensionFactory和SpringExtensionFactory），后续通过工厂获取实现类实例都是由具体的工厂来完成。
来看一下实例化代码的地方，即 loader.getExtension(name)方法：
/** * 返回指定名字的扩展。如果指定名字的扩展不存在，则抛异常 * 从cachedInstances缓存中获取name对应的实例，如果没有，通过createExtension(name)创建，之后放入缓存。 * getExtension(String name) * --createExtension(String name) * ----injectExtension( T instance ) * */ @SuppressWarnings("unchecked") public T getExtension(String name) { if (name == null || name.length() == 0) throw new IllegalArgumentException("Extension name == null"); if ("true".equals(name)) { return getDefaultExtension(); } Holder<Object> holder = cachedInstances.get(name); if (holder == null) { cachedInstances.putIfAbsent(name, new Holder<Object>()); holder = cachedInstances.get(name); } Object instance = holder.get(); if (instance == null) { synchronized (holder) { instance = holder.get(); if (instance == null) { instance = createExtension(name); holder.set(instance); } } } return (T) instance; }
在看一下createExtension(String name)方法
private T createExtension(String name) { /**从cachedClasses缓存中获取所有的实现类map，之后通过name获取到对应的实现类的Class对象**/ Class<?> clazz = getExtensionClasses().get(name); if (clazz == null) { throw findException(name); } try { /**从EXTENSION_INSTANCES缓存中获取对应的实现类的Class对象，如果没有，直接创建，之后放入缓存**/ T instance = (T) EXTENSION_INSTANCES.get(clazz); if (instance == null) { EXTENSION_INSTANCES.putIfAbsent(clazz, (T) clazz.newInstance()); instance = (T) EXTENSION_INSTANCES.get(clazz); } injectExtension(instance); Set<Class<?>> wrapperClasses = cachedWrapperClasses; if (wrapperClasses != null && wrapperClasses.size() > 0) { for (Class<?> wrapperClass : wrapperClasses) { instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance)); } } return instance; } catch (Throwable t) { throw new IllegalStateException("Extension instance(name: " + name + ", class: " + type + ") could not be instantiated: " + t.getMessage(), t); } }
这里，就体现了了dubbo-SPI比JDK-SPI的好处：dubbo-SPI不需要遍历所有的实现类来获取想要的内容，可以直接通过name来获取。
看下
ExtensionLoader<Protocol> loader = ExtensionLoader.getExtensionLoader(Protocol.class);
的执行结果：
在执行完
final Protocol dubboProtocol = loader.getExtension("dubbo");
结果（两张图）
【参考文档】
https://www.cnblogs.com/java-zhao/p/7617285.html