Dubbo 源码阅读1 - SPI 扩展加载class
Dubbo的SPI扩展机制
Dubbo 并未使用 Java SPI，而是重新实现了一套功能更强的SPI机制。Dubbo SPI 的相关逻辑被封装在了 ExtensionLoader 类中，通过 ExtensionLoader，我们可以加载指定的实现类。Dubbo SPI 所需的配置文件需放置在 META-INF/dubbo 路径下，配置内容如下。
traceFilter=com.qunar.com.TraceFilter
与 Java SPI 实现类配置不同，Dubbo SPI 是通过键值对的方式进行配置，这样我们可以按需加载指定的实现类。另外，在测试 Dubbo SPI 时，需要在 Robot 接口上标注@SPI 注解。下面来演示 Dubbo SPI 的用法：
@Activate(group = "provider")
public class TraceFilter implements Filter {
private static final Logger LOGGER = LoggerFactory.getLogger(TraceFilter.class);
private static String TRACE_KEY = "traceId";
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
String key = String.format("%s-%s", invoker.getInterface().getName(), invocation.getMethodName());
LOGGER.info("monitor key", key);
Result result = new AppResponse();
try {
if (isConsumer()) {
addTraceInfoToProvider();
} else {
addTraceInfoFromConsumer();
}
} catch (Exception e) {
LOGGER.error("dubbo invoker failed: {}", e.getMessage());
}
try {
result = invoker.invoke(invocation);
} catch (RpcException e) {
if (e.isTimeout()) {
//超时异常只记录监控
LOGGER.error("dubbo出现了超时异常", e);
} else {
throw e;
}
} finally {
if (result != null
&& result.getException() instanceof RuntimeException
&& result.getException().getCause() != null
&& result.getException().getCause() instanceof InterruptedException) {
//dubbo中断异常
LOGGER.error("dubbo出现中断异常了", result.getException().getCause());
result = new AppResponse();
}
}
return result;
}
/**
* 是否consumer
*
* @return
*/
private boolean isConsumer() {
return RpcContext.getContext().isConsumerSide();
}
/**
* consumer调用此方法
* 把TraceUtils中的信息添加到dubbo的header中，供provider使用
*/
private void addTraceInfoToProvider() {
RpcContext.getContext().setAttachment(TRACE_KEY, "testKey");
}
/**
* provider调用此方法
* 把header中的traceUtils放入
*/
private void addTraceInfoFromConsumer() {
Map<String, String> attachments = RpcContext.getContext().getAttachments();
if (attachments == null || !attachments.containsKey(TRACE_KEY)) {
return;
}
String traceInfo = attachments.get(TRACE_KEY);
System.out.println("provider 获得 traceId" + traceInfo);
}
}
这是一个使用Dubbo SPI扩展加载的Trace传递过滤器，他可以在Consumer 或者 Provider端生效，当在Provider可以选择把系统当前的trace传递给下游服务提供者
Dubbo SPI扩展的源码
我们首先通过 ExtensionLoader 的 getExtensionLoader 方法获取一个 ExtensionLoader 实例，然后再通过 ExtensionLoader 的 getExtension 方法获取拓展类对象。这其中，getExtensionLoader 方法用于从缓存中获取与拓展类对应的 ExtensionLoader，若缓存未命中，则创建一个新的实例。该方法的逻辑比较简单，本章就不进行分析了。下面我们从 ExtensionLoader 的 getExtension 方法作为入口，
/**
* Find the extension with the given name. If the specified name is not found, then {@link IllegalStateException}
* will be thrown.
*/
@SuppressWarnings("unchecked")
public T getExtension(String name) {
if (StringUtils.isEmpty(name)) {
throw new IllegalArgumentException("Extension name == null");
}
// 默认的扩展实现
if ("true".equals(name)) {
return getDefaultExtension();
}
final Holder<Object> holder = getOrCreateHolder(name);
Object instance = holder.get();
// 双检锁形式
if (instance == null) {
synchronized (holder) {
instance = holder.get();
if (instance == null) {
// 创建 扩展
instance = createExtension(name);
holder.set(instance);
}
}
}
return (T) instance;
}
创建扩展点的代码如下:
@SuppressWarnings("unchecked")
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, clazz.newInstance());
instance = (T) EXTENSION_INSTANCES.get(clazz);
}
// 向实例中注入依赖
injectExtension(instance);
Set<Class<?>> wrapperClasses = cachedWrapperClasses;
if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
// 循环创建 Wrapper 实例
for (Class<?> wrapperClass : wrapperClasses) {
// 将当前 instance 作为参数传给 Wrapper 的构造方法，并通过反射创建 Wrapper 实例。
// 然后向 Wrapper 实例中注入依赖，最后将 Wrapper 实例再次赋值给 instance 变量
instance = injectExtension(
(T) wrapperClass.getConstructor(type).newInstance(instance));
}
}
return instance;
} catch (Throwable t) {
throw new IllegalStateException("...");
}
}
createExtension 方法，包含了如下的步骤：
- 通过
getExtensionClasses获取所有的拓展类 - 通过反射创建拓展对象
- 向拓展对象中注入依赖
将拓展对象包裹在相应的 Wrapper 对象中
以上步骤中，第一个步骤是加载拓展类的关键，第三和第四个步骤是 Dubbo IOC 与 AOP 的具体实现
getExtensionClasses 获取的是一个class的 Map缓存, 还是一个典型的双检锁机制
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 注解，这里的 type 变量是在调用 getExtensionLoader 方法时传入的
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
if (defaultAnnotation != null) {
String value = defaultAnnotation.value();
if ((value = value.trim()).length() > 0) {
// 对 SPI 注解内容进行切分
String[] names = NAME_SEPARATOR.split(value);
// 检测 SPI 注解内容是否合法，不合法则抛出异常
if (names.length > 1) {
throw new IllegalStateException("more than 1 default extension name on extension...");
}
// 设置默认名称，参考 getDefaultExtension 方法
if (names.length == 1) {
cachedDefaultName = names[0];
}
}
}
Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
// 加载指定文件夹下的配置文件
loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
loadDirectory(extensionClasses, DUBBO_DIRECTORY);
loadDirectory(extensionClasses, SERVICES_DIRECTORY);
return extensionClasses;
}
loadExtensionClasses 方法总共做了两件事情，一是对 SPI 注解进行解析， 这里的SPIclass 就是我们 getExtensionClassLoader 时传进来的class .
二是调用 loadDirectory 方法加载指定文件夹配置文件。这三个文件夹 分别是
META-INF/dubbo/internal , META-INF/dubbo , META-INF/services , 我们对某个接口的实现， 就是写在这三个目录里面的 .
loadDirectory 方法主要是从我们的文件里解析， key 和 impl的全路径
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir) {
// fileName = 文件夹路径 + type 全限定名
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("...");
}
}
如何加载我们的 key=xxx.xx.xxxImpl
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) {
// 加载类，并通过 loadClass 方法对类进行缓存
loadClass(extensionClasses, resourceURL,
Class.forName(line, true, classLoader), name);
}
} catch (Throwable t) {
IllegalStateException e = new IllegalStateException("Failed to load extension class...");
}
}
}
} finally {
reader.close();
}
} catch (Throwable t) {
logger.error("Exception when load extension class...");
}
}
重点就在 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("...");
}
// 检测目标类上是否有 Adaptive 注解
if (clazz.isAnnotationPresent(Adaptive.class)) {
if (cachedAdaptiveClass == null) {
// 设置 cachedAdaptiveClass缓存
cachedAdaptiveClass = clazz;
} else if (!cachedAdaptiveClass.equals(clazz)) {
throw new IllegalStateException("...");
}
// 检测 clazz 是否是 Wrapper 类型
} else if (isWrapperClass(clazz)) {
Set<Class<?>> wrappers = cachedWrapperClasses;
if (wrappers == null) {
cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
wrappers = cachedWrapperClasses;
}
// 存储 clazz 到 cachedWrapperClasses 缓存中
wrappers.add(clazz);
// 程序进入此分支，表明 clazz 是一个普通的拓展类
} else {
// 检测 clazz 是否有默认的构造方法，如果没有，则抛出异常
clazz.getConstructor();
if (name == null || name.length() == 0) {
// 如果 name 为空，则尝试从 Extension 注解中获取 name，或使用小写的类名作为 name
name = findAnnotationName(clazz);
if (name.length() == 0) {
throw new IllegalStateException("...");
}
}
// 切分 name
String[] names = NAME_SEPARATOR.split(name);
if (names != null && names.length > 0) {
Activate activate = clazz.getAnnotation(Activate.class);
if (activate != null) {
// 如果类上有 Activate 注解，则使用 names 数组的第一个元素作为键，
// 存储 name 到 Activate 注解对象的映射关系
cachedActivates.put(names[0], activate);
}
for (String n : names) {
if (!cachedNames.containsKey(clazz)) {
// 存储 Class 到名称的映射关系
cachedNames.put(clazz, n);
}
Class<?> c = extensionClasses.get(n);
if (c == null) {
// 存储名称到 Class 的映射关系
extensionClasses.put(n, clazz);
} else if (c != clazz) {
throw new IllegalStateException("...");
}
}
}
}
}
OK代码进行到这里， 我们终于从 META-INF.dubbo里面的文件，读到了我们的实现类的class。
刚才代码里， 有一个重点的地方，就是分别处理 @Activite, Wapper的时候，到底做了什么， 以及Dubbo是如何应用IOC来注入的， 这些内容，还需要研究下。 总的来说， getExtension()这部分代码，先看官方文档，知道步骤之后再来看代码， 差不多也是可以看懂的， 还可以可以debug，来看。
参考文档:
Dubbo官网