2.2 自适应拓展类代码生成

createAdaptiveExtensionClassCode 方法代码略多，约有两百行代码。因此本节将会对该方法的代码进行拆分分析，以帮助大家更好的理解代码逻辑。

2.2.1 Adaptive 注解检测

在生成代理类源码之前，createAdaptiveExtensionClassCode 方法首先会通过反射检测接口方法是否包含 Adaptive 注解。对于要生成自适应拓展的接口，Dubbo 要求该接口至少有一个方法被 Adaptive 注解修饰。若不满足此条件，就会抛出运行时异常。相关代码如下：

  1. // 通过反射获取所有的方法
  2. Method[] methods = type.getMethods();
  3. boolean hasAdaptiveAnnotation = false;
  4. // 遍历方法列表
  5. for (Method m : methods) {
  6.     // 检测方法上是否有 Adaptive 注解
  7.     if (m.isAnnotationPresent(Adaptive.class)) {
  8.         hasAdaptiveAnnotation = true;
  9.         break;
  10.     }
  11. }
  13. if (!hasAdaptiveAnnotation)
  14.     // 若所有的方法上均无 Adaptive 注解，则抛出异常
  15.     throw new IllegalStateException("No adaptive method on extension ...");

2.2.2 生成类

通过 Adaptive 注解检测后，即可开始生成代码。代码生成的顺序与 Java 文件内容顺序一致，首先会生成 package 语句，然后生成 import 语句，紧接着生成类名等代码。整个逻辑如下：

  1. // 生成 package 代码：package + type 所在包
  2. codeBuilder.append("package ").append(type.getPackage().getName()).append(";");
  3. // 生成 import 代码：import + ExtensionLoader 全限定名
  4. codeBuilder.append("\nimport ").append(ExtensionLoader.class.getName()).append(";");
  5. // 生成类代码：public class + type简单名称 + $Adaptive + implements + type全限定名 + {
  6. codeBuilder.append("\npublic class ")
  7.     .append(type.getSimpleName())
  8.     .append("$Adaptive")
  9.     .append(" implements ")
  10.     .append(type.getCanonicalName())
  11.     .append(" {");
  13. // ${生成方法}
  15. codeBuilder.append("\n}");

这里使用 ${…} 占位符代表其他代码的生成逻辑，该部分逻辑将在随后进行分析。上面代码不是很难理解，下面直接通过一个例子展示该段代码所生成的内容。以 Dubbo 的 Protocol 接口为例，生成的代码如下：

  1. package com.alibaba.dubbo.rpc;
  2. import com.alibaba.dubbo.common.extension.ExtensionLoader;
  3. public class Protocol$Adaptive implements com.alibaba.dubbo.rpc.Protocol {
  4.     // 省略方法代码
  5. }

2.2.3 生成方法

一个方法可以被 Adaptive 注解修饰，也可以不被修饰。这里将未被 Adaptive 注解修饰的方法称为“无 Adaptive 注解方法”，下面我们先来看看此种方法的代码生成逻辑是怎样的。

2.2.3.1 无 Adaptive 注解方法代码生成逻辑

对于接口方法，我们可以按照需求标注 Adaptive 注解。以 Protocol 接口为例，该接口的 destroy 和 getDefaultPort 未标注 Adaptive 注解，其他方法均标注了 Adaptive 注解。Dubbo 不会为没有标注 Adaptive 注解的方法生成代理逻辑，对于该种类型的方法，仅会生成一句抛出异常的代码。生成逻辑如下：

  1. for (Method method : methods) {
  3.     // 省略无关逻辑
  5.     Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
  6.     StringBuilder code = new StringBuilder(512);
  7.     // 如果方法上无 Adaptive 注解，则生成 throw new UnsupportedOperationException(...) 代码
  8.     if (adaptiveAnnotation == null) {
  9.         // 生成的代码格式如下：
  10.         // throw new UnsupportedOperationException(
  11.         //     "method " + 方法签名 + of interface + 全限定接口名 + is not adaptive method!”)
  12.         code.append("throw new UnsupportedOperationException(\"method ")
  13.             .append(method.toString()).append(" of interface ")
  14.             .append(type.getName()).append(" is not adaptive method!\");");
  15.     } else {
  16.         // 省略无关逻辑
  17.     }
  19.     // 省略无关逻辑
  20. }

