共计 3073 个字符，预计需要花费 8 分钟才能阅读完成。
框架设计的有弹性扩展性好会给使用者带来很大的不便，如果业务有新的变动只有应用新的实现去替换之前的实现，且框架如何去加载实现咱们也不必太关注，显然这对咱们开发者来说是十分敌对的。java 里的 SPI 是这个思维，dubbo 里的 SPI 同样是这个思维，对于 java 里的 spi 因为会一次性将扩大点逻辑都执行而显得不够灵便，所以这里不再开展(能够参考 java spi)，这里重点说下 dubbo 里的 SPI.
应用形式
1，在 META-INF/services 目录下依据接口的全路径名创立一个文件，文件内容为 key=value 的模式
2，ExtensionLoader.getExtensionLoader(xxx.class).getExtension(“key”) 这样就能够获取到咱们自定义的实现了。
实现剖析
上面咱们对 ExtensionLoader.getExtensionLoader(xxx.class).getExtension(name)这行代码开展下。
public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {if (type == null)
throw new IllegalArgumentException("Extension type == null");
// 判断给定 type 是否为接口
if (!type.isInterface()) {throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
}
// 判断给定接口上是否有 SPI 注解
if (!withExtensionAnnotation(type)) {
throw new IllegalArgumentException("Extension type(" + type +
") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + "Annotation!");
}
// 先从 map 里获取 ExtensionLoader，如果没有进行创立
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;
}这全办法次要是获取 ExtensionLoader：
1，对给定的 type 进行判断，一是判断是否是接口类型；二是判断接口上是否有 SPI 注解
2，依据给定的 type 先从 Map 获取对应的 ExtensionLoader，要是没有进行创立。
接下来咱们再看看 getExtension(name)办法：
public T getExtension(String name) {if (name == null || name.length() == 0)
throw new IllegalArgumentException("Extension name == null");
if ("true".equals(name)) {return getDefaultExtension();
}
// 先获取包装类 Holder
Holder<Object> holder = cachedInstances.get(name);
if (holder == null) {cachedInstances.putIfAbsent(name, new Holder<Object>());
holder = cachedInstances.get(name);
}
// 再从包装类里获取实现类的实例，须要重点看下 createExtension
Object instance = holder.get();
if (instance == null) {synchronized (holder) {instance = holder.get();
if (instance == null) {instance = createExtension(name);
holder.set(instance);
}
}
}
return (T) instance;
}getExtension(name)办法逻辑清晰明了：
1，先获取包装类 Holder
2，从包装类 Holder 里获取具体实现类的实例。
实现类的实例是如何创立的呢？再看下 createExtension(name)
private T createExtension(String name) {
/**
* getExtensionClasses 会加载 META-INF/services/，META-INF/dubbo/,META-INF/dubbo/internal/ 这三
* 个目录下的所有类
*/
Class<?> clazz = getExtensionClasses().get(name);
if (clazz == null) {throw findException(name);
}
try {
// 通过反射的形式创立 name 对应的实例，并放到 map 里，下次能够间接从 map 里取
T instance = (T) EXTENSION_INSTANCES.get(clazz);
if (instance == null) {EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
instance = (T) EXTENSION_INSTANCES.get(clazz);
}
/**
* 如果实现类对象里有 set 办法，则框架还会依据依赖对象的理论状况进行主动注入的工作
* 阐明，只有满足上面两个条件才会进行注入：* 1，被依赖的对象也是在 services,dubbo,internal 这三个目录下
* 2，set 办法上没有应用了 DisableInject 注解
*/
injectExtension(instance);
Set<Class<?>> wrapperClasses = cachedWrapperClasses;
if (wrapperClasses != null && !wrapperClasses.isEmpty()) {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);
}
}这办法的次要逻辑：
1，通过 Class.forName 加载 META-INF/services/，META-INF/dubbo/,META-INF/dubbo/internal/ 这三个目录下的所有类
2，通过反射创立 type 对应的实例
3，如果合乎注入条件，框架还会进行主动注入。
最初用一张图总结下整个过程：
创立完对象后都会将对象放入缓存不便下次间接获取。