ExtensionLoader
ExtensionLoader
从上图中看到该类的构造方法被私有化，并且提供了一个静态方法来获取实例对象，
是的，该类使用了单例模式，懒汉模式
ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS... key:被扩展类，value:扩展器
一、构造方法：
- 将当前接口类型赋值给 this.type
- 将AdaptiveExtensionFactory对象赋值给 objectFactory对象
// 构造方法
private ExtensionLoader(Class<?> type) {
this.type = type;
objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class)
.getAdaptiveExtension());
}
二、获取对象的静态方法
public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
if (type == null)
throw new IllegalArgumentException("扩展类必须存在");
if (!type.isInterface()) {
throw new IllegalArgumentException("需要扩展的类型必须是接口");
}
if (!withExtensionAnnotation(type)) {
throw new IllegalArgumentException("被扩展的类必须被@SPI修饰");
}
// 从缓存中获取
ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
if (loader == null) {
// 缓存中没有，创建一个
EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
}
return loader;
}
可以得出结论：
被扩展类必须是一个被@SPI注解修饰的接口
dubbo先从缓存中获取扩展类的实例，如果没有则通过单例的懒汉式创建ExtensionLoader对象, 然后放入缓存
三、现在来看看下面这句代码, 创建当前类型的类扩展器，并放入缓存
EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
然后是构造方法，调用构造方法时，一个新的上下文，注意其中给objectFactory赋值的语句
private ExtensionLoader(Class<?> type) {
this.type = type;
objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}
注意：getAdaptiveExtension并没有为ExtensionFactory类型生成动态类, 在getAdaptiveExtensionClass方法中有控制（因为当前接口对应的扩展类文件中有AdaptiveExtensionFactory类，给cachedAdaptiveClass赋值了）
本类中的属性
private static final Logger logger = LoggerFactory.getLogger(ExtensionLoader.class);
// 扩展文件位置一
private static final String SERVICES_DIRECTORY = "META-INF/services/";
// 扩展文件位置二 这两个一般用来自定义扩展
private static final String DUBBO_DIRECTORY = "META-INF/dubbo/";
// 扩展文件位置三
private static final String DUBBO_INTERNAL_DIRECTORY = DUBBO_DIRECTORY + "internal/";
// 扩展名分割
private static final Pattern NAME_SEPARATOR = Pattern.compile("\\s*[,]+\\s*");
// 扩展接口 与对应的扩展器（存放所有的扩展器）
private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>();
// 具体扩展类（class）与其实例对象（new 之后的，存放所有的实例）
private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>();
// ==============================
//被扩展的具体接口
private final Class<?> type;
// 当前接口对应的文件内@Adaptive标识的对象（被IOC注入过） 用于获取扩展对象
private final ExtensionFactory objectFactory;
// key:扩展类型 value: 扩展名 用于通过接口字节对象(class对象)获取其扩展名
private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<Class<?>, String>();
// 除了@Adaptive和AOP扩展类之外所有的扩展类
private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();
// 被@Activate注解修饰的扩展类 k:扩展名 v:扩展实例 eg:在获取Filter时有用到
private final Map<String, Activate> cachedActivates = new ConcurrentHashMap<String, Activate>();
// k: 扩展名, value: 包含扩展实例的 Holder对象
private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<String, Holder<Object>>();
// 持有动态扩展类的holder对象 调用getAdaptiveExtension方法才会有值
private final Holder<Object> cachedAdaptiveInstance = new Holder<Object>();
//被@Adaptive注解修饰的扩展类
private volatile Class<?> cachedAdaptiveClass = null;
// 被扩展类的@SPI注解中的value数组的第一个value[0]
private String cachedDefaultName;
//创建动态类是的异常对象
private volatile Throwable createAdaptiveInstanceError;
// 扩展类的AOP增强类
private Set<Class<?>> cachedWrapperClasses;
//加载扩展类配置文件出错的信息
private Map<String, IllegalStateException> exceptions = new ConcurrentHashMap<String, IllegalStateException>();
getAdaptiveExtension
获取动态代理类
public T getAdaptiveExtension() {
//从缓存中获取动态扩展类
Object instance = cachedAdaptiveInstance.get();
if (instance == null) {
if (createAdaptiveInstanceError == null) {
synchronized (cachedAdaptiveInstance) {
instance = cachedAdaptiveInstance.get();
if (instance == null) {
try {
//1、创建 2、放入到
instance = createAdaptiveExtension();
cachedAdaptiveInstance.set(instance);
} catch (Throwable t) {
...
}
}
}
} else {
...
}
}
return (T) instance;
}
createAdaptiveExtension
这个类用来给动态类注入属性（IOC） ，包含了@Adaptive修饰的类
private T createAdaptiveExtension() {
try {
// 给创建的动态类注入属性（IOC）
return injectExtension((T) getAdaptiveExtensionClass().newInstance());
} catch (Exception e) {
...
}
}
getAdaptiveExtensionClass 获取动态类
private Class<?> getAdaptiveExtensionClass() {
//加载动态类
getExtensionClasses();
//如果存在@Adaptive注解修饰的扩展类，直接返回（被它修饰的类是个固定的类，不需要生成动态类）
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;
}
loadExtensionClasses
用来加载指定扩展文件下，文件名与当前接口的限定名相同的文件，里面的所有扩展类
private Map<String, Class<?>> loadExtensionClasses() {
//获取接口
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
//这个if操作是将接口@SPI注解上的值赋值给cachedDefaultName
if (defaultAnnotation != null) {
String value = defaultAnnotation.value();
if ((value = value.trim()).length() > 0) {
String[] names = NAME_SEPARATOR.split(value);
if (names.length > 1) {
throw ...
}
if (names.length == 1) cachedDefaultName = names[0];
}
}
// 这个map主要用来从三个固定目录下获取 与当前接口的全限定名相同的文件里面的所有扩展类
// 比如 接口名为per.qiao.service.TestService 那么就会加载下面三个路径下的扩展类
//META-INF/services/per.qiao.service.TestService
//META-INF/dubbo/per.qiao.service.TestService
//META-INF/dubbo/internal/per.qiao.service.TestService
Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
loadDirectory(extensionClasses, DUBBO_DIRECTORY);
loadDirectory(extensionClasses, SERVICES_DIRECTORY);
return extensionClasses;
}
loadDirectory
加载一个路径下的扩展类
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir) {
String fileName = dir + type.getName();
try {
Enumeration<java.net.URL> urls;
ClassLoader classLoader = findClassLoader();
if (classLoader != null) {
urls = classLoader.getResources(fileName);
} else {
urls = ClassLoader.getSystemResources(fileName);
}
if (urls != null) {
while (urls.hasMoreElements()) {
java.net.URL resourceURL = urls.nextElement();
//加载资源
loadResource(extensionClasses, classLoader, resourceURL);
}
}
} catch (Throwable t) {
...
}
}
loadClass
加载一个文件内的扩展类, 一个接口在同一个文件里只能有一个扩展类被@Adaptive修饰
private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name) throws NoSuchMethodException {
if (!type.isAssignableFrom(clazz)) {
throw ...
}
//如果当前文件中的扩展类有@Adaptive修饰，赋值给cachedAdaptiveClass
if (clazz.isAnnotationPresent(Adaptive.class)) {
if (cachedAdaptiveClass == null) {
cachedAdaptiveClass = clazz;
} else if (!cachedAdaptiveClass.equals(clazz)) {
//如果同一文件内有多余一个的类被Adaptive修饰，抛异常;
}
} else if (isWrapperClass(clazz)) {
//如果当前扫描的类有个构造方法，并且该构造方法的参数与当前类型相同（type），保存到 cachedWrapperClasses，这里是实现AOP的一个关键点
Set<Class<?>> wrappers = cachedWrapperClasses;
if (wrappers == null) {
cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
wrappers = cachedWrapperClasses;
}
wrappers.add(clazz);
} else {
//扩展类要有无参构造
clazz.getConstructor();
//校验扩展名， 这里可以发现扩展名可以为空 即配置文件不使用key=value，学JDK直接使用value
// 那么1.该扩展类上有@Extension注解 或者2.该类的名字的末尾包含当前类的名字
// 即： 如果当前类叫 Qiao 那么该类的名字为 AbcQiao 那么这个类的扩展名就是abc
if (name == null || name.length() == 0) {
name = findAnnotationName(clazz);
if (name.length() == 0) {
throw ...
}
}
String[] names = NAME_SEPARATOR.split(name);
if (names != null && names.length > 0) {
Activate activate = clazz.getAnnotation(Activate.class);
//将被@Activate修饰的类缓存到cachedActivates中
if (activate != null) {
cachedActivates.put(names[0], activate);
}
for (String n : names) {
//将@Adaptive, AOP的Wrapper除外的其他本文件下的扩展类缓存到cachedNames
if (!cachedNames.containsKey(clazz)) {
cachedNames.put(clazz, n);
}
//将@Adaptive, AOP的Wrapper除外的其他本文件下的扩展类添加到extensionClasses（map）
Class<?> c = extensionClasses.get(n);
if (c == null) {
extensionClasses.put(n, clazz);
} else if (c != clazz) {
throw new ...
}
}
}
}
}
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);
}
