Dubbo自适应拓展学习笔记
关于阅读开源代码的一些想法
在编写本文前，其实已经写了一篇关于Dubbo 自适应拓展特性的草稿，但是通篇写下来，所做的也不过是copy-write的过程，这样的文章对于我来说，又有什么意义呢？
尽管我多次想编写一篇详尽有效的文档，试图如同大神一样去理清Dubbo源码的脉络，但是深入其间才发现力有所不逮。因此便重新把那篇文章给删了，推倒重来，将阅读人群从别人转向自己。
这样一来，就变得清晰简单的许多。我只需要问自己以下几个问题，便能得到我想要的东西：
- 你最想了解的时Dubbo的哪个特性？
- 基于这个特性如果让你来实现，你会怎么实现？遇到哪些问题？
- 你无法解决的问题别人的解决思路是什么？
- 里面最有价值的算法或者思路是什么？
只要能解决这些问题，那么对于我来说，就是大有收获，至于别人的收获，又与我何干？
我最想了解Dubbo的哪个特性？
Dubbo的特性很多，如果一股脑的写成一篇文章，那么势必陷入僵局。围绕Dubbo一系列的特性，本文只针对Dubbo的自适应扩展与SPI部分进行解析。
那么这里顺带一提Dubbo的自适应扩展是什么?
一般情况下，Dubbo都通过SPI进行拓展，但对于有些拓展，希望在拓展方法被调用时，才灵活地根据运行时参数进行加载对应的拓展。这时候我们就称之为自适应拓展，其实就是动态拓展。
这里直接拿官网的例子来进行理解：
public interface WheelMaker {
Wheel makeWheel(URL url);
}
//WheelMaker 接口的自适应实现类如下：
public class AdaptiveWheelMaker implements WheelMaker {
public Wheel makeWheel(URL url) {
if (url == null) {
throw new IllegalArgumentException("url == null");
}
// 1.从 URL 中获取 WheelMaker 名称
String wheelMakerName = url.getParameter("Wheel.maker");
if (wheelMakerName == null) {
throw new IllegalArgumentException("wheelMakerName == null");
}
// 2.通过 SPI 加载具体的 WheelMaker
WheelMaker wheelMaker = ExtensionLoader
.getExtensionLoader(WheelMaker.class).getExtension(wheelMakerName);
// 3.调用目标方法
return wheelMaker.makeWheel(URL url);
}
}
从上面可以看出，实际的服务实现是通过URL远程传过来的参数来动态获取的，这也就是自适应拓展。区别于直接采用SPI进行拓展加载，采用这样的方式会更加灵活。
基于这个特性如果让你来实现，你会怎么实现？遇到哪些问题？
那么解决完我想要学习什么特性的问题，第二个问题，我们姑且先不要急着去看Dubbo的实现原理，我们可以闭着眼睛，想假如是我们自己去实现，我们会怎么实现，以及遇到哪些问题？
- 1.采用什么方式去标记需要动态拓展的方法？
- 2.由于框架的开发者是不应该去关注业务以及具体业务的实现，但是又一定程度的需要将调用拦截下来，做一定的路由引导，这时候就应该要有一层简单的代理。但是由于服务的多样性以及灵活性，只能采用动态代理的方式去实现包装。那么会采用什么技术去实现动态代理？
- 假设我们已经选定了动态代理了，那么我们需要构建代理方法的相关代码，如何去构建一个完整的代理方法，分几部分，其中需要注意些什么？
当然我们并没有真正自己亲手去实现这个功能，我们不过是围绕这个特性或者这个问题，即如何动态地通过参数去适配到对应的实现方法去？（其实最low的方法就是if else），基于这个问题，我们展开了一系列的探讨。
ok，我们已经粗略地想了下这个实现过程了，乍一看，就两个点我们需要关注的：
（1）是否真的如我们所想采用了动态代理的方式？如果是，采用了哪些动态代理的技术？引申开来，当前有哪些具体的动态代理技术？他们的优缺点是什么？
（2）构建一个完整的代理方法的细节有哪些？
带着以下问题，我们开始去解剖代码。
你无法解决的问题别人的解决思路是什么？里面最有价值的算法或者思路是什么？
当然我们不可能一下子扎入到源码当中，源码是汪洋大海啊，我们得找一个路标，那就是Dubbo的官网源码导读了，它是怎么说明这个问题的解决方案的呢？
自适应拓展机制的实现逻辑比较复杂，首先 Dubbo 会为拓展接口生成具有代理功能的代码。然后通过 javassist 或 jdk 编译这段代码，得到 Class 类。最后再通过反射创建代理类
有了这个路标，我们就可以比较快捷地把握住源码的方向了。Dubbo本身提供了一系列丰富的Demo，我们可以通过已经有的Demo进行源码解读。
Demo见dubbo-common ExtensionLoader_Adaptive_Test测试类
@Test
public void test_getAdaptiveExtension_defaultAdaptiveKey() throws Exception {
{
SimpleExt ext = ExtensionLoader.getExtensionLoader(SimpleExt.class).getAdaptiveExtension();
Map map = new HashMap();
URL url = new URL("p1", "1.2.3.4", 1010, "path1", map);
String echo = ext.echo(url, "haha");
assertEquals("Ext1Impl1-echo", echo);
}
{
SimpleExt ext = ExtensionLoader.getExtensionLoader(SimpleExt.class).getAdaptiveExtension();
Map map = new HashMap();
map.put("simple.ext", "impl2");
URL url = new URL("p1", "1.2.3.4", 1010, "path1", map);
String echo = ext.echo(url, "haha");
assertEquals("Ext1Impl2-echo", echo);
}
}
SimpleExt类
/**
* Simple extension, has no wrapper
*/
@SPI("impl1")
public interface SimpleExt {
// @Adaptive example, do not specify a explicit key.
@Adaptive
String echo(URL url, String s);
@Adaptive({"key1", "key2"})
String yell(URL url, String s);
// no @Adaptive
String bang(URL url, int i);
}
SimpleExtImpl1
public class SimpleExtImpl1 implements SimpleExt {
public String echo(URL url, String s) {
return "Ext1Impl1-echo";
}
public String yell(URL url, String s) {
return "Ext1Impl1-yell";
}
public String bang(URL url, int i) {
return "bang1";
}
}
SimpleExtImp2
public class SimpleExtImpl2 implements SimpleExt {
public String echo(URL url, String s) {
return "Ext1Impl2-echo";
}
public String yell(URL url, String s) {
return "Ext1Impl2-yell";
}
public String bang(URL url, int i) {
return "bang2";
}
}
以上是Dubbo简单的一个Demo。
我并不打算一点一点断点跟进去这个源码，然后一点一点的复制粘贴，上一篇的草稿就是这么写，但是写下来发现，值得我回味的源码并不是太多，况且官方文档的说明已经是十分详尽了，重复一次，意义不大。
我只想分享我在里面觉得有用的东西。
整个自适应拓展的实现其实就三步：
- 生成代理功能代码
- 通过javassit或者jdk编译代码，得到Class类
- 反射创建代理类
1.如何生成代理方法
生成代理方法功能，很冗长的东西，但是其实就是根据参数自行构建代理代码的字符，本质上就是个苦力活，无非就是将构建过程拆解成几步：
- 创建package信息
- 创建import信息
- 创建类声明信息
- 构建自适应代理方法
/**
* generate and return class code
*/
public String generate() {
// no need to generate adaptive class since there's no adaptive method found.
if (!hasAdaptiveMethod()) {
throw new IllegalStateException("No adaptive method exist on extension " + type.getName() + ", refuse to create the adaptive class!");
}
StringBuilder code = new StringBuilder();
code.append(generatePackageInfo());
code.append(generateImports());
code.append(generateClassDeclaration());
Method[] methods = type.getMethods();
for (Method method : methods) {
code.append(generateMethod(method));
}
code.append("}");
if (logger.isDebugEnabled()) {
logger.debug(code.toString());
}
return code.toString();
}
源码的实现还是比较简洁明了的，也比较冗长。如果说需要稍微值得关注的，那么就是构建自适应代理方法这一块可以稍微重点看看。
其实一个方法的构建也不外乎包括几个部分：返回，形参，异常抛出以及方法名称等。围绕这几部分，构建起来也算是不难。
/**
* generate method invocation statement and return it if necessary
*/
private String generateReturnAndInvocation(Method method) {
String returnStatement = method.getReturnType().equals(void.class) ? "" : "return ";
String args = Arrays.stream(method.getParameters()).map(Parameter::getName).collect(Collectors.joining(", "));
return returnStatement + String.format("extension.%s(%s);\n", method.getName(), args);
}
依然是那句话，构建代理方法，并不算是什么多么高大上的事情，就是一个苦力活，但是大神在写这些代码的时候总是尽量简洁，这一点的确是值得学习的。特别是最新版的dubbo源码，能一句话解决的，大神绝对不啰嗦。
很多地方都直接用类似一句代码形式就完成一个功能
/**
* generate package info
*/
private String generatePackageInfo() {
return String.format(CODE_PACKAGE, type.getPackage().getName());
}
构建完整个代码的模板大概就是这样：
package org.apache.dubbo.common.extension.ext1;
import org.apache.dubbo.common.extension.ExtensionLoader;
public class SimpleExt$Adaptive implements org.apache.dubbo.common.extension.ext1.SimpleExt {
public java.lang.String yell(org.apache.dubbo.common.URL arg0, java.lang.String arg1) {
if (arg0 == null) throw new IllegalArgumentException("url == null");
org.apache.dubbo.common.URL url = arg0;
String extName = url.getParameter("key1", url.getParameter("key2", "impl1"));
if (extName == null)
throw new IllegalStateException("Failed to get extension (org.apache.dubbo.common.extension.ext1.SimpleExt) name from url (" + url.toString() + ") use keys([key1, key2])");
org.apache.dubbo.common.extension.ext1.SimpleExt extension = (org.apache.dubbo.common.extension.ext1.SimpleExt) ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.extension.ext1.SimpleExt.class).getExtension(extName);
return extension.yell(arg0, arg1);
}
public java.lang.String echo(org.apache.dubbo.common.URL arg0, java.lang.String arg1) {
if (arg0 == null) throw new IllegalArgumentException("url == null");
org.apache.dubbo.common.URL url = arg0;
String extName = url.getParameter("simple.ext", "impl1");
if (extName == null)
throw new IllegalStateException("Failed to get extension (org.apache.dubbo.common.extension.ext1.SimpleExt) name from url (" + url.toString() + ") use keys([simple.ext])");
org.apache.dubbo.common.extension.ext1.SimpleExt extension = (org.apache.dubbo.common.extension.ext1.SimpleExt) ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.extension.ext1.SimpleExt.class).getExtension(extName);
return extension.echo(arg0, arg1);
}
public java.lang.String bang(org.apache.dubbo.common.URL arg0, int arg1) {
throw new UnsupportedOperationException("The method public abstract java.lang.String org.apache.dubbo.common.extension.ext1.SimpleExt.bang(org.apache.dubbo.common.URL,int) of interface org.apache.dubbo.common.extension.ext1.SimpleExt is not adaptive method!");
}
}
当整个构建完代理代码后，就可以采用javassist或者jdk去编译了
private Class createAdaptiveExtensionClass() {
String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
ClassLoader classLoader = findClassLoader();
org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
return compiler.compile(code, classLoader);
}
2.如何采用javassist或者jdk编译代码
看这一块的源码，依然秉持着带着问题去理解源码，同时我们要时刻把握住我们究竟不懂什么，要去学习什么。
在这里能学到的东西无非两样：
- 什么是javassist?
- 怎么去用它或者他们？
- 使用它的其他场景是什么？
我们心里揣着这些问题，姑且往下继续看看，咱们还是拿dubbo的demo代码来看，简单快捷，经济实惠。
JavassistCompileTest
@Test
public void testCompileJavaClass() throws Exception {
JavassistCompiler compiler = new JavassistCompiler();
Class clazz = compiler.compile(getSimpleCode(), JavassistCompiler.class.getClassLoader());
// Because javassist compiles using the caller class loader, we should't use HelloService directly
Object instance = clazz.newInstance();
Method sayHello = instance.getClass().getMethod("sayHello");
Assertions.assertEquals("Hello world!", sayHello.invoke(instance));
}
无论是javassistCompile和jdkCompile继承抽象类AbstractCompile类
里面具体的步骤如下：
- 正则匹配拿到当前的包名
- 正则匹配拿到类名
- 通过报名和类名拼装成全限定类名
- 用Class.forName的方式尝试获取对应的类
- 如果没有，则采用javassist和jdk去编译代码
package org.apache.dubbo.common.compiler.support;
import org.apache.dubbo.common.compiler.Compiler;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Abstract compiler. (SPI, Prototype, ThreadSafe)
*/
public abstract class AbstractCompiler implements Compiler {
private static final Pattern PACKAGE_PATTERN = Pattern.compile("package\\s+([$_a-zA-Z][$_a-zA-Z0-9\\.]*);");
private static final Pattern CLASS_PATTERN = Pattern.compile("class\\s+([$_a-zA-Z][$_a-zA-Z0-9]*)\\s+");
@Override
public Class compile(String code, ClassLoader classLoader) {
code = code.trim();
Matcher matcher = PACKAGE_PATTERN.matcher(code);
String pkg;
if (matcher.find()) {
pkg = matcher.group(1);
} else {
pkg = "";
}
matcher = CLASS_PATTERN.matcher(code);
String cls;
if (matcher.find()) {
cls = matcher.group(1);
} else {
throw new IllegalArgumentException("No such class name in " + code);
}
String className = pkg != null && pkg.length() > 0 ? pkg + "." + cls : cls;
try {
return Class.forName(className, true, org.apache.dubbo.common.utils.ClassUtils.getCallerClassLoader(getClass()));
} catch (ClassNotFoundException e) {
if (!code.endsWith("}")) {
throw new IllegalStateException("The java code not endsWith \"}\", code: \n" + code + "\n");
}
try {
return doCompile(className, code);
} catch (RuntimeException t) {
throw t;
} catch (Throwable t) {
throw new IllegalStateException("Failed to compile class, cause: " + t.getMessage() + ", class: " + className + ", code: \n" + code + "\n, stack: " + ClassUtils.toString(t));
}
}
}
protected abstract Class doCompile(String name, String source) throws Throwable;
}
javassist和jdkcompile具体实现doCompile的方法。
JavassistCompile.java
private static final Pattern IMPORT_PATTERN = Pattern.compile("import\\s+([\\w\\.\\*]+);\n");
private static final Pattern EXTENDS_PATTERN = Pattern.compile("\\s+extends\\s+([\\w\\.]+)[^\\{]*\\{\n");
private static final Pattern IMPLEMENTS_PATTERN = Pattern.compile("\\s+implements\\s+([\\w\\.]+)\\s*\\{\n");
private static final Pattern METHODS_PATTERN = Pattern.compile("\n(private|public|protected)\\s+");
private static final Pattern FIELD_PATTERN = Pattern.compile("[^\n]+=[^\n]+;");
@Override
public Class doCompile(String name, String source) throws Throwable {
CtClassBuilder builder = new CtClassBuilder();
builder.setClassName(name);
// process imported classes
Matcher matcher = IMPORT_PATTERN.matcher(source);
while (matcher.find()) {
builder.addImports(matcher.group(1).trim());
}
// process extended super class
matcher = EXTENDS_PATTERN.matcher(source);
if (matcher.find()) {
builder.setSuperClassName(matcher.group(1).trim());
}
// process implemented interfaces
matcher = IMPLEMENTS_PATTERN.matcher(source);
if (matcher.find()) {
String[] ifaces = matcher.group(1).trim().split("\\,");
Arrays.stream(ifaces).forEach(i -> builder.addInterface(i.trim()));
}
// process constructors, fields, methods
String body = source.substring(source.indexOf('{') + 1, source.length() - 1);
String[] methods = METHODS_PATTERN.split(body);
String className = ClassUtils.getSimpleClassName(name);
Arrays.stream(methods).map(String::trim).filter(m -> !m.isEmpty()).forEach(method -> {
if (method.startsWith(className)) {
builder.addConstructor("public " + method);
} else if (FIELD_PATTERN.matcher(method).matches()) {
builder.addField("private " + method);
} else {
builder.addMethod("public " + method);
}
});
// compile
ClassLoader classLoader = org.apache.dubbo.common.utils.ClassUtils.getCallerClassLoader(getClass());
CtClass cls = builder.build(classLoader);
return cls.toClass(classLoader, JavassistCompiler.class.getProtectionDomain());
}
JdkCompile.java
@Override
public Class doCompile(String name, String sourceCode) throws Throwable {
int i = name.lastIndexOf('.');
String packageName = i < 0 ? "" : name.substring(0, i);
String className = i < 0 ? name : name.substring(i + 1);
JavaFileObjectImpl javaFileObject = new JavaFileObjectImpl(className, sourceCode);
javaFileManager.putFileForInput(StandardLocation.SOURCE_PATH, packageName,
className + ClassUtils.JAVA_EXTENSION, javaFileObject);
Boolean result = compiler.getTask(null, javaFileManager, diagnosticCollector, options,
null, Arrays.asList(javaFileObject)).call();
if (result == null || !result) {
throw new IllegalStateException("Compilation failed. class: " + name + ", diagnostics: " + diagnosticCollector);
}
return classLoader.loadClass(name);
}
以上则是javassist在dubbo自适应拓展的简单应用。
Javassist是什么？
javassist是什么？javassist的官网有给出定义：javassist官网
Javassist (Java Programming Assistant) makes Java bytecode manipulation simple. It is a class library for editing bytecodes in Java; it enables Java programs to define a new class at runtime and to modify a class file when the JVM loads it. Unlike other similar bytecode editors, Javassist provides two levels of API: source level and bytecode level.
简单地说，javassist就是一款用java语言操作字节码的类库。它可以：
- 在运行时定义以及加载一个新的类
- 在JVM加载时修改class文件
相比较其他的字节码操作类库，它提供了两种方式的API:
- 源码级别
- 字节码级别
具体的Javassist API操作可以参考Javassist帮助手册中文版