一篇文章彻底弄懂dubbo的SPI机制的原理
在dubbo中几乎所有的功能组件都是基于SPI来实现的，dubbo良好的扩展性也与SPI加载机制密不可分，所以要想更进一步理解使用dubbo或者阅读dubbo的源码，SPI是一定要懂的。本文主要通过源码分析的方式来理解dubbo SPI的实现原理。
1.ExtensionLoader
ExtensionLoader是整个dubbo SPI最主要的类，在这个类中实现了SPI配置的加载,扩展类缓存，自适应对象生成，DI等核心逻辑。首先我们看ExtensionLoader是怎么创建的。
通过ExtensionLoader的静态方法getExtensionLoader我们可以获取一个ExtensionLoader。逻辑很简单，先从缓存里面取，如果缓存中没有，那么new一个ExtensionLoader放进去，每一个type对应一个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 an interface!");
}
if (!withExtensionAnnotation(type)) {
throw new IllegalArgumentException("Extension type (" + type +
") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
}
//首先从缓存中获取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;
}接下来我们通过getExtension()，getAdaptiveExtension()，getActivateExtensions()三个方法为入口对ExtensionLoader的核心代码进行分析。
1.getExtension()
getExtension()方法的作用是通过名字获取具体的实现类的实例。它会调用另外一个重载的方法，我们重点看重载方法。
public T getExtension(String name) {
T extension = getExtension(name, true);
if (extension == null) {
throw new IllegalArgumentException("Not find extension: " + name);
}
return extension;
}流程图
如果name是字符串true，那么会调用getDefaultExtension()方法获取默认的扩展点实例。否则会先从缓存holder中获取对应名称的扩展点实例，获取不到的话调用createExtension()方法创建扩展点实例并且放入到holder对象中缓存起来。这里我们重点对getDefaultExtension()，createExtension()两个方法进行分析。
public T getExtension(String name, boolean wrap) {
if (StringUtils.isEmpty(name)) {
throw new IllegalArgumentException("Extension name == null");
}
//如果传的是true字符串 调用getDefaultExtension()获取默认的扩展点实例
if ("true".equals(name)) {
return getDefaultExtension();
}
//获取对应的holder对象 holder是用来缓存实例的
final Holder<Object> holder = getOrCreateHolder(name);
//如果holder缓存中的实例是null 那么就双重检查锁 调用createExtension创建对应的扩展点实例 然后放到holder对象中缓存起来
Object instance = holder.get();
if (instance == null) {
synchronized (holder) {
instance = holder.get();
if (instance == null) {
instance = createExtension(name, wrap);
holder.set(instance);
}
}
}
return (T) instance;
}getDefaultExtension()
首先调用getExtensionClasses()方法，这个方法非常重要，要重点进行分析，它的作用是用来读取SPI配置并且初始化SPI一些默认值的，其中就包括cachedDefaultName的初始化，cachedDefaultName用来缓存默认的扩展点的name。然后调用通过cachedDefaultName再次调用getExtension()方法获取扩展点实例。
public T getDefaultExtension() {
//这个方法是用来读取spi配置并且初始化默认值的，其中就包括了cachedDefaultName，
//所以初始化之后通过cachedDefaultName调用getExtension获取默认的扩展点实例
getExtensionClasses();
//如果默认的name是空的或者还是true字符串 那么返回null 否则根据默认的name去获取扩展点实例
if (StringUtils.isBlank(cachedDefaultName) || "true".equals(cachedDefaultName)) {
return null;
}
return getExtension(cachedDefaultName);
}getExtensionClasses()
这个方法是重点，用来加载SPI配置，并且初始化默认值的，首先获取cachedClasses中缓存的map，这个map保存的key是SPI配置中的key，value则是配置中的value对应的class对象。如果缓存中没有那么调用loadExtensionClasses()方法读取配置并且缓存到cachedClasses中。
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()
调用cacheDefaultExtensionName()方法初始化cachedDefaultName，然后调用根据不同的策略读取配置文件，有三个策略调用loadDirectory()方法分别读取MTEA-INF/dubbo，META-INF/services，META-INF/dubbo/internal三个目录下的spi配置。
private Map<String, Class<?>> loadExtensionClasses() {
//这个方法就是初始化cachedDefaultName的
cacheDefaultExtensionName();
Map<String, Class<?>> extensionClasses = new HashMap<>();
//根据不同的策略读取不同的配置文件，包括MTEA-INF/dubbo
// META-INF/services META-INF/dubbo/internal 三个目录
for (LoadingStrategy strategy : strategies) {
loadDirectory(extensionClasses, strategy.directory(), type.getName(), strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
//为了适配之前旧的版本（没有捐给apache之前的包名是com.alibaba）
loadDirectory(extensionClasses, strategy.directory(), type.getName().replace("org.apache", "com.alibaba"), strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
}
return extensionClasses;
}cacheDefaultExtensionName()
这个方法主要是用来初始化cachedDefaultName的，读取@SPI注解中的value，这个value就是默认的扩展点实例的name。
private void cacheDefaultExtensionName() {
// 获取到接口的@SPI注解
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
if (defaultAnnotation == null) {
return;
}
//获取注解中的value
String value = defaultAnnotation.value();
if ((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进行初始化
cachedDefaultName = names[0];
}
}
}strategies是哪些策略呢？我们可以看它的初始化
private static volatile LoadingStrategy[] strategies = loadLoadingStrategies();通过loadLoadingStrategies()方法进行初始化
private static LoadingStrategy[] loadLoadingStrategies() {
return stream(load(LoadingStrategy.class).spliterator(), false)
.sorted()
.toArray(LoadingStrategy[]::new);
}我们可以看到这里是调用了java.util.ServiceLoader的load方法获取的，也就是通过了java的SPI获取到了加载配置文件的所有的策略类。
我们可以在META-INFO/services中找到名称为org.apache.dubbo.common.extension.LoadingStrategy的文件，里面存着加载SPI的策略类，三个类的directory()方法分别返回三个不同的目录。
注：这里我们也就知道了为什么要把SPI的配置文件放在MTEA-INF/dubbo，META-INF/services，META-INF/dubbo/internal这三个目录下面。
org.apache.dubbo.common.extension.DubboInternalLoadingStrategy
org.apache.dubbo.common.extension.DubboLoadingStrategy
org.apache.dubbo.common.extension.ServicesLoadingStrategy复制代码获取到加载的策略之后我们就可以继续向下分析了，接下来就是loadDirectory()方法读取SPI配置文件。
loadDirectory()
这个方法看起来很长，其实主要就是获取三个目录下所有的配置文件然后调用loadResource()方法加载解析配置文件。
注：从这里我们也就知道为什么SPI的配置文件名称必须是接口的全类名
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type,
boolean extensionLoaderClassLoaderFirst, boolean overridden, String... excludedPackages) {
//通过目录和接口全类名获取到SPI配置文件名称
String fileName = dir + type;
try {
Enumeration<java.net.URL> urls = null;
ClassLoader classLoader = findClassLoader();
// try to load from ExtensionLoader's ClassLoader first
if (extensionLoaderClassLoaderFirst) {
ClassLoader extensionLoaderClassLoader = ExtensionLoader.class.getClassLoader();
if (ClassLoader.getSystemClassLoader() != extensionLoaderClassLoader) {
urls = extensionLoaderClassLoader.getResources(fileName);
}
}
if (urls == null || !urls.hasMoreElements()) {
if (classLoader != null) {
urls = classLoader.getResources(fileName);
} else {
urls = ClassLoader.getSystemResources(fileName);
}
}
if (urls != null) {
while (urls.hasMoreElements()) {
java.net.URL resourceURL = urls.nextElement();
//加载配置解析SPI配置文件
loadResource(extensionClasses, classLoader, resourceURL, overridden, excludedPackages);
}
}
} catch (Throwable t) {
logger.error("Exception occurred when loading extension class (interface: " +
type + ", description file: " + fileName + ").", t);
}
}loadResource()
这个方法就是用来解析SPI文件的，解析完之后调用loadClass()方法对所有的实现类进行实例化。
private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader,
java.net.URL resourceURL, boolean overridden, String... excludedPackages) {
try {
try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), StandardCharsets.UTF_8))) {
String line;
String clazz = null;
//一行一行的读取
while ((line = reader.readLine()) != null) {
//如果读取到#号 那么获取#号之前的数据 因为#号之后的是注释
final int ci = line.indexOf('#');
if (ci >= 0) {
line = line.substring(0, ci);
}
line = line.trim();
if (line.length() > 0) {
try {
//根据“=”号进行分隔 等号前的是name，后面的是对应的类名
String name = null;
int i = line.indexOf('=');
if (i > 0) {
name = line.substring(0, i).trim();
clazz = line.substring(i + 1).trim();
} else {
clazz = line;
}
if (StringUtils.isNotEmpty(clazz) && !isExcluded(clazz, excludedPackages)) {
//如果类名不为空 而且没有被排除加载 那么调用loadClass()方法
loadClass(extensionClasses, resourceURL, Class.forName(clazz, true, classLoader), name, overridden);
}
} catch (Throwable t) {
IllegalStateException e = new IllegalStateException("Failed to load extension class (interface: " + type + ", class line: " + line + ") in " + resourceURL + ", cause: " + t.getMessage(), t);
exceptions.put(line, e);
}
}
}
}
} catch (Throwable t) {
logger.error("Exception occurred when loading extension class (interface: " +
type + ", class file: " + resourceURL + ") in " + resourceURL, t);
}
}loadClass()
作用是解析每一个扩展点实现类，初始化cachedAdaptiveClass（用于缓存加了@Adaptive注解的实现类，下面简称adaptive类），cachedWrapperClasses(扩展点下所有的包装类)，cachedActivates（扩展点下所有的activates类），cachedNames（用于缓存扩展点实现类的name）等，并且将name和实现类的关系放到extensionClasses中，extensionClasses会在getExtensionClasses()方法中赋值给cachedClasses缓存起来。
注意：adaptive类（即加了@Adaptive注解的实现类）是不会保存在extensionClasses中的，所以通过getExtension(String name)这个api是获取不到adaptive类的。
private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name,
boolean overridden) throws NoSuchMethodException {
// 如果class不是type的实现类 抛出异常
if (!type.isAssignableFrom(clazz)) {
throw new IllegalStateException("Error occurred when loading extension class (interface: " +
type + ", class line: " + clazz.getName() + "), class "
+ clazz.getName() + " is not subtype of interface.");
}
//如果实现类上面有@Adaptive注解
if (clazz.isAnnotationPresent(Adaptive.class)) {
//缓存默认的adaptive类
cacheAdaptiveClass(clazz, overridden);
} else if (isWrapperClass(clazz)) {
//判断是不是包装类就是看他有没有扩展点类型的构造器 其实就是装饰器模式
//如果是包装类 那么缓存包装类
cacheWrapperClass(clazz);
} else {
//这里要求扩展点的实现类必须有无参构造函数，不然会抛出NoSuchMethodException
clazz.getConstructor();
if (StringUtils.isEmpty(name)) {
//获取配置的name为空的话（配置文件支持不配key），如果实现类上有@Extension注解，优先拿@Extension注解的value作为name，否则name就为实现类的简单类名的小写
name = findAnnotationName(clazz);
if (name.length() == 0) {
throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
}
}
//如果name中有',',那么相当于是多个name用','分开
String[] names = NAME_SEPARATOR.split(name);
if (ArrayUtils.isNotEmpty(names)) {
//如果实现类上有@Activate注解，那么初始化cachedActivates
cacheActivateClass(clazz, names[0]);
for (String n : names) {
//缓存实现类与name的关系
cacheName(clazz, n);
//保存name与实现类的关系到extensionClasses中，注意adaptive类是不会保存在extensionClasses里面的 在第一个if对adaptive类进行了处理
saveInExtensionClass(extensionClasses, clazz, n, overridden);
}
}
}
}到这里loadExtensionClasses()方法执行完成，初始化完SPI配置文件后回到getExtensionClasses()方法，将cachedClasses初始化并返回之后，回到了createExtension()方法中，就可以通过name获取对应的扩展点实现类的Class对象了。
接下来就可以继续分析createExtension()方法了
createExtension()
这个方法是用于创建对应的扩展点实现类的，getExtensionClasses()方法我们前面分析了，它进行了一系列的初始化操作。首先获取到实现类的Class对象，然后从缓存中获取实例，如果缓存中没有，那么就反射调用无参构造函数创建实例，然后将创建好的实例放入到缓存中（这有没有一点熟悉，跟Spring的IoC好像啊），然后调用injectExtension()方法对实现类中的SPI属性初始化（也就是DI,依赖注入）,最后如果需要包装，那么就将扩展点的所有包装类循环，将实现类一层层的包装起来，最后返回实例。
private T createExtension(String name, boolean wrap) {
//从cachedClasses中通过名字获取到扩展点实现类的class对象 因为前面已经分析过了getExtensionClasses()会将cachedClasses初始化
Class<?> clazz = getExtensionClasses().get(name);
//没有对应实现类的class 抛出异常
if (clazz == null || unacceptableExceptions.contains(name)) {
throw findException(name);
}
try {
//获取对应实现类的实例 还是线程缓存中取 没有的话就反射创建一个对象
T instance = (T) EXTENSION_INSTANCES.get(clazz);
if (instance == null) {
EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.getDeclaredConstructor().newInstance());
instance = (T) EXTENSION_INSTANCES.get(clazz);
}
//依赖注入spi属性 这个方法很关键 涉及到dubbo SPI的DI 需要重点分析
injectExtension(instance);
//这里wrap默认是true 也就是支持包装 所以需要将对象包装返回包装对象出去
if (wrap) {
List<Class<?>> wrapperClassesList = new ArrayList<>();
if (cachedWrapperClasses != null) {
//获取缓存的包装类
//前面已经分析过cachedWrapperClasses会在getExtensionClasses()中初始化
wrapperClassesList.addAll(cachedWrapperClasses);
//排个序
wrapperClassesList.sort(WrapperComparator.COMPARATOR);
Collections.reverse(wrapperClassesList);
}
if (CollectionUtils.isNotEmpty(wrapperClassesList)) {
for (Class<?> wrapperClass : wrapperClassesList) {
Wrapper wrapper = wrapperClass.getAnnotation(Wrapper.class);
if (wrapper == null
|| (ArrayUtils.contains(wrapper.matches(), name) && !ArrayUtils.contains(wrapper.mismatches(), name))) {
//对原生对象进行包装 并且对包装类进行DI
instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
}
}
}
}
//调用一下生命周期的方法
initExtension(instance);
//将实例返回出去
return instance;
} catch (Throwable t) {
throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
type + ") couldn't be instantiated: " + t.getMessage(), t);
}
}injectExtension()
这个方法很重要，dubbo SPI的DI就是通过这个方法实现的。首先判断objectFactory这个成员变量是否为null，为null的话直接返回了。否则获取需要注入的类中所有的方法，然后过滤出set方法，再用objectFactory的getExtension()方法获取实例，最后反射调用set方法进行赋值。
injectExtension()
private T injectExtension(T instance) {
if (objectFactory == null) {
//objectFactory为null 直接返回
return instance;
}
try {
//遍历类中所有的方法
for (Method method : instance.getClass().getMethods()) {
if (!isSetter(method)) {
//不是set方法 直接跳过
continue;
}
/**
* Check {@link DisableInject} to see if we need auto injection for this property
*/
//方法上如果有@DisableInject注解 那么直接跳过
if (method.getAnnotation(DisableInject.class) != null) {
continue;
}
Class<?> pt = method.getParameterTypes()[0];
//如果是8大基本类型 直接跳过
if (ReflectUtils.isPrimitives(pt)) {
continue;
}
try {
//通过解析set方法方法名获取到属性的名称
String property = getSetterProperty(method);
//从objectFactory中获取实例
Object object = objectFactory.getExtension(pt, property);
if (object != null) {
//获取到的实例不为null 那么反射调用set方法赋值 完成DI
method.invoke(instance, object);
}
} catch (Exception e) {
logger.error("Failed to inject via method " + method.getName()
+ " of interface " + type.getName() + ": " + e.getMessage(), e);
}
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return instance;
}可以看到整个DI的逻辑并不复杂，关键是objectFactory到底是什么，它在哪里初始化。objectFactory的getExtension()方法获取到的对象是哪来的？所以我们进一步分析objectFactory的初始化。
其实我们不难发现objectFactory正是在ExtensionLoader的构造函数中初始化。
private ExtensionLoader(Class<?> type) {
this.type = type;
//如果正好是ExtensionFactory自己的扩展点，那么就返回null 否则赋值为ExtensionFactory扩展点的adaptive类
objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}不难看出ExtensionFactory本身也是一个扩展点，我们可以看到它有三个实现类
1.AdaptiveExtensionFactory
这个类加了@Adaptive注解的实现类，那么ExtensionLoader构造函数中赋值的正是这个类的实例。而AdaptiveExtensionFactory在构造函数的时候获取到ExtensionFactory扩展点的非adaptived的其他所有实现类保存到成员变量factories中，而它的getExtension()正是从循环其他工厂调用getExtension()方法获取实例。
public AdaptiveExtensionFactory() {
ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
//获取到ExtensionFactory扩展点的非adaptived的其他所有实现类
for (String name : loader.getSupportedExtensions()) {
//加入到list中赋值给成员变量factories
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;
}2.SpiExtensionFactory
这个工厂获取实例是从dubbo中的SPI容器中获取实例
public <T> T getExtension(Class<T> type, String name) {
if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
if (!loader.getSupportedExtensions().isEmpty()) {
return loader.getAdaptiveExtension();
}
}
return null;
}3.SpringExtensionFactory
这个顾名思义正是从Spring容器中获取实例。
@Override
@SuppressWarnings("unchecked")
public <T> T getExtension(Class<T> type, String name) {
//SPI should be get from SpiExtensionFactory
if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
return null;
}
for (ApplicationContext context : CONTEXTS) {
T bean = BeanFactoryUtils.getOptionalBean(context, name, type);
if (bean != null) {
return bean;
}
}
//logger.warn("No spring extension (bean) named:" + name + ", try to find an extension (bean) of type " + type.getName());
return null;
}那么到这里getExtension()方法的逻辑就全部分析完了，接下来分析getAdaptiveExtension()方法。
getAdaptiveExtension()
首先从缓存中获取adaptive的实例，如果实例为空，那么双重检查锁调用createAdaptiveExtension()方法创建实例，并且初始化cachedAdaptiveInstance缓存起来。
public T getAdaptiveExtension() {
//先从缓存中取
Object instance = cachedAdaptiveInstance.get();
if (instance == null) {
if (createAdaptiveInstanceError != null) {
throw new IllegalStateException("Failed to create adaptive instance: " +
createAdaptiveInstanceError.toString(),
createAdaptiveInstanceError);
}
//双重检查锁
synchronized (cachedAdaptiveInstance) {
instance = cachedAdaptiveInstance.get();
if (instance == null) {
try {
//实例为null 调用createAdaptiveExtension()方法获取实例
instance = createAdaptiveExtension();
//将实例放入缓存中
cachedAdaptiveInstance.set(instance);
} catch (Throwable t) {
createAdaptiveInstanceError = t;
throw new IllegalStateException("Failed to create adaptive instance: " + t.toString(), t);
}
}
}
}
//返回实例
return (T) instance;
}createAdaptiveExtension()
这个方法作用是创建adaptive扩展点实现类，首先调用getAdaptiveExtensionClass()获取class对象，然后反射获取实例之后，调用injectExtension()方法完成DI.
private T createAdaptiveExtension() {
try {
return injectExtension((T) getAdaptiveExtensionClass().newInstance());
} catch (Exception e) {
throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
}
}getAdaptiveExtensionClass()
这个方法的作用是获取Adaptive扩展点实现类的Class对象。首先调用getExtensionClasses()方法，这个方法我们在前面分析过了，就是解析SPI配置，并且做一些初始化，其中就包括了cachedAdaptiveClass。如果初始化之后cachedAdaptiveClass还是为null，那么就会调用createAdaptiveExtensionClass()创建Adaptive扩展点实现类的Class。
private Class<?> getAdaptiveExtensionClass() {
//解析配置 初始化一些缓存成员变量 其中包括cachedAdaptiveClass
getExtensionClasses();
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
//如果cachedAdaptiveClass还是为null 说明该扩展点没有存在@Adaptive注解的实现类
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}createAdaptiveExtensionClass()
走到这个方法说明该扩展点没有存在@Adaptive注解的实现类，dubbo就会帮助我们生成一个代理类来作为Adaptive类。根据扩展点的type和默认的扩展点实现类的name调用generate()方法获得相关的代码，然后通过编译器编译代码。
private Class<?> createAdaptiveExtensionClass() {
ClassLoader classLoader = findClassLoader();
try {
if (ApplicationModel.getEnvironment().getConfiguration().getBoolean(NATIVE, false)) {
return classLoader.loadClass(type.getName() + "$Adaptive");
}
} catch (Throwable ignore) {
}
//通过扩展点的type和默认的扩展点实现类的name拼接成一个类的字符串
String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
//获取编译器
org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
//编译代码
return compiler.compile(code, classLoader);
}generate()
这个方法的作用正是用来生成相关的代理类的代码的。
public String generate() {
// no need to generate adaptive class since there's no adaptive method found.
//如果扩展点接口没有加了@Adaptive注解的方法 那么抛出异常
if (!hasAdaptiveMethod()) {
throw new IllegalStateException("No adaptive method exist on extension " + type.getName() + ", refuse to create the adaptive class!");
}
//开始拼接字符串
StringBuilder code = new StringBuilder();
//首先拼接包名
code.append(generatePackageInfo());
//拼接导入的类
code.append(generateImports());
//拼接类名
code.append(generateClassDeclaration());
//获取到扩展点接口的所有方法 进行循环
Method[] methods = type.getMethods();
for (Method method : methods) {
//生成接口方法实现
code.append(generateMethod(method));
}
code.append('}');
if (logger.isDebugEnabled()) {
logger.debug(code.toString());
}
return code.toString();
}举个例子，看一下生成的代码长什么样
package org.apache.dubbo.metadata.report;
import org.apache.dubbo.common.extension.ExtensionLoader;
public class MetadataReportFactory$Adaptive implements org.apache.dubbo.metadata.report.MetadataReportFactory {
public org.apache.dubbo.metadata.report.MetadataReport getMetadataReport(org.apache.dubbo.common.URL arg0) {
if (arg0 == null) throw new IllegalArgumentException("url == null");
org.apache.dubbo.common.URL url = arg0;
String extName = ( url.getProtocol() == null ? "redis" : url.getProtocol() );
if(extName == null) throw new IllegalStateException("Failed to get extension (org.apache.dubbo.metadata.report.MetadataReportFactory) name from url (" + url.toString() + ") use keys([protocol])");
org.apache.dubbo.metadata.report.MetadataReportFactory extension = (org.apache.dubbo.metadata.report.MetadataReportFactory)ExtensionLoader.getExtensionLoader(org.apache.dubbo.metadata.report.MetadataReportFactory.class).getExtension(extName);
return extension.getMetadataReport(arg0);
}
}到这里getAdaptiveExtension()方法也就解析完了，最后分析一下getActivateExtensions()方法，
getActivateExtensions()
这个方法是用来获取扩展类中所有的加了@Activate注解的实现类实例。首先调用getExtensionClasses()方法解析SPI配置，初始化一些缓存变量。其中就包括cachedActivates。首先通过getExtensionClass()方法和getExtension()方法建立class与实例之间的关系，存入一个map中，最后发返回所有的Activate实例。
public List<T> getActivateExtensions() {
List<T> activateExtensions = new ArrayList<>();
TreeMap<Class<?>, T> activateExtensionsMap = new TreeMap<>(ActivateComparator.COMPARATOR);
//初始化
getExtensionClasses();
for (Map.Entry<String, Object> entry : cachedActivates.entrySet()) {
String name = entry.getKey();
Object activate = entry.getValue();
if (!(activate instanceof Activate)) {
continue;
}
//建立class与实例之间的关系
activateExtensionsMap.put(getExtensionClass(name), getExtension(name));
}
if (!activateExtensionsMap.isEmpty()) {
activateExtensions.addAll(activateExtensionsMap.values());
}
return activateExtensions;
}总结
本文以getExtension()，getAdaptiveExtension()，getActivateExtensions()三个常用的api为入口对dubbo SPI的核心类ExtensionLoader的核心代码进行了分析。虽然本篇文章的篇幅可能过长，但是也是为了讲的更细一点，如果大家有什么疑问或者建议，欢迎在下方评论区留言。
腾讯云开发者
