欢迎关注公众号【sharedCode】致力于主流中间件的源码分析， 可以直接与我联系
博主个人网站：www.shared-code.com
前文回顾
上文中，我们了解了dubbo的SPI机制，针对Protocol的SPI实现讲解了一半，讲到了Protocol生成好了ExtensionLoader以及其内部的ExtensionFactory , 本文继续讲解接下来的代码，建议没看过上一篇文章的朋友可以先去看下一，直接看本文会比较懵逼 。 dubbo系列之内核SPI拓展机制初识（七）
源码入口
com.alibaba.dubbo.config.ServiceConfig
private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
getAdaptiveExtension
这个方法是为了获得Protocol的扩展实现。
public T getAdaptiveExtension() {
// 从当前ExtensionLoader的缓存中获取
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;
}
createAdaptiveExtension
private T createAdaptiveExtension() {
try {
return injectExtension((T) getAdaptiveExtensionClass().newInstance());
} catch (Exception e) {
throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
}
}
injectExtension ：该方法用于依赖注入使用，放在稍后一点讲，先讲该方法的参数(T) getAdaptiveExtensionClass().newInstance() ， 获取扩展实现类，其实主要的逻辑在getAdaptiveExtensionClass() , 后面的newInstance就是直接通过反射创建对象了。
getAdaptiveExtensionClass
private Class<?> getAdaptiveExtensionClass() {
// 资源加载，负责读取META-INF下面的扩展类文件。
getExtensionClasses();
// 缓存着的类，如果上面getExtensionClasses方法解析到了需要的类，会把
// cachedAdaptiveClass 设值，如果这里判断cachedAdaptiveClass不为空，直接返回即可，ExtensionFactory就是这么干的
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
// 通过字节码技术，创建代理对象。
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
先看dubbo是如何读取扩展类文件的。
资源解析
getExtensionClasses
private Map<String, Class<?>> getExtensionClasses() {
// cachedClasses 是否为空，不为空则说明当前的ExtensionLoader已经解析过资源文件了
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() {
// 获取当前type类里面的注解，此处在我们的例子中type= Protocol.class
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
if (defaultAnnotation != null) {
// 注解不为空，获取值
String value = defaultAnnotation.value();
if ((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];
}
}
// 解析文件后得到的class对象通过extensionClasses这个map收集起来
Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
// 解析 META-INF/dubbo/internal/
loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
// 解析 META-INF/dubbo/
loadDirectory(extensionClasses, DUBBO_DIRECTORY);
// 解析 META-INF/services/
loadDirectory(extensionClasses, SERVICES_DIRECTORY);
return extensionClasses;
}
@SPI里面的值被放置在了cachedDefaultName这个全局变量里面 ， 基于我们这个例子，这个值应该为 dubbo
cachedDefaultName = dubbo ， 这个先记住。。这个在后面通过字节码生成类会其作用的。
我们先以META-INF/dubbo/internal/为例子， 因为Protocol的扩展实现是在这个目录下面。
loadDirectory
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir) {
// file的名称，通过文件夹路径和文件名名称组成
// fileName = META-INF/dubbo/internal/ + com.alibaba.dubbo.rpc.Protocol
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) {
logger.error("Exception when load extension class(interface: " +
type + ", description file: " + fileName + ").", t);
}
}
loadResource
/*
* 参数说明：
* extensionClasses 一个map集合，用来存储
*/
private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL) {
try {
// 开启输入流，进行资源的读取
BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), "utf-8"));
try {
String line;
// 来来来，不要着急，一行一行的读
while ((line = reader.readLine()) != null) {
// 看下是否带了#号
final int ci = line.indexOf('#');
// 截取#号前面的，至于为啥会有带#号的，笔者目前没有搞清楚。
if (ci >= 0) line = line.substring(0, ci);
// 去掉空格
line = line.trim();
if (line.length() > 0) {
// 去掉空格之后不为空的。
try {
// 一个个的开始解析
String name = null;
// 通过等于号开始隔开。
int i = line.indexOf('=');
if (i > 0) {
// 名称
name = line.substring(0, i).trim();
// 类名
line = line.substring(i + 1).trim();
}
if (line.length() > 0) { // 类名大于0
// 解析类
loadClass(extensionClasses, resourceURL, Class.forName(line, true, classLoader), name);
}
} catch (Throwable t) {
IllegalStateException e = new IllegalStateException("Failed to load extension class(interface: " + type + ", class line: " + line + ") in " + resourceURL + ", cause: " + t.getMessage(), t);t5rtf
exceptions.put(line, e);
}
}
}
} finally {
reader.close();
}
} catch (Throwable t) {
logger.error("Exception when load extension class(interface: " +
type + ", class file: " + resourceURL + ") in " + resourceURL, t);
}
}
上面的代码看着很长，核心概念就三个
1.读取资源文件，一行一行开始循环
2.文件内容进行分割，key, value 进行分离。
3.拿到了class的名称，调用loadClass进行解析了。。
loadClass
private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name) throws NoSuchMethodException {
if (!type.isAssignableFrom(clazz)) {
throw new IllegalStateException("Error when load extension class(interface: " +
type + ", class line: " + clazz.getName() + "), class "
+ clazz.getName() + "is not subtype of interface.");
}
// 当前类上，是否存在@Adaptive注解，存在的话直接设置cachedAdaptiveClass，这样就可以直接拿到扩展 实现类了。
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());
}
} else if (isWrapperClass(clazz)) { // 判断这个SPI扩展是否以当前SPI接口为构造器,使用装饰器模式增强这个类
// 以扩展类接口为构造参数 ，
Set<Class<?>> wrappers = cachedWrapperClasses;
if (wrappers == null) {
cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
wrappers = cachedWrapperClasses;
}
//放入到Wrapper实现类缓存中
wrappers.add(clazz);
} else {
// 获取类的构造函数
clazz.getConstructor();
if (name == null || name.length() == 0) {
// 在资源文件中，没有名称的。
name = findAnnotationName(clazz);
if (name == null || name.length() == 0) {
if (clazz.getSimpleName().length() > type.getSimpleName().length()
&& clazz.getSimpleName().endsWith(type.getSimpleName())) {
name = clazz.getSimpleName().substring(0, clazz.getSimpleName().length() - type.getSimpleName().length()).toLowerCase();
} else {
throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
}
}
}
String[] names = NAME_SEPARATOR.split(name);
if (names != null && names.length > 0) {
// 标注了Activate注解，保存在cachedActivates属性中
Activate activate = clazz.getAnnotation(Activate.class);
if (activate != null) {
cachedActivates.put(names[0], activate);
}
for (String n : names) {
// 把扩展名称与扩展类的映射关系保存在cachedNames中
if (!cachedNames.containsKey(clazz)) {
cachedNames.put(clazz, n);
}
Class<?> c = extensionClasses.get(n);
if (c == null) {
// 把扩展名称与扩展类的映射关系保存在extensionClasses中，用于返回
extensionClasses.put(n, clazz);
} else if (c != clazz) {
throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
}
}
}
}
}
private boolean isWrapperClass(Class<?> clazz) {
try {
// 以扩展类接口为构造参数
clazz.getConstructor(type);
return true;
} catch (NoSuchMethodException e) {
return false;
}
}
有些朋友可能一看上面那么多代码，又蒙圈了，其实我也差不多，但是可以化繁为简，将逻辑流程简化，其实主要可以分为四个方面
1.把含有@Adaptive注解的对象放置到cachedAdaptiveClass属性中，方便后面直接取着用
2.当前SPI接口为构造器,使用装饰器模式增强这个类，将这个类放入wrappers缓存中
3.构造函数没有参数的，解析扩展名称，**扩展名称可以多个，使用逗号隔开 ** ， 最后放入到extensionClasses这个map中。
至此，资源算是解析完了，资源解析完了之后，回到最上面的代码中，如果cachedAdaptiveClass为空的话，就需要通过字节码技术来创建扩展实现类了。
字节码创建扩展实现类在后面会单独开一篇， 下面讲一下dubbo的SPI的中对依赖注入的扩展
依赖注入
private T createAdaptiveExtension() {
try {
// injectExtension 这个方法里面就是对依赖注入的实现。
return injectExtension((T) getAdaptiveExtensionClass().newInstance());
} catch (Exception e) {
throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
}
}
下面看一下injectExtenstion方法的实现
private T injectExtension(T instance) {
try {
// 扩展类工厂不为空。
if (objectFactory != null) {
// 缓存扩展实现类中的方法
for (Method method : instance.getClass().getMethods()) {
// 方法名 set 开头 && 参数一个 && 方法为public
if (method.getName().startsWith("set")
&& method.getParameterTypes().length == 1
&& Modifier.isPublic(method.getModifiers())) {
// 获取第一个参数
Class<?> pt = method.getParameterTypes()[0];
try {
// 通过方法名，截取属性名，setUser , 这里截取的就是user这个值。
String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
// 调用扩展类工厂，获取
Object object = objectFactory.getExtension(pt, property);
if (object != null) {
// 执行方法，调用set方法进行赋值。
method.invoke(instance, object);
}
} catch (Exception e) {
logger.error("fail to inject via method " + method.getName()
+ " of interface " + type.getName() + ": " + e.getMessage(), e);
}
}
}
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return instance;
}
说明：
上面的代码，我们不需要很复杂的去看他， 可以分成三步来看
1.获取扩展实现类的方法，并循环判断是否符合set方法的特征
2.调用扩展工厂类，获取set方法参数中的 目标类
3.调用set方法，实现依赖注入。
上面这个方法中，比较重要的角色就是objectFactory ， 这个属性我们在SPI的第一篇文章中就已经讲过，每个ExtensionLoader都有一个ExtensionFactory实例。
objectFactory 的默认实现为AdaptiveExtensionFactory , 下面看一下是如何获取目标类的实例的。 Object object = objectFactory.getExtension(pt, property);
@Override
public <T> T getExtension(Class<T> type, String name) {
// 循环该类里面的属性factories ，
for (ExtensionFactory factory : factories) {
// 调用其他工厂的方法，进行目标类的获取
T extension = factory.getExtension(type, name);
// 获取不到了，不为空
if (extension != null) {
// 直接返回
return extension;
}
}
return null;
}
factories： 该属性在实例化AdaptiveExtensionFactory 的时候，就已经对里面进行设值了。 默认该集合中含有另外两个工厂SpiExtensionFactory , SpringExtensionFactory
####SpiExtensionFactory
public class SpringExtensionFactory implements ExtensionFactory {
private static final Set<ApplicationContext> contexts = new ConcurrentHashSet<ApplicationContext>();
// 设置spring的上下文
public static void addApplicationContext(ApplicationContext context) {
contexts.add(context);
}
// 移除spring的上下文
public static void removeApplicationContext(ApplicationContext context) {
contexts.remove(context);
}
@Override
@SuppressWarnings("unchecked")
public <T> T getExtension(Class<T> type, String name) {
// 循环上下文
for (ApplicationContext context : contexts) {
// 判断容器中是否包含这个bean
if (context.containsBean(name)) {
// 通过名字来进行获取
Object bean = context.getBean(name);
if (type.isInstance(bean)) {
// 返回bean
return (T) bean;
}
}
}
return null;
}
}
SpringExtensionFactory在初始化ServiceBean ,或者ReferenceBean的时候，就对contexts进行设值，所以这个里面是有当前spring容器的上下文的，可以从里面获取spring容器中所有的bean， 达到依赖注入的目的。
SpiExtensionFactory
public class SpiExtensionFactory implements ExtensionFactory {
@Override
public <T> T getExtension(Class<T> type, String name) {
// 是否是接口 && 包含SPI注解
if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
// 获取当前type的ExtensionLoader
ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
// 当前type支持的扩展实现类不能为空
if (!loader.getSupportedExtensions().isEmpty()) {
// 获取实现类。
return loader.getAdaptiveExtension();
}
}
return null;
}
}
SpiExtensionFactory的作用就是为了注入那些其他需要扩展的类，用于扩展实现类的注入
总结： dubbo的SPI的依赖注入支持两种
1.spring容器中的bean
2.其他扩展实现类。
欢迎关注公众号【sharedCode】致力于主流中间件的源码分析， 可以直接与我联系
博主个人网站：www.shared-code.com