以 Protocol 接口的 destroy 方法为例，上面代码生成的内容如下：

  1. throw new UnsupportedOperationException(
  2.             "method public abstract void com.alibaba.dubbo.rpc.Protocol.destroy() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
2.2.3.2 获取 URL 数据

前面说过方法代理逻辑会从 URL 中提取目标拓展的名称，因此代码生成逻辑的一个重要的任务是从方法的参数列表或者其他参数中获取 URL 数据。举例说明一下，我们要为 Protocol 接口的 refer 和 export 方法生成代理逻辑。在运行时，通过反射得到的方法定义大致如下：

  1. Invoker refer(Class<T> arg0, URL arg1) throws RpcException;
  2. Exporter export(Invoker<T> arg0) throws RpcException;

对于 refer 方法，通过遍历 refer 的参数列表即可获取 URL 数据，这个还比较简单。对于 export 方法，获取 URL 数据则要麻烦一些。export 参数列表中没有 URL 参数，因此需要从 Invoker 参数中获取 URL 数据。获取方式是调用 Invoker 中可返回 URL 的 getter 方法，比如 getUrl。如果 Invoker 中无相关 getter 方法，此时则会抛出异常。整个逻辑如下：

  1. for (Method method : methods) {
  2.     Class<?> rt = method.getReturnType();
  3.     Class<?>[] pts = method.getParameterTypes();
  4.     Class<?>[] ets = method.getExceptionTypes();
  6.     Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
  7.     StringBuilder code = new StringBuilder(512);
  8.     if (adaptiveAnnotation == null) {
  9.         // ${无 Adaptive 注解方法代码生成逻辑}
  10.     } else {
  11.         int urlTypeIndex = -1;
  12.         // 遍历参数列表，确定 URL 参数位置
  13.         for (int i = 0; i < pts.length; ++i) {
  14.             if (pts[i].equals(URL.class)) {
  15.                 urlTypeIndex = i;
  16.                 break;
  17.             }
  18.         }
  20.         // urlTypeIndex != -1，表示参数列表中存在 URL 参数
  21.         if (urlTypeIndex != -1) {
  22.             // 为 URL 类型参数生成判空代码，格式如下：
  23.             // if (arg + urlTypeIndex == null) 
  24.             //     throw new IllegalArgumentException("url == null");
  25.             String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"url == null\");",
  26.                                      urlTypeIndex);
  27.             code.append(s);
  29.             // 为 URL 类型参数生成赋值代码，形如 URL url = arg1
  30.             s = String.format("\n%s url = arg%d;", URL.class.getName(), urlTypeIndex);
  31.             code.append(s);
  33.         // 参数列表中不存在 URL 类型参数
  34.         } else {
  35.             String attribMethod = null;
  37.             LBL_PTS:
  38.             // 遍历方法的参数类型列表
  39.             for (int i = 0; i < pts.length; ++i) {
  40.                 // 获取某一类型参数的全部方法
  41.                 Method[] ms = pts[i].getMethods();
  42.                 // 遍历方法列表，寻找可返回 URL 的 getter 方法
  43.                 for (Method m : ms) {
  44.                     String name = m.getName();
  45.                     // 1. 方法名以 get 开头，或方法名大于3个字符
  46.                     // 2. 方法的访问权限为 public
  47.                     // 3. 非静态方法
  48.                     // 4. 方法参数数量为0
  49.                     // 5. 方法返回值类型为 URL
  50.                     if ((name.startsWith("get") || name.length() > 3)
  51.                         && Modifier.isPublic(m.getModifiers())
  52.                         && !Modifier.isStatic(m.getModifiers())
  53.                         && m.getParameterTypes().length == 0
  54.                         && m.getReturnType() == URL.class) {
  55.                         urlTypeIndex = i;
  56.                         attribMethod = name;
  58.                         // 结束 for (int i = 0; i < pts.length; ++i) 循环
  59.                         break LBL_PTS;
  60.                     }
  61.                 }
  62.             }
  63.             if (attribMethod == null) {
  64.                 // 如果所有参数中均不包含可返回 URL 的 getter 方法，则抛出异常
  65.                 throw new IllegalStateException("fail to create adaptive class for interface ...");
  66.             }
  68.             // 为可返回 URL 的参数生成判空代码，格式如下：
  69.             // if (arg + urlTypeIndex == null) 
  70.             //     throw new IllegalArgumentException("参数全限定名 + argument == null");
  71.             String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"%s argument == null\");",
  72.                                      urlTypeIndex, pts[urlTypeIndex].getName());
  73.             code.append(s);
  75.             // 为 getter 方法返回的 URL 生成判空代码，格式如下：
  76.             // if (argN.getter方法名() == null) 
  77.             //     throw new IllegalArgumentException(参数全限定名 + argument getUrl() == null);
  78.             s = String.format("\nif (arg%d.%s() == null) throw new IllegalArgumentException(\"%s argument %s() == null\");",
  79.                               urlTypeIndex, attribMethod, pts[urlTypeIndex].getName(), attribMethod);
  80.             code.append(s);
  82.             // 生成赋值语句，格式如下：
  83.             // URL全限定名 url = argN.getter方法名()，比如 
  84.             // com.alibaba.dubbo.common.URL url = invoker.getUrl();
  85.             s = String.format("%s url = arg%d.%s();", URL.class.getName(), urlTypeIndex, attribMethod);
  86.             code.append(s);
  87.         }
  89.         // 省略无关代码
  90.     }
  92.     // 省略无关代码
  93. }

