​ SPI英文全称为Service Provider Interface。它的作用就是将接口实现类的全限定名写在指定目录的配置文件中,使框架读取配置文件,从而加载实现类。这样我们就可以动态的为接口替换实现类,使得框架拓展性更高。Java其实也有原生的SPI机制,但是Dubbo并未使用它。学习Dubbo源码的前提就是得弄懂Dubbo SPI机制。

0.Java SPI示例

public interface Hello{
void sayHello();
}
public class testA implements Hello{
@Override
public void sayHello(){
System.out.println("Hello,I am A");
}
} public class testB implements Hello{
@Override
public void sayHello(){
System.out.println("Hello,I am B");
}
}

​ 写好实现类和接口后,我们需要在META-INF/services目录下新建一个文件,名称为接口Hello的全限定名。然后在文件里面写上所有实现类的全限定名,例如:

com.yelow.spi.testA
com.yelow.spi.testB

​ 测试

public class JavaSPITest{
@Test
public void sayHello() throws Exception{
ServiceLoader<Hello> serviceLoader = ServiceLoader.load(Hello.class);
serviceLoader.forEach(Hello::sayHello);
//分别输出:
//Hello,I am A
//Hello,I am B
}
}

1.Dubbo SPI示例

​ Dubbo SPI的使用上,和Java SPI类似的。先定义接口和实现类,接口前加上@SPI注解,代表一个拓展点。再创建一个配置文件。但是这个文件的路径应该在META-INF/dubbo/路径下。配置文件内容应该变成键值对形式,例如:

testA = com.yelow.spi.testA
testB = com.yelow.spi.testB

​ 最后测试方法为:

public class JavaSPITest{
@Test
public void sayHello() throws Exception{
ExtensionLoader<Hello> loader=ExtensionLoader.getExtensionLoader(Hello.class);
//按需加载,参数为配置文件中的key值
Hello testA=loader.getExtension("testA");
testA.sayHello();
//输出Hello,I am A
}
}

2.Dubbo SPI源码分析

​ 上面简单演示了Dubbo的使用方法。先通过ExtensionLoader.getExtensionLoader获取ExtensionLoader对象。在通过这个对象的getExtension方法获取实现类对象。先看一下getExtensionLoader方法:

public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
if (type == null)
throw new IllegalArgumentException("Extension type == null");
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对象
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;
}

​ getExtensionLoader方法比较简单,我们接着看一下getExtension:

public T getExtension(String name) {
if (name == null || name.length() == 0)
throw new IllegalArgumentException("Extension name == null");
if ("true".equals(name)) {
//获取默认的实现类
return getDefaultExtension();
}
//这个类用于持有目标对象,先从缓存中获取
Holder<Object> holder = cachedInstances.get(name);
if (holder == null) {
cachedInstances.putIfAbsent(name, new Holder<Object>());
holder = cachedInstances.get(name);
}
//获取实例对象
Object instance = holder.get();
//如果没有,就新建实例对象。这里是个双重检查。意义可参考单例模式
if (instance == null) {
synchronized (holder) {
instance = holder.get();
if (instance == null) {
//创建实现类实例对象
instance = createExtension(name);
//赋值到holder中
holder.set(instance);
}
}
}
return (T) instance;
}

​ 同样的,也是先检查缓存,没有缓存再新建。下面我们看一下是怎么新建实例对象的,进入到createExtension方法:

private T createExtension(String name) {
//从配置文件中获取所有实现类
Class<?> clazz = getExtensionClasses().get(name);
if (clazz == null) {
throw findException(name);
}
try {
T instance = (T) EXTENSION_INSTANCES.get(clazz);
if (instance == null) {
//通过反射创建实例
EXTENSION_INSTANCES.putIfAbsent(clazz, (T) clazz.newInstance());
instance = (T) EXTENSION_INSTANCES.get(clazz);
}
//向实例对象中注入依赖
injectExtension(instance);
Set<Class<?>> wrapperClasses = cachedWrapperClasses;
if (wrapperClasses != null && wrapperClasses.size() > 0) {
for (Class<?> wrapperClass : wrapperClasses) {
//将当前实例对象作为参数传给Wrapper的构造方法,并通过反射创建Wrapper对象
//再向wrapper实例对象中注入依赖,最后把wrapper赋值给instance
instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
}
}
return instance;
} catch (Throwable t) {
throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
type + ") could not be instantiated: " + t.getMessage(), t);
}
}

