Dubbo SPI
SPI(Service Provider Interface)简单来说就是对一个接口进行扩展。可以通过服务加载的方式，获取到所有配置的实现类
一、java SPI机制
创建一个接口
public interface ILog {
void warn(String msg);
}
两个接口实现
public class ConsoleLogImpl implements ILog {
public void warn(String msg) {
System.out.println("console log" + msg + "!");
}
}
public class FileLogImpl implements ILog {
public void warn(String msg) {
System.out.println("File log" + msg + "!");
}
}
在META-INF/services路径下移ILog接口的全限定名创建文件javaspi.inter.ILog
javaspi.interimpl.ConsoleLogImpl
javaspi.interimpl.FileLogImpl
创建测试类进行测试
public class Main {
private static ServiceLoader<ILog> services = ServiceLoader.load(ILog.class);
public static void main(String[] args) {
Iterator<ILog> iterator = services.iterator();
while (iterator.hasNext()){
iterator.next().warn("Hello SPI");
}
}
}
可以看到如下的结果：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LXwLdlqR-1639122827777)(/Users/zhouzhouzhuoran/file/dubbo学习笔记/图片/javaspi生成结果.jpg)]
java SPI机制不详细分析，重点看看dubbo的SPI机制
二、dubbo SPI机制详解
与java spi机制不同的地方在于，配置文件的路径以及相应的处理类
在META-INF/dubbo路径下创建对应的ILog路径名命名的文件dubbospi.inter.ILog，配置和java原有的有一定区别
consoleLog = dubbospi.interimpl.ConsoleLogImpl
fileLog = dubbospi.interimpl.FileLogImpl
创建测试类
public class ClassMain {
public static void main(String[] args) {
ExtensionLoader<ILog> extensionLoader =
ExtensionLoader.getExtensionLoader(ILog.class);
ILog consoleLog = extensionLoader. ("consoleLog");
consoleLog.warn("a");
ILog fileLog = extensionLoader.getExtension("fileLog");
fileLog.warn("b");
}
}
结果如下：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pwFgdPLy-1639122827778)(/Users/zhouzhouzhuoran/Library/Application Support/typora-user-images/image-20211112120016936.png)]
后续对这个过程进行源码分析
三、dubbo SPI机制源码分析
第一步当然是获取扩展加载器
1、ExtensionLoader.getExtensionLoader源码分析
传入一个class对象
public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
//type类型不能为空
if (type == null)
throw new IllegalArgumentException("Extension type == null");
//type必须是接口
if (!type.isInterface()) {
throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
}
//type必须有SPI注解
if (!withExtensionAnnotation(type)) {
throw new IllegalArgumentException("Extension type(" + type +
") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
}
//EXTENSION_LOADERS：扩展名+扩展类对应的缓存
ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
//没有获取到
if (loader == null) {
//new一个
EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
}
return loader;
}
看看具体new的过程
private ExtensionLoader(Class<?> type) {
//将Class对象存入type属性
this.type = type;
//如果type是一个ExtensionFactory对象，objectFactory则存入null，否则存入ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension()
objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}
objectFactory的构造，首先是获取ExtensionFactory.class的扩展加载器，然后调用方法返回一个ExtensionFactory扩展对象，然后调用自适应扩展getAdaptiveExtension
ExtensionLoader.getExtensionLoader其实就是初始化了一个ExtensionLoader，存到EXTENSION_LOADERS中
2、extensionLoader.getExtension源码分析
此方法就是去获取指定type对应的具体实现类的对象，下面具体分析
public T getExtension(String name) {
//空判断
if (name == null || name.length() == 0)
throw new IllegalArgumentException("Extension name == null");
// 获取默认的拓展实现类
if ("true".equals(name)) {
return getDefaultExtension();
}
// Holder，顾名思义，用于持有目标对象
Holder<Object> holder = cachedInstances.get(name);
//缓存获取Holder对象，没有则构建一个
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.set(instance);
}
}
}
return (T) instance;
}
①先分析getDefaultExtension，默认实现
public T getDefaultExtension() {
getExtensionClasses();
if (null == cachedDefaultName || cachedDefaultName.length() == 0
|| "true".equals(cachedDefaultName)) {
return null;
}
return getExtension(cachedDefaultName);
}
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;
}
cachedClasses：普通扩展类缓存，不包括自适应拓展类和wrapper类
继续分析，默认创建方法
private Map<String, Class<?>> loadExtensionClasses() {
//之前存的type，获取SPI注解
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
//获取SPI注解上的默认name
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];
}
}
Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
//加载对应的类
loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
loadDirectory(extensionClasses, DUBBO_DIRECTORY);
loadDirectory(extensionClasses, SERVICES_DIRECTORY);
return extensionClasses;
}
最后调用loadDirectory方法去加载对应的class文件，加载成功后会调用getExtension方法获取对应的扩展类，loadDirectory方法后续分析
②对于不是默认实现的情况，分析createExtension这个方法
private T createExtension(String name) {
//getExtensionClasses：从配置文件中加载所有的拓展类，可得到“配置项名称”到“配置类”的映射关系表
Class<?> clazz = getExtensionClasses().get(name);
//异常处理
if (clazz == null) {
throw findException(name);
}
try {
//EXTENSION_INSTANCES:扩展类Class对象与具体实现类的缓存
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("Extension instance(name: " + name + ", class: " +
type + ") could not be instantiated: " + t.getMessage(), t);
}
}
上述方法主要做了三个事情
1、通过 getExtensionClasses 获取所有的拓展类
2、向拓展对象中注入依赖injectExtension
3、将拓展对象包裹在相应的 Wrapper 对象中
接下来，依次分析
2.1通过 getExtensionClasses 获取所有的拓展类，主要是获取class对象
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 (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];
}
}
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;
}
在上面默认构造中有分析，主要分析loadDirectory，文件加载过程,主要是从META-INF/dubbo/internal/、META-INF/dubbo/、META-INF/services/三个文件夹中获取
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir) {
//获取配置文件名
String fileName = dir + type.getName();
try {
Enumeration<java.net.URL> urls;
//获取加载器
ClassLoader classLoader = findClassLoader();
//通过 classLoader 获取所有资源链接
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加载配置文件中的每个class
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('=');
// 以等于号 = 为界，截取name和具体类名
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(interface: " + type + ", class line: " + line + ") in " + resourceURL + ", cause: " + t.getMessage(), t);
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);
}
}
逻辑很简单，就是读取配置文件的每一行的类容，对于每个name，调用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注解
if (clazz.isAnnotationPresent(Adaptive.class)) {
if (cachedAdaptiveClass == null) {
// 设置 cachedAdaptiveClass缓存
cachedAdaptiveClass = clazz;
} else if (!cachedAdaptiveClass.equals(clazz)) {
throw new IllegalStateException("More than 1 adaptive class found: "
+ cachedAdaptiveClass.getClass().getName()
+ ", " + clazz.getClass().getName());
}
//是否是Wrapper对象
//cachedWrapperClasses中缓存wapper对象
} else if (isWrapperClass(clazz)) {
Set<Class<?>> wrappers = cachedWrapperClasses;
if (wrappers == null) {
cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
wrappers = cachedWrapperClasses;
}
wrappers.add(clazz);
} else {
//获取构造器
clazz.getConstructor();
if (name == null || name.length() == 0) {
//此处如果没有设置名字，则调用findAnnotationName获取
name = findAnnotationName(clazz);
//如果还是没有，则抛出异常
if (name.length() == 0) {
throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
}
}
//name分割
String[] names = NAME_SEPARATOR.split(name);
if (names != null && names.length > 0) {
//获取Activate注解
Activate activate = clazz.getAnnotation(Activate.class);
//如果类上有 Activate 注解，则使用 names 数组的第一个元素作为键，
// 存储 name 到 Activate 注解对象的映射关系
if (activate != null) {
cachedActivates.put(names[0], activate);
}
//cachedNames：class对象与name之间的对应关系
for (String n : names) {
if (!cachedNames.containsKey(clazz)) {
cachedNames.put(clazz, n);
}
Class<?> c = extensionClasses.get(n);
//如果extensionClasses没有则直接put
if (c == null) {
extensionClasses.put(n, clazz);
//如果有了且和Class对象不一致，则报错，一个name对应了多个Class对象
} else if (c != clazz) {
throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
}
}
}
}
}
分析到这，基本可以清楚获取所有的拓展类的整个过程，此处进行一个总结：
1、设置一个缓存，从缓存获取，否则调用加载方法。
2、解析SPI注解，这个注解的value属性会被解析为name，然后去加载指定的资源文件夹
3、加载时，会对文件的每一行进行解析，去掉注释、以等号分割等（其中还有一些相关注解的解析）
4、通过全限定名以及类加载器加载创建Class对象，并存入extensionClasses中。
等号前面没有name时，获取name的方法
private String findAnnotationName(Class<?> clazz) {
com.alibaba.dubbo.common.Extension extension = clazz.getAnnotation(com.alibaba.dubbo.common.Extension.class);
if (extension == null) {
//获取其雷鸣
String name = clazz.getSimpleName();
//如果是以接口类名结尾，则截取前面的部分，如果不是，则直接返回其小写类名
if (name.endsWith(type.getSimpleName())) {
name = name.substring(0, name.length() - type.getSimpleName().length());
}
return name.toLowerCase();
}
return extension.value();
}
2.2 向拓展对象中注入依赖injectExtension
经过2.1，我们获取到了扩展类的实例，接下来主要分析下依赖注入的过程injectExtension
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) : "";
// 从 ObjectFactory 中获取依赖对象
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只支持用setter注入的方式。
2.3、创建wrapper对象
也是采用injectExtension完成实例的注入和包装
四、自适应拓展
说到自适应拓展主要是自适应拓展类Adaptive实现，实质上是一个代理类，代理的对象采用SPI加载获取。下面从源码的角度去分析。
1、自适应注解类
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Adaptive {
String[] value() default {};
}
运行时注解，可用于类和方法，有一个value值，一般用于方法上，类上只有AdaptiveCompiler 和 AdaptiveExtensionFactory，我们重点分析注解在方法上的
2、源码分析
2.1、getAdaptiveExtension方法
自适应拓展类的调用方法为getAdaptiveExtension，在getExtensionLoader方法中就有该方法的调用
public T getAdaptiveExtension() {
// 从缓存中获取自适应拓展
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方法
2.2、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);
}
}
这个方法就一行代码，但是包含三个逻辑
调用 getAdaptiveExtensionClass 方法获取自适应拓展 Class 对象
通过反射进行实例化
调用 injectExtension 方法向拓展实例中注入依赖
后面两个已经很熟悉了，主要分析getAdaptiveExtensionClass方法
顺便简单说下此处injectExtension方法的作用，Dubbo 中有两种类型的自适应拓展，一种是手工编码的，一种是自动生成的。手工编码的自适应拓展中可能存在着一些依赖，而自动生成的 Adaptive 拓展则不会依赖其他类。这里调用 injectExtension 方法的目的是为手工编码的自适应拓展注入依赖
2.3、getAdaptiveExtensionClass 方法
private Class<?> getAdaptiveExtensionClass() {
// 通过 SPI 获取所有的拓展类，前面有介绍过这个方法
getExtensionClasses();
// 检查缓存，若缓存不为空，则直接返回缓存
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
// 创建自适应拓展类
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
主要包含三个逻辑
调用 getExtensionClasses 获取所有的拓展类
检查缓存，若缓存不为空，则返回缓存
若缓存为空，则调用 createAdaptiveExtensionClass 创建自适应拓展类
getExtensionClasses 这个方法用于获取某个接口的所有实现类。比如该方法可以获取 Protocol 接口的 DubboProtocol、HttpProtocol、InjvmProtocol 等实现类。在获取实现类的过程中，如果某个实现类被 Adaptive 注解修饰了，那么该类就会被赋值给 cachedAdaptiveClass 变量。此时，上面步骤中的第二步条件成立（缓存不为空），直接返回 cachedAdaptiveClass 即可。如果所有的实现类均未被 Adaptive 注解修饰，那么执行第三步逻辑，创建自适应拓展类。相关代码如下：
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();
// 编译代码，生成 Class
return compiler.compile(code, classLoader);
}
重点是这个自适应拓展代码生成
3、自适应拓展代码生成
这个方法较长，分成几个部分分析
private String createAdaptiveExtensionClassCode() {
StringBuilder codeBuilder = new StringBuilder();
//=================method的Adaptive注解校验====================
// 通过反射获取所有的方法
Method[] methods = type.getMethods();
boolean hasAdaptiveAnnotation = false;
// 遍历方法列表
for (Method m : methods) {
// 检测方法上是否有 Adaptive 注解
if (m.isAnnotationPresent(Adaptive.class)) {
hasAdaptiveAnnotation = true;
break;
}
}
// 若所有的方法上均无 Adaptive 注解，则抛出异常
if (!hasAdaptiveAnnotation)
throw new IllegalStateException("No adaptive method on extension " + type.getName() + ", refuse to create the adaptive class!");
//========================生成类======================
// 生成 package 代码：package + type 所在包
codeBuilder.append("package ").append(type.getPackage().getName()).append(";");
// 生成 import 代码：import + ExtensionLoader 全限定名
codeBuilder.append("\nimport ").append(ExtensionLoader.class.getName()).append(";");
// 生成类代码：public class + type简单名称 + $Adaptive + implements + type全限定名 + {
codeBuilder.append("\npublic class ").append(type.getSimpleName()).append("$Adaptive").append(" implements ").append(type.getCanonicalName()).append(" {");
//以 Dubbo 的 Protocol 接口为例，生成的代码如下：
//package com.alibaba.dubbo.rpc;
//import com.alibaba.dubbo.common.extension.ExtensionLoader;
//public class Protocol$Adaptive implements com.alibaba.dubbo.rpc.Protocol {
//}
//=====================生成方法===================
for (Method method : methods) {
Class<?> rt = method.getReturnType();
Class<?>[] pts = method.getParameterTypes();
Class<?>[] ets = method.getExceptionTypes();
Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
StringBuilder code = new StringBuilder(512);
if (adaptiveAnnotation == null) {
// 如果方法上无 Adaptive 注解，则生成 throw new UnsupportedOperationException(...) 代码
code.append("throw new UnsupportedOperationException(\"method ")
.append(method.toString()).append(" of interface ")
.append(type.getName()).append(" is not adaptive method!\");");
//以 Protocol 接口的 destroy 方法为例，上面代码生成的内容如下：
//throw new UnsupportedOperationException("method public abstract void com.alibaba.dubbo.rpc.Protocol.destroy() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
} else {
int urlTypeIndex = -1;
// 遍历参数列表，确定 URL 参数位置，举例说明一下，我们要为 Protocol 接口的 refer 和 export 方法生成代理逻辑。在运行时，通过反射得到的方法定义大致如下：
//Invoker refer(Class<T> arg0, URL arg1) throws RpcException;
//Exporter export(Invoker<T> arg0) throws RpcException;
//对于 refer 方法，通过遍历 refer 的参数列表即可获取 URL 数据，这个还比较简单。对于 export 方法，获取 URL 数据则要麻烦一些。export 参数列表中没有 URL 参数，因此需要从 Invoker 参数中获取 URL 数据。获取方式是调用 Invoker 中可返回 URL 的 getter 方法，比如 getUrl。如果 Invoker 中无相关 getter 方法，此时则会抛出异常
for (int i = 0; i < pts.length; ++i) {
if (pts[i].equals(URL.class)) {
urlTypeIndex = i;
break;
}
}
//urlTypeIndex有值，说明有URL参数
if (urlTypeIndex != -1) {
// urlTypeIndex != -1，表示参数列表中存在 URL 参数
// 为 URL 类型参数生成判空代码，格式如下：
// if (arg（urlTypeIndex） == null)
// throw new IllegalArgumentException("url == null");
String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"url == null\");",
urlTypeIndex);
code.append(s);
// 为 URL 类型参数生成赋值代码，形如 URL url = arg1
s = String.format("\n%s url = arg%d;", URL.class.getName(), urlTypeIndex);
code.append(s);
}
// 参数列表中不存在 URL 类型参数
else {
String attribMethod = null;
LBL_PTS:
// 遍历方法的参数类型列表
for (int i = 0; i < pts.length; ++i) {
// 获取某一类型参数的全部方法
Method[] ms = pts[i].getMethods();
// 遍历方法列表，寻找可返回 URL 的 getter 方法
for (Method m : ms) {
String name = m.getName();
// 1. 方法名以 get 开头，或方法名大于3个字符
// 2. 方法的访问权限为 public
// 3. 非静态方法
// 4. 方法参数数量为0
// 5. 方法返回值类型为 URL
if ((name.startsWith("get") || name.length() > 3)
&& Modifier.isPublic(m.getModifiers())
&& !Modifier.isStatic(m.getModifiers())
&& m.getParameterTypes().length == 0
&& m.getReturnType() == URL.class) {
urlTypeIndex = i;
attribMethod = name;
break LBL_PTS;
}
}
}
if (attribMethod == null) {
// 如果所有参数中均不包含可返回 URL 的 getter 方法，则抛出异常
throw new IllegalStateException("fail to create adaptive class for interface " + type.getName()
+ ": not found url parameter or url attribute in parameters of method " + method.getName());
}
// 为可返回 URL 的参数生成判空代码，格式如下：
// if (arg + urlTypeIndex == null)
// throw new IllegalArgumentException("参数全限定名 + argument == null");
String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"%s argument == null\");",
urlTypeIndex, pts[urlTypeIndex].getName());
code.append(s);
// 为 getter 方法返回的 URL 生成判空代码，格式如下：
// if (argN.getter方法名() == null)
// throw new IllegalArgumentException(参数全限定名 + argument getUrl() == null);
s = String.format("\nif (arg%d.%s() == null) throw new IllegalArgumentException(\"%s argument %s() == null\");",
urlTypeIndex, attribMethod, pts[urlTypeIndex].getName(), attribMethod);
code.append(s);
// 生成赋值语句，格式如下：
// URL全限定名 url = argN.getter方法名()，比如
// com.alibaba.dubbo.common.URL url = invoker.getUrl();
s = String.format("%s url = arg%d.%s();", URL.class.getName(), urlTypeIndex, attribMethod);
code.append(s);
}
//以 Protocol 的 refer 和 export 方法为例，上面的代码为它们生成如下内容
/*refer:
if (arg1 == null)
throw new IllegalArgumentException("url == null");
com.alibaba.dubbo.common.URL url = arg1;
export:
if (arg0 == null)
throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null");
if (arg0.getUrl() == null)
throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");
com.alibaba.dubbo.common.URL url = arg0.getUrl();*/
//=================获取 Adaptive 注解值 =================
String[] value = adaptiveAnnotation.value();
// value 为空数组
if (value.length == 0) {
// 获取类名，并将类名转换为字符数组
char[] charArray = type.getSimpleName().toCharArray();
StringBuilder sb = new StringBuilder(128);
// 遍历字节数组
for (int i = 0; i < charArray.length; i++) {
// 检测当前字符是否为大写字母
if (Character.isUpperCase(charArray[i])) {
if (i != 0) {
// 向 sb 中添加点号
sb.append(".");
}
// 将字符变为小写，并添加到 sb 中
sb.append(Character.toLowerCase(charArray[i]));
} else {
// 添加字符到 sb 中
sb.append(charArray[i]);
}
}
value = new String[]{sb.toString()};
}
//上面的处理：比如 LoadBalance 经过处理后，得到 load.balance。
//================= 检测 Invocation 参数===============
boolean hasInvocation = false;
// 遍历参数类型列表
for (int i = 0; i < pts.length; ++i) {
// 判断当前参数名称是否等于 com.alibaba.dubbo.rpc.Invocation
if (pts[i].getName().equals("com.alibaba.dubbo.rpc.Invocation")) {
// 为 Invocation 类型参数生成判空代码
String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"invocation == null\");", i);
code.append(s);
// 生成 getMethodName 方法调用代码，格式为：
// String methodName = argi.getMethodName();
s = String.format("\nString methodName = arg%d.getMethodName();", i);
code.append(s);
// 设置 hasInvocation 为 true
hasInvocation = true;
break;
}
}
//=========================生成拓展名获取逻辑======================
// 设置默认拓展名，cachedDefaultName 源于 SPI 注解值，默认情况下，
// SPI 注解值为空串，此时 cachedDefaultName = null
String defaultExtName = cachedDefaultName;
String getNameCode = null;
// 遍历 value，这里的 value 是 Adaptive 的注解值，前面分析过 value 变量的获取过 程。此处循环目的是生成从 URL 中获取拓展名的代码，生成的代码会赋值给 getNameCode 变量。注意 这个循环的遍历顺序是由后向前遍历的。
for (int i = value.length - 1; i >= 0; --i) {
// 当 i 为最后一个元素的坐标时
if (i == value.length - 1){
// 默认拓展名非空
if (null != defaultExtName) {
// protocol 是 url 的一部分，可通过 getProtocol 方法获取，其他的则是从URL 参数中获取。因为获取方式不同，所以这里要判断 value[i] 是否为 protocol
if (!"protocol".equals(value[i]))
// hasInvocation 用于标识方法参数列表中是否有 Invocation 类型参数
if (hasInvocation)
// 生成的代码功能等价于下面的代码：
// url.getMethodParameter(methodName, value[i], defaultExtName)
// 以 LoadBalance 接口的 select 方法为例，最终生成的代码如下：
// url.getMethodParameter(methodName, "loadbalance", "random")
//getMethodParameter这个方法是获取url中methodName.loadbalance的值，如果没有则获取loadbalance的值，如果还没有则返回默认值
getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
else
// 生成的代码功能等价于下面的代码：
// url.getParameter(value[i], defaultExtName)
//getParameter方法返回url中value[i]的值，没有就返回defaultExtName
getNameCode = String.format("url.getParameter(\"%s\", \"%s\")", value[i], defaultExtName);
else
// 生成的代码功能等价于下面的代码：
// ( url.getProtocol() == null ? defaultExtName : url.getProtocol() )
getNameCode = String.format("( url.getProtocol() == null ? \"%s\" : url.getProtocol() )", defaultExtName);
// 默认拓展名为空
} else {
if (!"protocol".equals(value[i]))
if (hasInvocation)
// 生成代码格式同上
getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
else
// 生成的代码功能等价于下面的代码：
// url.getParameter(value[i])
getNameCode = String.format("url.getParameter(\"%s\")", value[i]);
else
// 生成从 url 中获取协议的代码，比如 "dubbo"
getNameCode = "url.getProtocol()";
}
//不是最后一个元素
} else {
if (!"protocol".equals(value[i]))
if (hasInvocation)
// 生成代码格式同上
getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
else
// 生成的代码功能等价于下面的代码：
// url.getParameter(value[i], getNameCode)
// 以 Transporter 接口的 connect 方法为例，最终生成的代码如下：
// url.getParameter("client", url.getParameter("transporter", "netty"))
getNameCode = String.format("url.getParameter(\"%s\", %s)", value[i], getNameCode);
else
// 生成的代码功能等价于下面的代码：
// url.getProtocol() == null ? getNameCode : url.getProtocol()
// 以 Protocol 接口的 connect 方法为例，最终生成的代码如下：
// url.getProtocol() == null ? "dubbo" : url.getProtocol()
getNameCode = String.format("url.getProtocol() == null ? (%s) : url.getProtocol()", getNameCode);
}
}
// 生成 extName 赋值代码
code.append("\nString extName = ").append(getNameCode).append(";");
// 生成 extName 判空代码
String s = String.format("\nif(extName == null) " +
"throw new IllegalStateException(\"Fail to get extension(%s) name from url(\" + url.toString() + \") use keys(%s)\");",
type.getName(), Arrays.toString(value));
code.append(s);
//===================生成拓展加载与目标方法调用逻辑=======================
// 生成拓展获取代码，格式如下：
// type全限定名 extension = (type全限定名)ExtensionLoader全限定名
// .getExtensionLoader(type全限定名.class).getExtension(extName);
// Tips: 格式化字符串中的 %<s 表示使用前一个转换符所描述的参数，即 type 全限定名
s = String.format("\n%s extension = (%<s)%s.getExtensionLoader(%s.class).getExtension(extName);",
type.getName(), ExtensionLoader.class.getSimpleName(), type.getName());
code.append(s);
// 如果方法返回值类型非 void，则生成 return 语句。
if (!rt.equals(void.class)) {
code.append("\nreturn ");
}
// 生成目标方法调用逻辑，格式为：
// extension.方法名(arg0, arg2, ..., argN);
s = String.format("extension.%s(", method.getName());
code.append(s);
for (int i = 0; i < pts.length; i++) {
if (i != 0)
code.append(", ");
code.append("arg").append(i);
}
code.append(");");
}
//以 Protocol 接口举例说明
//com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);
//return extension.refer(arg0, arg1);
//==============生成完整的方法
// public + 返回值全限定名 + 方法名 + (
codeBuilder.append("\npublic ").append(rt.getCanonicalName()).append(" ").append(method.getName()).append("(");
// 添加参数列表代码
for (int i = 0; i < pts.length; i++) {
if (i > 0) {
codeBuilder.append(", ");
}
codeBuilder.append(pts[i].getCanonicalName());
codeBuilder.append(" ");
codeBuilder.append("arg").append(i);
}
codeBuilder.append(")");
// 添加异常抛出代码
if (ets.length > 0) {
codeBuilder.append(" throws ");
for (int i = 0; i < ets.length; i++) {
if (i > 0) {
codeBuilder.append(", ");
}
codeBuilder.append(ets[i].getCanonicalName());
}
}
//加入方法code
codeBuilder.append(" {");
codeBuilder.append(code.toString());
codeBuilder.append("\n}");
}
//收尾}
codeBuilder.append("\n}");
//以 Protocol 的 refer 方法为例，上面代码生成的内容如下：
//public com.alibaba.dubbo.rpc.Invoker refer(java.lang.Class arg0, com.alibaba.dubbo.common.URL arg1) {
//}
if (logger.isDebugEnabled()) {
logger.debug(codeBuilder.toString());
}
return codeBuilder.toString();
}
这一部分代码比较长，总的来说就是自适应拓展类的代码拼接，可以根据注释多看几遍应该就能理解了。
第二次看完这部分，对这个代码重构做一个简单的总结：
这一部分的解析主要是针对Adaptive注解的处理，首先，这个注解的作用是返回注解value属性中设置的值在url中赋值的扩展类。什么意思呢？以Transporter接口为例
@SPI("netty")
public interface Transporter {
// @Adaptive({server, transporter})
@Adaptive({Constants.SERVER_KEY, Constants.TRANSPORTER_KEY})
Server bind(URL url, ChannelHandler handler) throws RemotingException;
// @Adaptive({client, transporter})
@Adaptive({Constants.CLIENT_KEY, Constants.TRANSPORTER_KEY})
Client connect(URL url, ChannelHandler handler) throws RemotingException;
}
如果我传入的url中有&client=xxxx，则connect方法返回的就是xxxx的扩展类。那dubbo是如何实现这个功能的呢？
首先是调用Transporter的connect方法时，实际调用的是Transporter$Adaptive类，这个类是重新构建，具体怎么构建的就是上述的过程。过程可以简单的分为几步（对上面分析进行一个总结）：
1、判断整个类的所有方法中，是否包含Adaptive注解，如果没有方法包含，则抛出异常，如果有，则进行解析。
2、package、import（此处只需要引入ExtensionLoader）、class三行
3、遍历每个方法，无Adaptive注解的，方法体为直接抛出异常
4、对于有Adaptive注解的，首先获取到URL对象，两种途径，直接从方法入参中获取，或者从所有方法的getUrl方法获取（能够返回Url对象的方法）
5、处理Adaptive注解的value值，用于匹配URL中的参数
6、判断方法参数中是否有com.alibaba.dubbo.rpc.Invocation参数
7、根据value值获取URL中的扩展对象名，并通过ExtensionLoader实例化对应的扩展类，如果方法有返回值，则会返回对应的扩展对象的实现方法
8、完成方法、异常抛出，方法参数，完成整个类的重写。
4、getActivateExtension源码分析
Activate注解主要包含了5个参数，可以定义在类和方法上
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Activate {
//调用getActivateExtension的入参group如果在注解的group，则激活
String[] group() default {};
//调用getActivateExtension的入参value匹配url得到对应的values，会激活values对应的key
//value的作用：如果value不是url中的一个key|.value不是url中的一个key，不会被激活
String[] value() default {};
//填写扩展点列表，表示那些扩展点要在本扩展点之前
String[] before() default {};
//填写扩展点列表，表示那些扩展点要在本扩展点之后
String[] after() default {};
//整型，直接的排序信息
int order() default 0;
}
首先理解下Activate注解的用法
public class Test1Filter implements Filter {
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
return null;
}
}
@Activate(group = Constants.PROVIDER,order = 2)
public class Test2Filter implements Filter {
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
return null;
}
}
@Activate(group = Constants.CONSUMER,order = 3)
public class Test3Filter implements Filter {
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
return null;
}
}
@Activate(group = {Constants.PROVIDER,Constants.CONSUMER},order = 4)
public class Test4Filter implements Filter {
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
return null;
}
}
@Activate(group = {Constants.PROVIDER,Constants.CONSUMER},order = 5,value = "test5")
public class Test5Filter implements Filter {
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
return null;
}
}
public static void main(String[] args){
ExtensionLoader extensionLoader = ExtensionLoader.getExtensionLoader(Filter.class);
URL url=new URL("","",3);
url=url.addParameter("filterValue", "test5");
//2,4
List list=extensionLoader.getActivateExtension(url,"",Constants.PROVIDER);
System.out.println(list);
//3,4
list=extensionLoader.getActivateExtension(url,"",Constants.CONSUMER);
System.out.println(list);
//3，4，5
list=extensionLoader.getActivateExtension(url,"filterValue",Constants.CONSUMER);
System.out.println(list);
}
主要看下Activate注解的调用入口getActivateExtension
//首先说明该方法的三个参数的意义：
//url：传入的URL对象（例子中的url），values：匹配url中的参数key（例子中的filterValue），group：某一个固定的key（例子中的Constants.CONSUMER、Constants.PROVIDER）
public List<T> getActivateExtension(URL url, String[] values, String group) {
List<T> exts = new ArrayList<T>();
//names包含了所有values集合
List<String> names = values == null ? new ArrayList<String>(0) : Arrays.asList(values);
//如果传入了-default参数，则所有Activate扩展点都不会被激活
if (!names.contains(Constants.REMOVE_VALUE_PREFIX + Constants.DEFAULT_KEY)) {
//加载所有扩展类
getExtensionClasses();
//cachedActivates这个在获取ExtensionLoader的时候就获取了所有扩展类名与Activate注解的map
//遍历所有存在activate注解的name
for (Map.Entry<String, Activate> entry : cachedActivates.entrySet()) {
String name = entry.getKey();
Activate activate = entry.getValue();
//如果注解上的group包含了传入的group，则需要激活该name的扩展类
if (isMatchGroup(group, activate.group())) {
//激活
T ext = getExtension(name);
//1、传入的values没有该扩展名，2、传入的values没有-name（扩展点名），3、url中有对应value，则真正添加
if (!names.contains(name)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)
&& isActive(activate, url)) {
exts.add(ext);
}
}
}
//根据order排序，before和after排序，具体排序规则可以看ActivateComparator
Collections.sort(exts, ActivateComparator.COMPARATOR);
}
//处理传入的value字段
List<T> usrs = new ArrayList<T>();
for (int i = 0; i < names.size(); i++) {
String name = names.get(i);
//-开头直接不处理，如果values传入了-name，也不进行加载
if (!name.startsWith(Constants.REMOVE_VALUE_PREFIX)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)) {
//default可以控制default之前的所有节点
if (Constants.DEFAULT_KEY.equals(name)) {
if (!usrs.isEmpty()) {
exts.addAll(0, usrs);
usrs.clear();
}
} else {
T ext = getExtension(name);
usrs.add(ext);
}
}
}
if (!usrs.isEmpty()) {
exts.addAll(usrs);
}
return exts;
}
（扩展点名），3、url中有对应value，则真正添加
if (!names.contains(name)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)
&& isActive(activate, url)) {
exts.add(ext);
}
}
}
//根据order排序，before和after排序，具体排序规则可以看ActivateComparator
Collections.sort(exts, ActivateComparator.COMPARATOR);
}
//处理传入的value字段
List usrs = new ArrayList();
for (int i = 0; i < names.size(); i++) {
String name = names.get(i);
//-开头直接不处理，如果values传入了-name，也不进行加载
if (!name.startsWith(Constants.REMOVE_VALUE_PREFIX)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)) {
//default可以控制default之前的所有节点
if (Constants.DEFAULT_KEY.equals(name)) {
if (!usrs.isEmpty()) {
exts.addAll(0, usrs);
usrs.clear();
}
} else {
T ext = getExtension(name);
usrs.add(ext);
}
}
}
if (!usrs.isEmpty()) {
exts.addAll(usrs);
}
return exts;
}
136
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