上面代码有点多，需要耐心看一下。这段代码主要目的是为了获取 URL 数据，并为之生成判空和赋值代码。以 Protocol 的 refer 和 export 方法为例，上面的代码为它们生成如下内容（代码已格式化）：

  1. refer:
  2. if (arg1 == null) 
  3.     throw new IllegalArgumentException("url == null");
  4. com.alibaba.dubbo.common.URL url = arg1;
  6. export:
  7. if (arg0 == null) 
  8.     throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null");
  9. if (arg0.getUrl() == null) 
  10.     throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");
  11. com.alibaba.dubbo.common.URL url = arg0.getUrl();
2.2.3.3 获取 Adaptive 注解值

Adaptive 注解值 value 类型为 String[]，可填写多个值，默认情况下为空数组。若 value 为非空数组，直接获取数组内容即可。若 value 为空数组，则需进行额外处理。处理过程是将类名转换为字符数组，然后遍历字符数组，并将字符放入 StringBuilder 中。若字符为大写字母，则向 StringBuilder 中添加点号，随后将字符变为小写存入 StringBuilder 中。比如 LoadBalance 经过处理后，得到 load.balance。

  1. for (Method method : methods) {
  2.     Class<?> rt = method.getReturnType();
  3.     Class<?>[] pts = method.getParameterTypes();
  4.     Class<?>[] ets = method.getExceptionTypes();
  6.     Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
  7.     StringBuilder code = new StringBuilder(512);
  8.     if (adaptiveAnnotation == null) {
  9.         // ${无 Adaptive 注解方法代码生成逻辑}
  10.     } else {
  11.         // ${获取 URL 数据}
  13.         String[] value = adaptiveAnnotation.value();
  14.         // value 为空数组
  15.         if (value.length == 0) {
  16.             // 获取类名，并将类名转换为字符数组
  17.             char[] charArray = type.getSimpleName().toCharArray();
  18.             StringBuilder sb = new StringBuilder(128);
  19.             // 遍历字节数组
  20.             for (int i = 0; i < charArray.length; i++) {
  21.                 // 检测当前字符是否为大写字母
  22.                 if (Character.isUpperCase(charArray[i])) {
  23.                     if (i != 0) {
  24.                         // 向 sb 中添加点号
  25.                         sb.append(".");
  26.                     }
  27.                     // 将字符变为小写，并添加到 sb 中
  28.                     sb.append(Character.toLowerCase(charArray[i]));
  29.                 } else {
  30.                     // 添加字符到 sb 中
  31.                     sb.append(charArray[i]);
  32.                 }
  33.             }
  34.             value = new String[]{sb.toString()};
  35.         }
  37.         // 省略无关代码
  38.     }
  40.     // 省略无关逻辑
  41. }
2.2.3.4 检测 Invocation 参数