​ 上面的方法中,给instance赋值的那行代码稍微有点复杂,其实最终目的只是把实现类对象包裹在Wrapper对象中。从上面的注释看,createExtension方法的目的有四个。重点关注getExtensionClasses和injectExtension方法:

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() {
//获取SPI注解
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
if (defaultAnnotation != null) {
String value = defaultAnnotation.value();
if (value != null && (value = value.trim()).length() > 0) {
//对SPI注解的值进行拆分
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];
}
} Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
//加载指定文件夹下的配置文件
loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
loadFile(extensionClasses, DUBBO_DIRECTORY);
loadFile(extensionClasses, SERVICES_DIRECTORY);
return extensionClasses;
}

​ 我们看一下loadFile方法指定的目录常量分别是啥:

​ 可以看到,前面示例说到的目录就是在这规定的。而META-INF/services/是为了兼容Java SPI,internal/是Dubbo内部自己的拓展类配置文件。最后我们分析一下loadFile方法:

private void loadFile(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 url = urls.nextElement();
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), "utf-8"));
try {
String line = null;
//按行读取
while ((line = reader.readLine()) != null) {
//解析配置文件
//通过反射加载实现类
//操作缓存
//略。。。,最好自己debug调试一下,最清楚
} // end of while read lines
} finally {
reader.close();
}
} catch (Throwable t) {
logger.error("Exception when load extension class(interface: " +
type + ", class file: " + url + ") in " + url, t);
}
} // end of while urls
}
} catch (Throwable t) {
logger.error("Exception when load extension class(interface: " +
type + ", description file: " + fileName + ").", t);
}
}

