SPI核心机制主要依赖于ExtensionLoader类，在3.0版本中获取扩展点的方式跟2版本是有区别的，已经废弃了原本的方式，而是采用以下方式
ExtensionLoader<Protocol> extensionLoader =
ApplicationModel.defaultModel().getExtensionLoader(Protocol.class);
Protocol http = extensionLoader.getExtension("http");
http.sendRequest("http hello");
ExtensionLoader的核心功能点：
- 扩展点的加载
- 扩展点的依赖注入
- 扩展点的自适应
- 以及扩展点的激活
1.extensionLoader.getExtension()方法流程
public T getExtension(String name) {
//调用重载方法，跟进去
T extension = getExtension(name, true);
if (extension == null) {
throw new IllegalArgumentException("Not find extension: " + name);
}
return extension;
}
public T getExtension(String name, boolean wrap) {
final Holder<Object> holder = getOrCreateHolder(cacheKey);
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;
}
private T createExtension(String name, boolean wrap) {
//获取类对象
Class<?> clazz = getExtensionClasses().get(name);
if (clazz == null || unacceptableExceptions.contains(name)) {
throw findException(name);
}
try {
//先从实例map中取一下看是否存在实例
T instance = (T) extensionInstances.get(clazz);
if (instance == null) {
//创建实例并放入map中
extensionInstances.putIfAbsent(clazz, createExtensionInstance(clazz));
//再从实例map中获取
instance = (T) extensionInstances.get(clazz);
//前置增强
instance = postProcessBeforeInitialization(instance, name);
//判断是否需要setter注入
injectExtension(instance);
//后置增强
instance = postProcessAfterInitialization(instance, name);
}
//是否存在包装
if (wrap) {
List<Class<?>> wrapperClassesList = new ArrayList<>();
if (cachedWrapperClasses != null) {
wrapperClassesList.addAll(cachedWrapperClasses);
wrapperClassesList.sort(WrapperComparator.COMPARATOR);
Collections.reverse(wrapperClassesList);
}
if (CollectionUtils.isNotEmpty(wrapperClassesList)) {
for (Class<?> wrapperClass : wrapperClassesList) {
Wrapper wrapper = wrapperClass.getAnnotation(Wrapper.class);
boolean match = (wrapper == null) ||
((ArrayUtils.isEmpty(wrapper.matches()) || ArrayUtils.contains(wrapper.matches(), name)) &&
!ArrayUtils.contains(wrapper.mismatches(), name));
if (match) {
//装饰增强
instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
//执行后置通知
instance = postProcessAfterInitialization(instance, name);
}
}
}
}
// Warning: After an instance of Lifecycle is wrapped by cachedWrapperClasses, it may not still be Lifecycle instance, this application may not invoke the lifecycle.initialize hook.
initExtension(instance);
return instance;
} catch (Throwable t) {
throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
type + ") couldn't be instantiated: " + t.getMessage(), t);
}
}
2.Dubbo 依赖注入
依赖注入，实现类依赖的属性自动注入，类似spring的依赖注入。如果字段不想不注入，可以在set方法上使用DisableInject注解。被依赖注入的属性类的方法必须有@Adaptive注解，即这个类是一个自适应SPI。
3.扩展点原理
案例代码如下
@SPI
public interface Animal {
@Adaptive
String eat(URL url);
}
@Adaptive
public class Cat implements Animal{
@Override
public String eat(URL url) {
return "Cat eat";
}
}
public class Dog implements Animal{
@Override
public String eat(URL url) {
return "Dog eat";
}
}
public class Pig implements Animal{
@Override
public String eat(URL url) {
return "Pig eat";
}
}
public class Demo {
public static void main(String[] args) {
ExtensionLoader<Animal> extensionLoader = ExtensionLoader.getExtensionLoader(Animal.class);
Animal animal = extensionLoader.getAdaptiveExtension();
String cat = animal.eat(URL.valueOf("http://localhost?aa=pig"));
System.out.println(cat);
}
}
输出结果为Cat eat
一个SPI下扩展点只能有一个，原理代码如下
private Map<String, Class<?>> loadExtensionClasses() {
cacheDefaultExtensionName();
Map<String, Class<?>> extensionClasses = new HashMap<>();
loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName());
loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName());
loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName());
loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
return extensionClasses;
}
private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name) throws NoSuchMethodException {
if (!type.isAssignableFrom(clazz)) {
throw new IllegalStateException();
}
if (clazz.isAnnotationPresent(Adaptive.class)) {
//缓存扩展点
cacheAdaptiveClass(clazz);
} else if (isWrapperClass(clazz)) {
} else {
}
}
private void cacheAdaptiveClass(Class<?> clazz) {
//只能有一个扩展点
if (cachedAdaptiveClass == null) {
cachedAdaptiveClass = clazz;
} else if (!cachedAdaptiveClass.equals(clazz)) {
throw new IllegalStateException("More than 1 adaptive class found: "
+ cachedAdaptiveClass.getName()
+ ", " + clazz.getName());
}
}
注释掉Cat的@Adaptive，默认的实现code如下：
private Class<?> createAdaptiveExtensionClass() {
String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
ClassLoader classLoader = findClassLoader();
org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
return compiler.compile(code, classLoader);
}
import org.apache.dubbo.common.extension.ExtensionLoader;
public class Animal\$Adaptive implements com.doukill.dubbo.adaptive.Animal {
public java.lang.String eat(org.apache.dubbo.common.URL arg0) {
if (arg0 == null) throw new IllegalArgumentException("url == null");
org.apache.dubbo.common.URL url = arg0;
String extName = url.getParameter("animal", "pig");
if(extName == null) throw new IllegalStateException("Failed to get extension (com.doukill.dubbo.adaptive.Animal) name from url (" + url.toString() + ") use keys(\[animal])");
com.doukill.dubbo.adaptive.Animal extension = (com.doukill.dubbo.adaptive.Animal)ExtensionLoader.getExtensionLoader(com.doukill.dubbo.adaptive.Animal.class).getExtension(extName);
return extension.eat(arg0);
}
}
```
类URL中代码：
public String getParameter(String key) {
String value = parameters.get(key);
return StringUtils.isEmpty(value) ? parameters.get(DEFAULT_KEY_PREFIX + key) : value;
}
public String getParameter(String key, String defaultValue) {
String value = getParameter(key);
return StringUtils.isEmpty(value) ? defaultValue : value;
}
ExtensionLoader<Animal> extensionLoader = ExtensionLoader.getExtensionLoader(Animal.class);
Animal animal = extensionLoader.getAdaptiveExtension();
String cat = animal.eat(URL.valueOf("http://localhost?animal=cat"));
System.out.println(cat);
String pig = animal.eat(URL.valueOf("http://localhost?animal=pig"));
System.out.println(pig);
String dog = animal.eat(URL.valueOf("http://localhost?animal=dog"));
System.out.println(dog);
//报错 没有默认值，除非在SPI注解上加一个默认值
String def = animal.eat(URL.valueOf("http://localhost"));
System.out.println(def);
```
作用其实比较简单，就是想动态地指定 URL 中的参数，来动态切换实现类去执行业务逻辑，把一堆根据参数获取实现类的重复代码，全部封装到了代理类中，以达到充分灵活扩展的效果。
@Adaptive 注解其实是生成了一个自适应的代理类，每个 SPI 接口都有且仅有一个自适应扩展点。
然后跟踪了加载 SPI 资源文件的 loadDirectory 方法的源码，发现 @Adaptive 注解不仅可以
写在 SPI 接口的方法上，还可以写在 SPI 接口实现类上，并且在使用自适应扩展的时候，若实
现类有 @Adaptive 注解，则优先使用该实现类作为自适应扩展点。
要实现SPI的setter注入，必须要有@Adaptive注解，源码如下：
public String generate() {
// no need to generate adaptive class since there's no adaptive method found.
//这里必须要有注解方法
if (!hasAdaptiveMethod()) {
throw new IllegalStateException("No adaptive method exist on extension " + type.getName() + ", refuse to create the adaptive class!");
}
StringBuilder code = new StringBuilder();
return code.toString();
}
public class Bb$Adaptive implements com.doukill.dubbo.demo.Bb {
public java.lang.String eat(org.apache.dubbo.common.URL arg0) {
if (arg0 == null) throw new IllegalArgumentException("url == null");
org.apache.dubbo.common.URL url = arg0;
String extName = url.getParameter("bb");
if (extName == null)
throw new IllegalStateException("Failed to get extension (com.doukill.dubbo.demo.Bb) " +
"name from url (" + url.toString() + ") use keys([bb])");
com.doukill.dubbo.demo.Bb extension = (com.doukill.dubbo.demo.Bb)
ExtensionLoader.getExtensionLoader(com.doukill.dubbo.demo.Bb.class).getExtension(extName);
return extension.eat(arg0);
}
}