此段逻辑是检测方法列表中是否存在 Invocation 类型的参数，若存在，则为其生成判空代码和其他一些代码。相应的逻辑如下：

  1. for (Method method : methods) {
  2.     Class<?> rt = method.getReturnType();
  3.     Class<?>[] pts = method.getParameterTypes();    // 获取参数类型列表
  4.     Class<?>[] ets = method.getExceptionTypes();
  6.     Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
  7.     StringBuilder code = new StringBuilder(512);
  8.     if (adaptiveAnnotation == null) {
  9.         // ${无 Adaptive 注解方法代码生成逻辑}
  10.     } else {
  11.         // ${获取 URL 数据}
  13.         // ${获取 Adaptive 注解值}
  15.         boolean hasInvocation = false;
  16.         // 遍历参数类型列表
  17.         for (int i = 0; i < pts.length; ++i) {
  18.             // 判断当前参数名称是否等于 com.alibaba.dubbo.rpc.Invocation
  19.             if (pts[i].getName().equals("com.alibaba.dubbo.rpc.Invocation")) {
  20.                 // 为 Invocation 类型参数生成判空代码
  21.                 String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"invocation == null\");", i);
  22.                 code.append(s);
  23.                 // 生成 getMethodName 方法调用代码，格式为：
  24.                 //    String methodName = argN.getMethodName();
  25.                 s = String.format("\nString methodName = arg%d.getMethodName();", i);
  26.                 code.append(s);
  28.                 // 设置 hasInvocation 为 true
  29.                 hasInvocation = true;
  30.                 break;
  31.             }
  32.         }
  33.     }
  35.     // 省略无关逻辑
  36. }
2.2.3.5 生成拓展名获取逻辑

本段逻辑用于根据 SPI 和 Adaptive 注解值生成“获取拓展名逻辑”，同时生成逻辑也受 Invocation 类型参数影响，综合因素导致本段逻辑相对复杂。本段逻辑可能会生成但不限于下面的代码：

  1. String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());

或

  1. String extName = url.getMethodParameter(methodName, "loadbalance", "random");

亦或是

  1. String extName = url.getParameter("client", url.getParameter("transporter", "netty"));

本段逻辑复杂之处在于条件分支比较多，大家在阅读源码时需要知道每个条件分支的意义是什么，否则不太容易看懂相关代码。下面开始分析本段逻辑。

  1. for (Method method : methods) {
  2.     Class<?> rt = method.getReturnType();
  3.     Class<?>[] pts = method.getParameterTypes();
  4.     Class<?>[] ets = method.getExceptionTypes();
  6.     Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
  7.     StringBuilder code = new StringBuilder(512);
  8.     if (adaptiveAnnotation == null) {
  9.         // $无 Adaptive 注解方法代码生成逻辑}
  10.     } else {
  11.         // ${获取 URL 数据}
  13.         // ${获取 Adaptive 注解值}
  15.         // ${检测 Invocation 参数}
  17.         // 设置默认拓展名，cachedDefaultName 源于 SPI 注解值，默认情况下，
  18.         // SPI 注解值为空串，此时 cachedDefaultName = null
  19.         String defaultExtName = cachedDefaultName;
  20.         String getNameCode = null;
  22.         // 遍历 value，这里的 value 是 Adaptive 的注解值，2.2.3.3 节分析过 value 变量的获取过程。
  23.         // 此处循环目的是生成从 URL 中获取拓展名的代码，生成的代码会赋值给 getNameCode 变量。注意这
  24.         // 个循环的遍历顺序是由后向前遍历的。
  25.         for (int i = value.length - 1; i >= 0; --i) {
  26.             // 当 i 为最后一个元素的坐标时
  27.             if (i == value.length - 1) {
  28.                 // 默认拓展名非空
  29.                 if (null != defaultExtName) {
  30.                     // protocol 是 url 的一部分，可通过 getProtocol 方法获取，其他的则是从
  31.                     // URL 参数中获取。因为获取方式不同，所以这里要判断 value[i] 是否为 protocol
  32.                     if (!"protocol".equals(value[i]))
  33.                         // hasInvocation 用于标识方法参数列表中是否有 Invocation 类型参数
  34.                         if (hasInvocation)
  35.                             // 生成的代码功能等价于下面的代码：
  36.                             //   url.getMethodParameter(methodName, value[i], defaultExtName)
  37.                             // 以 LoadBalance 接口的 select 方法为例，最终生成的代码如下：
  38.                             //   url.getMethodParameter(methodName, "loadbalance", "random")
  39.                             getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
  40.                         else
  41.                             // 生成的代码功能等价于下面的代码：
  42.                             //   url.getParameter(value[i], defaultExtName)
  43.                             getNameCode = String.format("url.getParameter(\"%s\", \"%s\")", value[i], defaultExtName);
  44.                     else
  45.                         // 生成的代码功能等价于下面的代码：
  46.                         //   ( url.getProtocol() == null ? defaultExtName : url.getProtocol() )
  47.                         getNameCode = String.format("( url.getProtocol() == null ? \"%s\" : url.getProtocol() )", defaultExtName);
  49.                 // 默认拓展名为空
  50.                 } else {
  51.                     if (!"protocol".equals(value[i]))
  52.                         if (hasInvocation)
  53.                             // 生成代码格式同上
  54.                             getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
  55.                         else
  56.                             // 生成的代码功能等价于下面的代码：
  57.                             //   url.getParameter(value[i])
  58.                             getNameCode = String.format("url.getParameter(\"%s\")", value[i]);
  59.                     else
  60.                         // 生成从 url 中获取协议的代码，比如 "dubbo"
  61.                         getNameCode = "url.getProtocol()";
  62.                 }
  63.             } else {
  64.                 if (!"protocol".equals(value[i]))
  65.                     if (hasInvocation)
  66.                         // 生成代码格式同上
  67.                         getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
  68.                     else
  69.                         // 生成的代码功能等价于下面的代码：
  70.                         //   url.getParameter(value[i], getNameCode)
  71.                         // 以 Transporter 接口的 connect 方法为例，最终生成的代码如下：
  72.                         //   url.getParameter("client", url.getParameter("transporter", "netty"))
  73.                         getNameCode = String.format("url.getParameter(\"%s\", %s)", value[i], getNameCode);
  74.                 else
  75.                     // 生成的代码功能等价于下面的代码：
  76.                     //   url.getProtocol() == null ? getNameCode : url.getProtocol()
  77.                     // 以 Protocol 接口的 connect 方法为例，最终生成的代码如下：
  78.                     //   url.getProtocol() == null ? "dubbo" : url.getProtocol()
  79.                     getNameCode = String.format("url.getProtocol() == null ? (%s) : url.getProtocol()", getNameCode);
  80.             }
  81.         }
  82.         // 生成 extName 赋值代码
  83.         code.append("\nString extName = ").append(getNameCode).append(";");
  84.         // 生成 extName 判空代码
  85.         String s = String.format("\nif(extName == null) " +
  86.                                  "throw new IllegalStateException(\"Fail to get extension(%s) name from url(\" + url.toString() + \") use keys(%s)\");",
  87.                                  type.getName(), Arrays.toString(value));
  88.         code.append(s);
  89.     }
  91.     // 省略无关逻辑
  92. }

