概述
ExtensionLoader是dubbo项目的核心组件,正是有了它,使得dubbo的可扩展性得到了极大的提升.dubbo设计之精良,从这点可见一斑.
dubbo的扩展机制,类似于jdk所提供的spi机制. 但是dubbo的更加强大,体现在:
- jdk的spi默认会加载并实例化所有扩展点类，如果对应扩展点没用到且实例化消耗大，则是个耗资源的点。
- 不支持依赖注入，即如果在扩展点类a中，有b扩展点属性实例，则在加载扩展点类a时不会自动注入b。但是dubbo支持依赖注入(根据目标类的setter方法注入
- 加载扩展点失败会吞掉异常，比如加载一个扩展类a，如果其所依赖的jar找不到，不会报这个错误，反而会报不支持。
首先,先手写一个demo利用dubbo的扩展机制,实现一个自己的服务.初步体验一下ExtensionLoader的用法.
首先定义一个(SPI)接口
//必须有 @spi注解 没有就报错
@SPI
public interface BaseExt {
@Adaptive
String echo(String str, URL url);
}
然后定义2个实现类
@Adaptive
public class ExtOne implements BaseExt {
@Override
public String echo(String str, URL url) {
System.out.println("one ... " + str);
return null;
}
}
public class ExtTwo implements BaseExt {
@Override
public String echo(String str, URL url) {
System.out.println("two ... " + str);
return null;
}
}
最后要在 classpath(src/main/resources)下创建一个META-INF/dubbo/internal的目录,创建一个名字为spi接口全路径(com.xx.BaseExt)的文件里面写入一下内容(key=value)
one=com.xx.ExtOne
two=com.xx.ExtTwo
搞定,最后写一个测试类
public class Main {
public static void main(String[] args) {
//
ExtensionLoader<BaseExt> loader = ExtensionLoader.getExtensionLoader(BaseExt.class);
BaseExt adaptiveExtension = loader.getAdaptiveExtension();
URL url = URL.valueOf("test://localhost/test");
adaptiveExtension.echo("d", url);
}
得到以下输出
one ... d
入门非常简单,例子更简单.从上面能得到一下总结: 用法其实和jdk的ServiceLoader 一个思想, (接口+实现类+配置文件) . 其实dubbo的扩展一直要遵守一下的约定
- Dubbo约定，需要通过SPI加载的接口，在接口上必须添加注解@SPI。
- Dubbo自己实现了加载器（ExtensionLoader）而非使用JDK自带的（ServiceLoader）。
- 实现类的配置文件名称还是以接口全路径命名约定不变，但是内容以key=value格式存在，key表示实现类的别名，value表示实现类全路径（JDK自带的SPI约定内容是实现类全路径）。
- ExtensionLoader分别从依赖的JAR包中的，META－INF/dubbo/internal/目录、META－INF/dubbo/目录、META－INF/services/目录，这个3个目录中扫描寻找实现类配置文件。
- 所有SPI接口，都会有一个要求有一个适配类（即在实现类打上@Adaptive注解就被认定为适配类，如果扫描后所有实现类都没有该注解，系统会生成一个）。在系统里面使用时，一般都先获取接口的适配类实例，然后再由入参配置来决定选择哪个具体实现类调用。实现了可配置动态切换实现类。
- 在实现类里面，可以通过提供setter方法来达到依赖注入。
其实dubbo一个spi服务一般会有多种实现 ,具体使用哪一个实现呢? 这个是忧优先级的 .
- 首先,在实现类(方法上无效)上面加
@Adaptive注解,优先级会最高 - 如果所有实现类都没有这个注解(接口方法上的不算),回去寻找url路径中的指明的那个注解 ,比如上面mian函数中的 ,spi接口的分段形式(XxxYyy类的分段形式 : xxxx.yyy)作为key,配置文件中的key作为value, 根据这个value也可以找到具体实现类,比如上面如果URL中这样写:
URL url = URL.valueOf("test://localhost/test?base.ext=one");
就表示 spi接口BaseExt 要求使用OneExt作为实现类 - 如果URL中也没有指定 ,还有次次优先级的方式: spi注解中加入默认值
比如 BaseExt的spi注解中这样写:@SPI("two")此时,TwoExt 就作为默认实现类提供服务了 .注意这个优先级哦
知道了上面的用法和各种玩法. 下面是时候再探究竟了 .我们看下源代码吧 .
ExtensionLoader<BaseExt> loader = ExtensionLoader.getExtensionLoader(BaseExt.class);
引出
@SuppressWarnings("unchecked")
public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
if (type == null)
throw new IllegalArgumentException("Extension type == null");
//说明SPI获取的必须是接口类型
if(!type.isInterface()) {
throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
}
// 说明SPI服务的接口必须有`@SPI`这个注解
if(!withExtensionAnnotation(type)) {
throw new IllegalArgumentException("Extension type(" + type +
") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
}
//第一次获取必定拿到null
ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
if (loader == null) {
//new一个扩展器处理这个type,new操作的特别之处在于会创建一个factory来获取目标type,从而得到扩展工厂,
EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
}
return loader;
}
创建扩展工厂需要ExtensionFactory
private ExtensionLoader(Class<?> type) {
this.type = type;
objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}
从上面可以看到 ,拿到 ExtensionFactory之后,会放入 ExtensionLoader的内部类变量
private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>();里面 .这个玩意就是缓存着了. 所有获取过的扩展对象都会在这里存下来. 后面再拿就走这个缓存了. 我们再来看main中下一句引子BaseExt adaptiveExtension = loader.getAdaptiveExtension();
public T getAdaptiveExtension() {
Object instance = cachedAdaptiveInstance.get();
if (instance == null) {
if(createAdaptiveInstanceError == null) {
synchronized (cachedAdaptiveInstance) {
instance = cachedAdaptiveInstance.get();
if (instance == null) {
try {
//首次拿扩展实例会需要先创建 ,
//创建好了 才回缓存这个实例
//下面这句是核心逻辑 ,
instance = createAdaptiveExtension();
cachedAdaptiveInstance.set(instance);
} 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;
}
调用创建扩展类函数 ExtensionLoader.createAdaptiveExtension
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
// 开始获取扩展
private Class<?> getAdaptiveExtensionClass() {
//这里如果获取下面步骤
getExtensionClasses();
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
//下面先沿着 getExtensionClasses 这条线 ,尝试获取扩展实现类
//下面是获取扩展的
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;
}
// 这个方法就是 核心逻辑了 ,会从文件中扫描指定接口的实现类
// 此方法已经getExtensionClasses方法同步过。
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<?>>();
//从 META-INF/dubbo/internal 目录读取
loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
// 从 META-INF/dubbo/ 目录读取
loadFile(extensionClasses, DUBBO_DIRECTORY);
// 从 META-INF/services/ 目录读取
loadFile(extensionClasses, SERVICES_DIRECTORY);
return extensionClasses;
}
//读取逻辑不在贴代码了 ,就是获取文件 按照key=value的配置文件的形式解析服务配置文件
//但是有一段代码贴下 ,就是在解析的过程中,发现实现类头上有 @Adaptive注解的 ,就把他设置到当前的 cachedAdaptiveClass 属性中去.(摘自方法 loadFile)
//
if (clazz.isAnnotationPresent(Adaptive.class)) {
if(cachedAdaptiveClass == null) {
cachedAdaptiveClass = clazz;
} else if (! cachedAdaptiveClass.equals(clazz)) {
throw new IllegalStateException("More than 1 adaptive class found: "
+ cachedAdaptiveClass.getClass().getName()
+ ", " + clazz.getClass().getName());
}
}
// ..................
到此为止,这条线已经走完,完成之后(看下面),如果在load的过程中 找到了自动适配的类(@adaptive注解的实现类) ,则直接返回
cachedAdaptiveClass完成任务 .否则开始走另一条线createAdaptiveExtensionClass
// 这块代码是上面开始的时候代码,
private Class<?> getAdaptiveExtensionClass() {
//这里如果获取下面步骤
getExtensionClasses();
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
接下来看看另一条线吧.
private Class<?> createAdaptiveExtensionClass() {
//拼接代码的方式
String code = createAdaptiveExtensionClassCode();
ClassLoader classLoader = findClassLoader();
com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
return compiler.compile(code, classLoader);
}
//不全部粘贴了 ,详细的自己看源码了 ,篇幅有限
private String createAdaptiveExtensionClassCode() {
StringBuilder codeBuidler = new StringBuilder();
Method[] methods = type.getMethods();
boolean hasAdaptiveAnnotation = false;
for(Method m : methods) {
if(m.isAnnotationPresent(Adaptive.class)) {
hasAdaptiveAnnotation = true;
break;
}
}
// 完全没有Adaptive方法，则不需要生成Adaptive类
if(! hasAdaptiveAnnotation)
throw new IllegalStateException("No adaptive method on extension " + type.getName() + ", refuse to create the adaptive class!");
codeBuidler.append("package " + type.getPackage().getName() + ";");
codeBuidler.append("\nimport " + ExtensionLoader.class.getName() + ";");
codeBuidler.append("\npublic class " + type.getSimpleName() + "$Adpative" + " implements " + type.getCanonicalName() + " {");
for (Method method : methods) {
Class<?> rt = method.getReturnType();
Class<?>[] pts = method.getParameterTypes();
Class<?>[] ets = method.getExceptionTypes();
//.......................省略 ,
可以看出,上面就是要通过代码创建一个java文件,并用compile进行编译
下面是一个通过编译得到的例子 (可读性比较差,但是能看出大概意思),
package com.xxx.dubbo;
import com.alibaba.dubbo.common.extension.ExtensionLoader;
public class BaseExt$Adpative implements com.zuosh.dts2018.dubbo.BaseExt {
public java.lang.String echo(java.lang.String arg0, com.alibaba.dubbo.common.URL arg1) {
if (arg1 == null) throw new IllegalArgumentException("url == null");
com.alibaba.dubbo.common.URL url = arg1;
String extName = url.getParameter("base.ext");
if(extName == null) throw new IllegalStateException("Fail to get extension(com.xxx.dubbo.BaseExt) name from url(" + url.toString() + ") use keys([base.ext])");
com.xxx.dubbo.BaseExt extension = (com.xxx.dubbo.BaseExt)ExtensionLoader.getExtensionLoader(com.xxx.dubbo.BaseExt.class).getExtension(extName);
return extension.echo(arg0, arg1);
}
}
上面就是获取自适应扩展实现类的全部过程. 我们从一个方法逐渐深入,看了扩展器的其中一个功能 (获取自适应扩展类) ,其他各种五花八门的获取实现类的方式(如下图)都是差不多同样的道理.都值得我们一一学习和参考.
image.png
后面的其他扩展原理都是大同小异,但是重载的很多方法给我们日常编码提供了很好的例子,让我们知道怎么样写一个好的扩展,而不是仅仅实现功能.
网友评论