1. Dubbo 的 AOP 源码解析
Dubbo 的 AOP 是对 SPI 扩展类进行增强的方式，而 Wrapper 机制就是对 SPI 扩展类的增强。不同 SPI 的不同 Wrapper，其增强的功能不同。为了方便大家的理解，我们就以前面在学习“Wrapper 机制”时写的代码 15-wrapper 为例进行源码解析，来查看扩展类是如何被包装起来的。
1.1 找到 AOP 源码
15-wrapper中配置文件内容：
META-INF/dubbo/internal/com.abc.spi.Order
alipay=com.abc.spi.extension.AlipayOrder
wechat=com.abc.spi.extension.WeChatOrder
wrapper=com.abc.spi.extension.OrderWrapper
wrapper2=com.abc.spi.extension.OrderWrapper2
15-wrapper中我们写的测试类：
public class WrapperTest {
public static void main(String[] args) {
ExtensionLoader<Order> loader = ExtensionLoader.getExtensionLoader(Order.class);
Order adaptiveExtension = loader.getAdaptiveExtension();
URL url = URL.valueOf("xxx://localhost/ooo");
System.out.println(adaptiveExtension.pay(url));
}
}
我们跟adaptiveExtension.pay方法，在这个例子中Order接口我们没有实现它的Adaptive类，所以这个adaptiveExtension是动态生成的：
public class Order$Adaptive implements Order {
public String pay(org.apache.dubbo.common.URL arg0) {
if (arg0 == null) throw new IllegalArgumentException("url == null");
org.apache.dubbo.common.URL url = arg0;
String extName = url.getParameter("order", "alipay");
if(extName == null) throw new IllegalStateException("Failed to get extension (com.abc.spi.Order) name from url (" + url.toString() + ") use keys([order])");
Order extension = (Order) ExtensionLoader.getExtensionLoader(Order.class).getExtension(extName);
return extension.pay(arg0);
}
public String way() {
throw new UnsupportedOperationException("The method public abstract java.lang.String com.abc.spi.Order.way() of interface com.abc.spi.Order is not adaptive method!");
}
}
我们接着跟ExtensionLoader.getExtensionLoader(Order.class).getExtension(extName)的getExtension方法，此时因为URL中没有order参数，所以extName是alipay：
断点：
public T getExtension(String name) {
//此时name是alipay
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) {
// 创建、setter及wrapper指定名称的扩展类实例
instance = createExtension(name);
holder.set(instance);
}
}
}
return (T) instance;
}
可以看到这边代码都是之前跟过的，继续跟createExtension：
private T createExtension(String name) {
// getExtensionClasses() 获取到当前type的所有扩展类(不包含adaptive与wrapper)
// 获取指定功能性扩展名所对应的扩展类
Class<?> clazz = getExtensionClasses().get(name); // 此时Class就是AlipayOrder类
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);
}
// 调用instance的setter，完成初始化
injectExtension(instance);
// 从缓存获取当前SPI接口的所有wrapper
Set<Class<?>> wrapperClasses = cachedWrapperClasses;
if (CollectionUtils.isNotEmpty(wrapperClasses)) {
// 遍历所有wrapper，逐层包装instance
for (Class<?> wrapperClass : wrapperClasses) {
//调用wrapperClass的带参构造创建实例，并通过构造传入了扩展类(装饰模式)
//创建完成后调用wrapperClass实例的set方法进行注入完成初始化
instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
}
}
//在我们的例子中
//最终返回的instance是OrderWrapper，其封装了OrderWrapper2，
//而OrderWrapper2封装了真正的扩展类AlipayOrder
return instance;
} catch (Throwable t) {
throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
type + ") couldn't be instantiated: " + t.getMessage(), t);
}
}
断点：
1.2 调用执行
逐级返回，直至 Order$Adaptive 类，看下pay执行顺序：
进入OrderWrapper的pay方法：
进入OrderWrapper2的pay方法：
进入AlipayOrder的pay方法：
最终结果：
2. Dubbo 的动态编译 Compile 源码解析
Dubbo 支持的动态编译器有两种：JavassistCompile 与 JdkCompiler。在 Dubbo 框架中，只要是动态编译，使用的都是默认的 JavassistCompiler，而编译器 JdkCompiler 仅是让用户可以进行自由选择使用的。所以我们在这里只分析 JavassistCompile 编译器。
2.1 Javassist 简介
Javassist 是一个开源的分析、编辑和创建 Java 字节码的类库。一般情况下，对字节码文件进行修改是需要使用虚拟机指令的。而使用 Javassist，可以直接使用 java 编码的形式，而不需要了解虚拟机指令，就能动态改变类的结构，或者动态生成类。
2.2 手工实现 Javassist 动态编译 17-javassist
(1) 创建工程
创建一个 Maven 的 Java 工程。
(2) 导入依赖
仅需要一个 Javassist 依赖。
<dependencies>
<!-- javassist 依赖 -->
<dependency>
<groupId>org.javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.26.0-GA</version>
</dependency>
</dependencies>
(3) 定义 JavassistCompiler
public class JavassistCompiler {
public static void main(String[] args) throws Exception {
// 获取CtClass实例的工具类实例
ClassPool pool = ClassPool.getDefault();
// CtClass，Class Type Class
CtClass ctClass = genericClass(pool);
invokeInstance(ctClass);
}
private static CtClass genericClass(ClassPool pool) throws Exception {
// 通过pool生成一个public的com.abc.Person类的字节码类
CtClass ctClass = pool.makeClass("com.abc.Person");
// 添加private String name属性
CtField nameField = new CtField(pool.getCtClass("java.lang.String"), "name", ctClass);
nameField.setModifiers(Modifier.PRIVATE);
ctClass.addField(nameField);
// 添加private int age属性
CtField ageField = new CtField(pool.getCtClass("int"), "age", ctClass);
ageField.setModifiers(Modifier.PRIVATE);
ctClass.addField(ageField);
// 添加无参构造器
CtConstructor ctConstructor = new CtConstructor(new CtClass[] {
}, ctClass);
// 纯字符串，放入构造中
String body = "{\nname=\"zhangsan\";\nage=23;\n}";
ctConstructor.setBody(body);
ctClass.addConstructor(ctConstructor);
// 添加getter与setter
ctClass.addMethod(CtNewMethod.getter("getName", nameField));
ctClass.addMethod(CtNewMethod.setter("setName", nameField));
ctClass.addMethod(CtNewMethod.getter("getAge", ageField));
ctClass.addMethod(CtNewMethod.setter("setAge", ageField));
// 添加personInfo业务方法
CtMethod ctMethod = new CtMethod(CtClass.voidType, "personInfo", new CtClass[] {
}, ctClass);
ctMethod.setModifiers(Modifier.PUBLIC);
// 拼接方法的内容
StringBuffer sb = new StringBuffer();
sb.append("{\nSystem.out.println(\"name=\"+name);\n")
.append("System.out.println(\"age=\"+age);\n}");
ctMethod.setBody(sb.toString());
ctClass.addMethod(ctMethod);
// 把生成的字节码文件写入到d盘
byte[] bytes = ctClass.toBytecode();
File file = new File("d:/Person.class");
FileOutputStream fos = new FileOutputStream(file);
fos.write(bytes);
fos.close();
return ctClass;
}
private static void invokeInstance(CtClass ctClass)
throws Exception {
//获取类
Class<?> clazz = ctClass.toClass();
Object obj = clazz.newInstance();
obj.getClass().getMethod("personInfo", new Class[] {
}).invoke(obj, new Object[] {
});
}
}
运行结果：
生成的字节码文件对于的java内容是这样的：
public class Person {
private String name;
private int age;
public Person() {
name = "zhangsan";
age = 23;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
// 业务方法
public void personInfo() {
System.out.println("name = " + name);
System.out.println("age = " + age);
}
}
2.3 解析 Dubbo 的动态编译
下面以获取 Protocol 接口的 adaptive 扩展类实例为例进行解析。
public class ServiceConfig<T> extends AbstractServiceConfig {
...
private static final Protocol protocol = ExtensionLoader
// 加载并缓存了Protocol接口的所有扩展类(四类)
.getExtensionLoader(Protocol.class)
.getAdaptiveExtension();
...
}
很多都是跟过的：
//org.apache.dubbo.common.extension.ExtensionLoader#getAdaptiveExtension
public T getAdaptiveExtension() {
// 双重检测锁
Object instance = cachedAdaptiveInstance.get();
if (instance == null) {
if (createAdaptiveInstanceError == null) {
synchronized (cachedAdaptiveInstance) {
instance = cachedAdaptiveInstance.get();
if (instance == null) {
try {
// 创建Adaptive类实例
instance = createAdaptiveExtension();
cachedAdaptiveInstance.set(instance);
} catch (Throwable t) {
createAdaptiveInstanceError = t;
throw new IllegalStateException("Failed to create adaptive instance: " + t.toString(), t);
}
}
}
} else {
throw new IllegalStateException("Failed to create adaptive instance: " + createAdaptiveInstanceError.toString(), createAdaptiveInstanceError);
}
}
return (T) instance;
}
//org.apache.dubbo.common.extension.ExtensionLoader#createAdaptiveExtension
private T createAdaptiveExtension() {
try {
// getAdaptiveExtensionClass() 获取到当前type的adaptive类
// injectExtension() 参数中的实例，仅仅就是从配置文件中读取到的类创建的一个实例，
// 没有进行初始化。这个方法就是调用该实例的setter完成注入(初始化)
return injectExtension((T) getAdaptiveExtensionClass().newInstance());
} catch (Exception e) {
throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
}
}
关键是getAdaptiveExtensionClass方法：
//org.apache.dubbo.common.extension.ExtensionLoader#getAdaptiveExtensionClass
private Class<?> getAdaptiveExtensionClass() {
// 读取并缓存配置文件中所有的类(普通扩展类、adpative类、wrapper类、activate类)
getExtensionClasses();
// 若显式定义了adaptive类，则返回
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
// 没有显式定义adaptive类，则创建一个adaptive类
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
因为Protocol.class是没有显式定义AdaptiveClass，所以cachedAdaptiveClass 肯定是空的，走createAdaptiveExtensionClass方法：
//org.apache.dubbo.common.extension.ExtensionLoader#createAdaptiveExtensionClass
private Class<?> createAdaptiveExtensionClass() {
//AdaptiveClassCodeGenerator构造传入了接口Class以及默认的扩展名
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();
// 调用compiler的adaptive实例的compile()
return compiler.compile(code, classLoader);
}
该方法有两个流程：
- 根据SPI接口和默认扩展名，在内存中生成java文件内容
- 将java文件内容编译生成Class
(1) 根据SPI接口和默认扩展名，在内存中生成java文件内容
主要看org.apache.dubbo.common.extension.AdaptiveClassCodeGenerator#generate方法：
//org.apache.dubbo.common.extension.AdaptiveClassCodeGenerator#generate
public String generate() {
// no need to generate adaptive class since there's no adaptive method found.
// 判断当前type接口中是否存在Adaptive方法
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();
}
判断当前type接口中是否存在Adaptive方法：
//org.apache.dubbo.common.extension.AdaptiveClassCodeGenerator#hasAdaptiveMethod
private boolean hasAdaptiveMethod() {
return Arrays.stream(type.getMethods()) // 流中的每个元素都是当前type的方法
// 只要有一个匹配成功，则马上结束并返回true
.anyMatch(m -> m.isAnnotationPresent(Adaptive.class));
}
可以看出，要动态编译生成Adaptive类，则至少要有一个Adaptive方法。
整个方法都是按照字符串拼接方式，一步一步最终拼接成完整的java文件，我们只关注一个点，方法的处理，看generateMethod方法：
//org.apache.dubbo.common.extension.AdaptiveClassCodeGenerator#generateMethod
private String generateMethod(Method method) {
String methodReturnType = method.getReturnType().getCanonicalName();
String methodName = method.getName();
//主要关注方法体
String methodContent = generateMethodContent(method);
String methodArgs = generateMethodArguments(method);
String methodThrows = generateMethodThrows(method);
return String.format(CODE_METHOD_DECLARATION, methodReturnType, methodName, methodArgs, methodThrows, methodContent);
}
//org.apache.dubbo.common.extension.AdaptiveClassCodeGenerator#generateMethodContent
private String generateMethodContent(Method method) {
Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
StringBuilder code = new StringBuilder(512);
if (adaptiveAnnotation == null) {
// 这里可以看到，如果方法上没有@Adaptive标记，会生成抛异常的代码内容
// 表示不支持该操作
return generateUnsupported(method);
} else {
int urlTypeIndex = getUrlTypeIndex(method);
// found parameter in URL type
// 下面这两段代码是要找方法中的URL类型的参数
// 如果找不到是会抛异常的
// 所以Adaptive方法要求就是，方法中的参数必须
// 包含 URL 类型的参数，或参数可以获取到 URL 类型的值。
if (urlTypeIndex != -1) {
// Null Point check
code.append(generateUrlNullCheck(urlTypeIndex));
} else {
// did not find parameter in URL type
code.append(generateUrlAssignmentIndirectly(method));
}
//获取@Adaptive注解对象的value属性
//如果没有配置，默认取简单类名全小写
//例如：com.abc.spi.Order -> order
//value就是作为从URL中获取extName 的key
String[] value = getMethodAdaptiveValue(adaptiveAnnotation);
//判断方法参数中是否有org.apache.dubbo.rpc.Invocation类型的参数
boolean hasInvocation = hasInvocationArgument(method);
code.append(generateInvocationArgumentNullCheck(method));
code.append(generateExtNameAssignment(value, hasInvocation));
// check extName == null?
code.append(generateExtNameNullCheck(value));
code.append(generateExtensionAssignment());
// return statement
code.append(generateReturnAndInvocation(method));
}
return code.toString();
}
重点关注generateExtNameAssignment方法，这个方法是获取extName 的关键：
private String generateExtNameAssignment(String[] value, boolean hasInvocation) {
// TODO: refactor it
String getNameCode = null;
for (int i = value.length - 1; i >= 0; --i) {
if (i == value.length - 1) {
//判断是否有默认的defaultExtName
if (null != defaultExtName) {
if (!"protocol".equals(value[i])) {
//是否有Invocation类型的参数
if (hasInvocation) {
getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
} else {
getNameCode = String.format("url.getParameter(\"%s\", \"%s\")", value[i], defaultExtName);
}
} else {
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 {
getNameCode = String.format("url.getParameter(\"%s\")", value[i]);
}
} else {
getNameCode = "url.getProtocol()";
}
}
} else {
if (!"protocol".equals(value[i])) {
if (hasInvocation) {
getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
} else {
getNameCode = String.format("url.getParameter(\"%s\", %s)", value[i], getNameCode);
}
} else {
getNameCode = String.format("url.getProtocol() == null ? (%s) : url.getProtocol()", getNameCode);
}
}
}
return String.format(CODE_EXT_NAME_ASSIGNMENT, getNameCode);
}
这段代码看上去比较乱，总体结论就是，从URL类型的参数获取extName有三种方式
- url.getProtocol() 直接根据协议获取extName
- url.getParameter() 根据Url类型的参数获取extName（key就是@Adaptive的value指定的，没有指定就是简单类名全小写）
- url.getMethodParameter() 从本方法的参数中获取（key就是@Adaptive的value指定的，没有指定就是简单类名全小写）
以上每种方式如果根据key获取为空，如果defaultExtName不为空，则用defaultExtName。
其他方法就不看了，我们退出org.apache.dubbo.common.extension.AdaptiveClassCodeGenerator#generate方法回到createAdaptiveExtensionClass，此时查看 code 的值，其为一个字符串，其内容就是动态生成的 Adaptive 扩展类。在其上右击，选择 copy value 即可复制该字符串的内容。
(2) 将java文件内容编译生成Class
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();
// 调用compiler的adaptive实例的compile()
return compiler.compile(code, classLoader);
}
动态生成 Adaptive 代码后，就可以对其进行编译了，继续看Compiler的adaptive实例的compile()方法：
@Adaptive
public class AdaptiveCompiler implements Compiler {
private static volatile String DEFAULT_COMPILER;
public static void setDefaultCompiler(String compiler) {
DEFAULT_COMPILER = compiler;
}
@Override
public Class<?> compile(String code, ClassLoader classLoader) {
Compiler compiler;
ExtensionLoader<Compiler> loader = ExtensionLoader.getExtensionLoader(Compiler.class);
// 获取用户指定的扩展名
String name = DEFAULT_COMPILER; // copy reference
// 若用户指定了扩展名，则获取用户指定的compiler，否则获取默认的compiler
if (name != null && name.length() > 0) {
compiler = loader.getExtension(name);
} else {
// 默认的compiler，即javassistCompiler
compiler = loader.getDefaultExtension();
}
// 调用javassistCompiler的compile()
return compiler.compile(code, classLoader);
}
}
默认会走JavassistCompiler，看javassistCompiler的compile()方法，先会走其父类的抽象方法：
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();
// 从java代码code中找到package
Matcher matcher = PACKAGE_PATTERN.matcher(code);
String pkg;
if (matcher.find()) {
pkg = matcher.group(1);
} else {
pkg = "";
}
// 从java代码code中找到class类名
matcher = CLASS_PATTERN.matcher(code);
String cls;
if (matcher.find()) {
cls = matcher.group(1);
} else {
throw new IllegalArgumentException("No such class name in " + code);
}
// 用找到的package与class拼接为全限定性类名
String className = pkg != null && pkg.length() > 0 ? pkg + "." + cls : cls;
try {
// 将指定名称的类加载到内存
// 如果没有会报错
// 这里会先尝试本地加载类，加载失败报错了以后才会动态编译生成Class
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 {
// 调用javassistCompiler的doCompile()方法进行编译
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;
}
这个抽象类会先尝试本地加载类，加载失败报错了以后才会动态编译生成Class
这就是为什么我们之前把动态生成的Adaptive类的内容拷贝出来放入文件以后，程序能够正常跑
并且可以在这个类中断点的原因
我们后期分析源码的时候，会经常拷贝动态生成的自适应类出来，方便断点，原理就是这个！
现在我们看javassistCompiler的doCompile()方法：
public class JavassistCompiler extends AbstractCompiler {
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，封装了javassist(建造者模式)
CtClassBuilder builder = new CtClassBuilder();
// 初始化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());
// 通过ctClassBuilder构建出一个CtClass，即编译的实现
CtClass cls = builder.build(classLoader);
return cls.toClass(classLoader, JavassistCompiler.class.getProtectionDomain());
}
}
这个方法就不细究了。