上面代码比较复杂，不是很好理解。对于这段代码，建议大家写点测试用例，对 Protocol、LoadBalance 以及 Transporter 等接口的自适应拓展类代码生成过程进行调试。这里我以 Transporter 接口的自适应拓展类代码生成过程举例说明。首先看一下 Transporter 接口的定义，如下：

  1. @SPI("netty")
  2. public interface Transporter {
  3.     // @Adaptive({server, transporter})
  4.     @Adaptive({Constants.SERVER_KEY, Constants.TRANSPORTER_KEY}) 
  5.     Server bind(URL url, ChannelHandler handler) throws RemotingException;
  7.     // @Adaptive({client, transporter})
  8.     @Adaptive({Constants.CLIENT_KEY, Constants.TRANSPORTER_KEY})
  9.     Client connect(URL url, ChannelHandler handler) throws RemotingException;
  10. }

下面对 connect 方法代理逻辑生成的过程进行分析，此时生成代理逻辑所用到的变量如下：

  1. String defaultExtName = "netty";
  2. boolean hasInvocation = false;
  3. String getNameCode = null;
  4. String[] value = ["client", "transporter"];

下面对 value 数组进行遍历，此时 i = 1, value[i] = “transporter”，生成的代码如下：

  1. getNameCode = url.getParameter("transporter", "netty");

接下来，for 循环继续执行，此时 i = 0, value[i] = “client”，生成的代码如下：

  1. getNameCode = url.getParameter("client", url.getParameter("transporter", "netty"));

for 循环结束运行，现在为 extName 变量生成赋值和判空代码，如下：

  1. String extName = url.getParameter("client", url.getParameter("transporter", "netty"));
  2. if (extName == null) {
  3.     throw new IllegalStateException(
  4.         "Fail to get extension(com.alibaba.dubbo.remoting.Transporter) name from url(" + url.toString()
  5.         + ") use keys([client, transporter])");
  6. }
2.2.3.6 生成拓展加载与目标方法调用逻辑

