dubbo系列之内核SPI-资源解析&依赖注入(八)

前文回顾

上文中,我们了解了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源码交流群,欢迎喜欢阅读源码的朋友加群,添加下面的微信, 备注”加群“ 。

在这里插入图片描述

展开阅读全文

没有更多推荐了,返回首页