//以下提到的扩展名就是在配置文件中的key值，类似于“dubbo”等
//缓存的扩展名与拓展类映射，和cachedClasses的key和value对换。
private final ConcurrentMap, String> cachedNames = new ConcurrentHashMap, String>();
//缓存的扩展实现类集合
private final Holder>> cachedClasses = new Holder>>();
//扩展名与加有@Activate的自动激活类的映射
private final Map cachedActivates = new ConcurrentHashMap();
//缓存的扩展对象集合，key为扩展名，value为扩展对象
//例如Protocol扩展，key为dubbo，value为DubboProcotol
private final ConcurrentMap> cachedInstances = new ConcurrentHashMap cachedAdaptiveInstance = new Holder
public static ExtensionLoader getExtensionLoader(Class type) {
//扩展点接口为空，抛出异常
if (type == null)
throw new IllegalArgumentException("Extension type == null");
//判断type是否是一个接口类
if (!type.isInterface()) {
throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
}
//判断是否为可扩展的接口
if (!withExtensionAnnotation(type)) {
throw new IllegalArgumentException("Extension type(" + type +
") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
}
//从扩展加载器集合中取出扩展接口对应的扩展加载器
ExtensionLoader loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
//如果为空，则创建该扩展接口的扩展加载器，并且添加到EXTENSION_LOADERS
if (loader == null) {
EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));
loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
}
return loader;
}
这个方法的源码解析看上面，解读起来还是没有太多难点的。就是把几个属性的含义弄清楚就好了。
getActivateExtension方法：获得符合自动激活条件的扩展实现类对象集合
public List getActivateExtension(URL url, String key) {
return getActivateExtension(url, key, null);
}
//弃用
public List getActivateExtension(URL url, String[] values) {
return getActivateExtension(url, values, null);
}
public List getActivateExtension(URL url, String key, String group) {
String value = url.getParameter(key);
// 获得符合自动激活条件的拓展对象数组
return getActivateExtension(url, value == null || value.length() == 0 ? null : Constants.COMMA_SPLIT_PATTERN.split(value), group);
}
public List getActivateExtension(URL url, String[] values, String group) {
List exts = new ArrayList();
List names = values == null ? new ArrayList(0) : Arrays.asList(values);
//判断不存在配置 `"-name"` 。
//例如， ，代表移除所有默认过滤器。
if (!names.contains(Constants.REMOVE_VALUE_PREFIX + Constants.DEFAULT_KEY)) {
//获得扩展实现类数组，把扩展实现类放到cachedClasses中
getExtensionClasses();
for (Map.Entry entry : cachedActivates.entrySet()) {
String name = entry.getKey();
Activate activate = entry.getValue();
//判断group值是否存在所有自动激活类中group组中，匹配分组
if (isMatchGroup(group, activate.group())) {
//通过扩展名获得拓展对象
T ext = getExtension(name);
//不包含在自定义配置里。如果包含，会在下面的代码处理。
//判断是否配置移除。例如 ，则 MonitorFilter 会被移除
//判断是否激活
if (!names.contains(name)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)
&& isActive(activate, url)) {
exts.add(ext);
}
}
}
//排序
Collections.sort(exts, ActivateComparator.COMPARATOR);
}
List usrs = new ArrayList();
for (int i = 0; i < names.size(); i++) {
String name = names.get(i);
//还是判断是否是被移除的配置
if (!name.startsWith(Constants.REMOVE_VALUE_PREFIX)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)) {
//在配置中把自定义的配置放在自动激活的扩展对象前面，可以让自定义的配置先加载
//例如， ，则 DemoFilter 就会放在默认的过滤器前面。
if (Constants.DEFAULT_KEY.equals(name)) {
if (!usrs.isEmpty()) {
exts.addAll(0, usrs);
usrs.clear();
}
} else {
T ext = getExtension(name);
usrs.add(ext);
}
}
}
if (!usrs.isEmpty()) {
exts.addAll(usrs);
}
return exts;
}
@SuppressWarnings("unchecked")
public T getExtension(String name) {
if (name == null || name.length() == 0)
throw new IllegalArgumentException("Extension name == null");
//查找默认的扩展实现，也就是@SPI中的默认值作为key
if ("true".equals(name)) {
return getDefaultExtension();
}
//缓存中获取对应的扩展对象
Holder
public void addExtension(String name, Class clazz) {
getExtensionClasses(); // load classes
//该类是否是接口的本身或子类
if (!type.isAssignableFrom(clazz)) {
throw new IllegalStateException("Input type " +
clazz + "not implement Extension " + type);
}
//该类是否被激活
if (clazz.isInterface()) {
throw new IllegalStateException("Input type " +
clazz + "can not be interface!");
}
//判断是否为适配器
if (!clazz.isAnnotationPresent(Adaptive.class)) {
if (StringUtils.isBlank(name)) {
throw new IllegalStateException("Extension name is blank (Extension " + type + ")!");
}
if (cachedClasses.get().containsKey(name)) {
throw new IllegalStateException("Extension name " +
name + " already existed(Extension " + type + ")!");
}
//把扩展名和扩展接口的实现类放入缓存
cachedNames.put(clazz, name);
cachedClasses.get().put(name, clazz);
} else {
if (cachedAdaptiveClass != null) {
throw new IllegalStateException("Adaptive Extension already existed(Extension " + type + ")!");
}
cachedAdaptiveClass = clazz;
}
}
getAdaptiveExtension方法：获得自适应扩展对象，也就是接口的适配器对象
@SuppressWarnings("unchecked")
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;
}
private Class getExtensionClass(String name) {
if (type == null)
throw new IllegalArgumentException("Extension type == null");
if (name == null)
throw new IllegalArgumentException("Extension name == null");
Class clazz = getExtensionClasses().get(name);
if (clazz == null)
throw new IllegalStateException("No such extension "" + name + "" for " + type.getName() + "!");
return clazz;
}
@Adaptive
public class AdaptiveExtensionFactory implements ExtensionFactory {
//扩展对象的集合，默认的可以分为dubbo 的SPI中接口实现类对象或者Spring bean对象
private final List factories;
public AdaptiveExtensionFactory() {
ExtensionLoader loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
List list = new ArrayList();
//遍历所有支持的扩展名
for (String name : loader.getSupportedExtensions()) {
//扩展对象加入到集合中
list.add(loader.getExtension(name));
}
//返回一个不可修改的集合
factories = Collections.unmodifiableList(list);
}
@Override
public T getExtension(Class type, String name) {
for (ExtensionFactory factory : factories) {
//通过扩展接口和扩展名获得扩展对象
T extension = factory.getExtension(type, name);
if (extension != null) {
return extension;
}
}
return null;
}
}
