AdaptiveExtension
自适应Extension，作者其实在使用Extension方和Extension之间插入AdaptiveExtension用来自适应，也可以说是适配。
所以，我们发现，这里其实有三种，
1，一种是自动生成的Adaptive根据url参数来选择具体实现；
2，一种是自己实现一个Adaptive，写自己的逻辑选择具体实现，比如AdaptiveExtensionFactory，Compiler。这种都是在ExtensionLoader中需要使用，一般是不会这么做的。
3，还有一种没有Adaptive，实现一个adapter，比如TelnetHandler。这种因为不能根据url参数来决定使用哪一个实现。
从结构上看AdaptiveExtension是很重要的角色，我们配置了一些插件，但是具体使用哪一个如果用硬编码自然是不可能的，而这种自适应的方式得益于dubbo的状态数据信息都可以通过URL来获取，被叫做以URL为总线的模式。而自适应即是根据这些信息来决定调用哪一个插件的实现。
ExtensionLoader是插件机制的核心类:
private final Holder<Object> cachedAdaptiveInstance = new Holder<Object>();
// 获得AdaptiveExtension入口
public T getAdaptiveExtension() {
// cachedAdaptiveInstance缓存
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;
} 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);
}
} private Class<?> getAdaptiveExtensionClass() {
getExtensionClasses();
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
// 依然没有cachedAdaptiveClass 说明没有配置@Adaptive 那就自动生成一个
return cachedAdaptiveClass = createAdaptiveExtensionClass();
} private Class<?> createAdaptiveExtensionClass() {
// 组装java代码
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 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;
} 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，这个方法就会读取文件，解析出各个插件的class。有@Adaptive注解的会放入赋值给cachedAdaptiveClass。
下面以Transporter接口为例进行说明自动生成的代码:
@SPI("netty")
public interface Transporter {
@Adaptive({Constants.SERVER_KEY, Constants.TRANSPORTER_KEY})
Server bind(URL url, ChannelHandler handler) throws RemotingException;
@Adaptive({Constants.CLIENT_KEY, Constants.TRANSPORTER_KEY})
Client connect(URL url, ChannelHandler handler) throws RemotingException;
}
动态生成类：
public class Transporter$Adaptive implements Transporter {
public Server bind(URL arg0, ChannelHandler arg1) throws RemotingException {
URL url = arg0;
String extName = url.getParameter("server",
url.getParameter("transporter", "netty"));
Transporter extension = (Transporter) ExtensionLoader
.getExtensionLoader(Transporter.class).getExtension(extName);
return extension.bind(arg0, arg1);
}
}
Adaptive机制是一个很好的设计，很好的解决多方案实现的适配问题，如果你遇到类似的代码架构的时候，多想一下更加有扩展性的设计。