本段代码逻辑用于根据拓展名加载拓展实例，并调用拓展实例的目标方法。相关逻辑如下：

  1. for (Method method : methods) {
  2.     Class<?> rt = method.getReturnType();
  3.     Class<?>[] pts = method.getParameterTypes();
  4.     Class<?>[] ets = method.getExceptionTypes();
  6.     Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
  7.     StringBuilder code = new StringBuilder(512);
  8.     if (adaptiveAnnotation == null) {
  9.         // $无 Adaptive 注解方法代码生成逻辑}
  10.     } else {
  11.         // ${获取 URL 数据}
  13.         // ${获取 Adaptive 注解值}
  15.         // ${检测 Invocation 参数}
  17.         // ${生成拓展名获取逻辑}
  19.         // 生成拓展获取代码，格式如下：
  20.         // type全限定名 extension = (type全限定名)ExtensionLoader全限定名
  21.         //     .getExtensionLoader(type全限定名.class).getExtension(extName);
  22.         // Tips: 格式化字符串中的 %<s 表示使用前一个转换符所描述的参数，即 type 全限定名
  23.         s = String.format("\n%s extension = (%<s)%s.getExtensionLoader(%s.class).getExtension(extName);",
  24.                         type.getName(), ExtensionLoader.class.getSimpleName(), type.getName());
  25.         code.append(s);
  27.         // 如果方法返回值类型非 void，则生成 return 语句。
  28.         if (!rt.equals(void.class)) {
  29.             code.append("\nreturn ");
  30.         }
  32.         // 生成目标方法调用逻辑，格式为：
  33.         //     extension.方法名(arg0, arg2, ..., argN);
  34.         s = String.format("extension.%s(", method.getName());
  35.         code.append(s);
  36.         for (int i = 0; i < pts.length; i++) {
  37.             if (i != 0)
  38.                 code.append(", ");
  39.             code.append("arg").append(i);
  40.         }
  41.         code.append(");");   
  42.     }
  44.     // 省略无关逻辑
  45. }

以 Protocol 接口举例说明，上面代码生成的内容如下：

  1. com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader
  2.     .getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);
  3. return extension.refer(arg0, arg1);
2.2.3.7 生成完整的方法

本节进行代码生成的收尾工作，主要用于生成方法定义的代码。相关逻辑如下：

  1. for (Method method : methods) {
  2.     Class<?> rt = method.getReturnType();
  3.     Class<?>[] pts = method.getParameterTypes();
  4.     Class<?>[] ets = method.getExceptionTypes();
  6.     Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
  7.     StringBuilder code = new StringBuilder(512);
  8.     if (adaptiveAnnotation == null) {
  9.         // $无 Adaptive 注解方法代码生成逻辑}
  10.     } else {
  11.         // ${获取 URL 数据}
  13.         // ${获取 Adaptive 注解值}
  15.         // ${检测 Invocation 参数}
  17.         // ${生成拓展名获取逻辑}
  19.         // ${生成拓展加载与目标方法调用逻辑}
  20.     }
  21. }
  23. // public + 返回值全限定名 + 方法名 + (
  24. codeBuilder.append("\npublic ")
  25.     .append(rt.getCanonicalName())
  26.     .append(" ")
  27.     .append(method.getName())
  28.     .append("(");
  30. // 添加参数列表代码
  31. for (int i = 0; i < pts.length; i++) {
  32.     if (i > 0) {
  33.         codeBuilder.append(", ");
  34.     }
  35.     codeBuilder.append(pts[i].getCanonicalName());
  36.     codeBuilder.append(" ");
  37.     codeBuilder.append("arg").append(i);
  38. }
  39. codeBuilder.append(")");
  41. // 添加异常抛出代码
  42. if (ets.length > 0) {
  43.     codeBuilder.append(" throws ");
  44.     for (int i = 0; i < ets.length; i++) {
  45.         if (i > 0) {
  46.             codeBuilder.append(", ");
  47.         }
  48.         codeBuilder.append(ets[i].getCanonicalName());
  49.     }
  50. }
  51. codeBuilder.append(" {");
  52. codeBuilder.append(code.toString());
  53. codeBuilder.append("\n}");

以 Protocol 的 refer 方法为例，上面代码生成的内容如下：

  1. public com.alibaba.dubbo.rpc.Invoker refer(java.lang.Class arg0, com.alibaba.dubbo.common.URL arg1) {
  2.     // 方法体
  3. }