//以下提到的擴展名就是在配置文件中的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;
}
}