​ 获取实现类的源码分析的差不多了,现在回到createExtension方法,接着看看injectExtension,也就是Dubbo的依赖注入功能。Dubbo IOC是通过setter方法注入依赖。它会通过反射获取实例的方法列表,再遍历方法是否具备setter方法的特征,若有就通过反射调用这个setter方法将依赖设置到目标对象中。代码分析如下:

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())) {
//获取setter方法参数类型
Class<?> pt = method.getParameterTypes()[0];
try {
//获取熟悉名,比如setName,其对应的属性应该是name
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) {
//通过反射调用setter方法完成依赖注入
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;
}

Dubbo SPI源码解析①的更多相关文章

  1. Dubbo源码解析之SPI(一):扩展类的加载过程

    Dubbo是一款开源的.高性能且轻量级的Java RPC框架,它提供了三大核心能力:面向接口的远程方法调用.智能容错和负载均衡,以及服务自动注册和发现. Dubbo最早是阿里公司内部的RPC框架,于 ...

  2. 第零章 dubbo源码解析目录

    第一章 第一个dubbo项目 第二章  dubbo内核之spi源码解析 2.1  jdk-spi的实现原理 2.2 dubbo-spi源码解析 第三章 dubbo内核之ioc源码解析 第四章 dubb ...

  3. dubbo源码解析-spi(4)

    前言 本篇是spi的第四篇,本篇讲解的是spi中增加的AOP,还是和上一篇一样,我们先从大家熟悉的spring引出AOP. AOP是老生常谈的话题了,思想都不会是一蹴而就的.比如架构设计从All in ...

  4. dubbo源码解析-spi(3)

    前言 在上一篇的末尾,我们提到了dubbo的spi中增加了IoC和AOP的功能.那么本篇就讲一下这个增加的IoC,spi部分预计会有四篇,因为这东西实在是太重要了.温故而知新,我们先来回顾一下,我们之 ...

  5. dubbo源码解析-spi(一)

    前言 虽然标题是dubbo源码解析,但是本篇并不会出现dubbo的源码,本篇和之前的dubbo源码解析-简单原理.与spring融合一样,为dubbo源码解析专题的知识预热篇. 插播面试题 你是否了解 ...

  6. Dubbo源码(二) - SPI源码

    前情提要 假设你已经知道Dubbo SPI的使用方式,不知道的请出门左转: Dubbo源码(一) - SPI使用 Dubbo源码地址: apache/dubbo 本文使用版本:2.6.x 测试Demo ...

  7. dubbo源码解析五 --- 集群容错架构设计与原理分析

    欢迎来我的 Star Followers 后期后继续更新Dubbo别的文章 Dubbo 源码分析系列之一环境搭建 博客园 Dubbo 入门之二 --- 项目结构解析 博客园 Dubbo 源码分析系列之 ...

  8. Dubbo 源码解析四 —— 负载均衡LoadBalance

    欢迎来我的 Star Followers 后期后继续更新Dubbo别的文章 Dubbo 源码分析系列之一环境搭建 Dubbo 入门之二 --- 项目结构解析 Dubbo 源码分析系列之三 -- 架构原 ...

  9. 第四章 dubbo内核之aop源码解析

    ExtensionLoader<Protocol> loader = ExtensionLoader.getExtensionLoader(Protocol.class); final P ...

随机推荐

  1. 三. Vue组件化

    1. 认识组件化 1.1 什么是组件化 人面对复杂问题的处理方式 任何一个人处理信息的逻辑能力都是有限的,所以当面对一个非常复杂的问题时我们不太可能一次性搞定一大堆的内容. 但是我们人有一种天生的能力 ...

  2. 为k8s预留系统资源

    为k8s预留系统资源 Kubernetes 的节点可以按照 Capacity 调度.默认情况下 pod 能够使用节点全部可用容量. 这是个问题,因为节点自己通常运行了不少驱动 OS 和 Kuberne ...

  3. lambda表达式中无法抛出受检异常!

    抛出受检异常的时候,我们的接口应该带上throw关键字,但通过lambda表达式实现的Consumer的accept方法并不带有关键字,因此在lambda表达式中不能抛出受检异常必须把它吃掉

  4. 40 张图带你搞懂 TCP 和 UDP

    前言 欢迎阅读「程序员cxuan」 的文章,从今往后,你就是我的读者了. 我的 github bestJavaer 已经收录此文章,目录在 https://github.com/crisxuan/be ...

  5. 如何测试一个APP

    1.是否支持各种手机系统 2.是否会因为分辨率而出错 3.不同机型能否安装 4.老旧机型 能否通用 5.广告时长 6.测试能否登陆注册 7.卸载时是否会发生意外 8.安装时会不会误认为带病毒 9.用户 ...

  6. Alpha冲刺-第四次冲刺笔记

    Alpha冲刺-冲刺笔记 这个作业属于哪个课程 https://edu.cnblogs.com/campus/fzzcxy/2018SE2 这个作业要求在哪里 https://edu.cnblogs. ...

  7. 使用paho的MQTT时遇到的重连导致订阅无法收到问题和解决

    最近在使用MQTT来实现消息的传输,网上demo很多,这里就不在重复介绍了,直接上代码,百度就能出现一大堆 下面是MQTT实现订阅的主要代码部分 MqttClient client = new Mqt ...

  8. 数据库事务ACID/隔离级别

    参考博客 1. 事务的定义 事务是用户定义的一个数据库操作序列.这些操作要么全执行,要么全不执行,是一个不可分割的工作单元.在关系型数据库中,事务可以是一条SQL语句,也可以是一组SQL语句或整个程序 ...

  9. 基于gRPC的注册发现与负载均衡的原理和实战

    gRPC是一个现代的.高性能.开源的和语言无关的通用RPC框架,基于HTTP2协议设计,序列化使用PB(Protocol Buffer),PB是一种语言无关的高性能序列化框架,基于HTTP2+PB保证 ...

  10. Djang项目部署之sqlite版本升级

    项目环境: centos7 django 2.2.10 问题描述: 使用了django 2.2.12版本开发项目,此版本对应的sqlite需要升级为3.8.0以上. 百度了不少解决方案,缺点:过程繁琐 ...