Dubbo 原始碼分析 - 服務引用

public Object getObject() throws Exception {
return get();
}

public synchronized T get() {
if (destroyed) {
throw new IllegalStateException("Already destroyed!");
}
// 檢測 ref 是否為空，為空則通過 init 方法建立
if (ref == null) {
// init 方法主要用於處理配置，以及呼叫 createProxy 生成代理類
init();
}
return ref;
}

private void init() {
if (initialized) {
return;
}
initialized = true;
if (interfaceName == null || interfaceName.length() == 0) {
throw new IllegalStateException("interface not allow null!");
}

// 檢測 consumer 變數是否為空，為空則建立
checkDefault();
appendProperties(this);
if (getGeneric() == null && getConsumer() != null) {
// 設定 generic
setGeneric(getConsumer().getGeneric());
}

// 檢測是否為泛化介面
if (ProtocolUtils.isGeneric(getGeneric())) {
interfaceClass = GenericService.class;
} else {
try {
// 載入類
interfaceClass = Class.forName(interfaceName, true, Thread.currentThread()
.getContextClassLoader());
} catch (ClassNotFoundException e) {
throw new IllegalStateException(e.getMessage(), e);
}
checkInterfaceAndMethods(interfaceClass, methods);
}

// -------------------------------:sparkles: 分割線1 :sparkles:------------------------------

// 從系統變數中獲取與介面名對應的屬性值
String resolve = System.getProperty(interfaceName);
String resolveFile = null;
if (resolve == null || resolve.length() == 0) {
// 從系統屬性中獲取解析檔案路徑
resolveFile = System.getProperty("dubbo.resolve.file");
if (resolveFile == null || resolveFile.length() == 0) {
// 從指定位置載入配置檔案
File userResolveFile = new File(new File(System.getProperty("user.home")), "dubbo-resolve.properties");
if (userResolveFile.exists()) {
// 獲取檔案絕對路徑
resolveFile = userResolveFile.getAbsolutePath();
}
}
if (resolveFile != null && resolveFile.length() > 0) {
Properties properties = new Properties();
FileInputStream fis = null;
try {
fis = new FileInputStream(new File(resolveFile));
// 從檔案中載入配置
properties.load(fis);
} catch (IOException e) {
throw new IllegalStateException("Unload ..., cause:...");
} finally {
try {
if (null != fis) fis.close();
} catch (IOException e) {
logger.warn(e.getMessage(), e);
}
}
// 獲取與介面名對應的配置
resolve = properties.getProperty(interfaceName);
}
}
if (resolve != null && resolve.length() > 0) {
// 將 resolve 賦值給 url
url = resolve;
}

// -------------------------------:sparkles: 分割線2 :sparkles:------------------------------
if (consumer != null) {
if (application == null) {
// 從 consumer 中獲取 Application 例項，下同
application = consumer.getApplication();
}
if (module == null) {
module = consumer.getModule();
}
if (registries == null) {
registries = consumer.getRegistries();
}
if (monitor == null) {
monitor = consumer.getMonitor();
}
}
if (module != null) {
if (registries == null) {
registries = module.getRegistries();
}
if (monitor == null) {
monitor = module.getMonitor();
}
}
if (application != null) {
if (registries == null) {
registries = application.getRegistries();
}
if (monitor == null) {
monitor = application.getMonitor();
}
}

// 檢測本地 Application 和本地存根配置合法性
checkApplication();
checkStubAndMock(interfaceClass);

// -------------------------------:sparkles: 分割線3 :sparkles:------------------------------

Map<String, String> map = new HashMap<String, String>();
Map<Object, Object> attributes = new HashMap<Object, Object>();

// 新增 side、協議版本資訊、時間戳和程序號等資訊到 map 中
map.put(Constants.SIDE_KEY, Constants.CONSUMER_SIDE);
map.put(Constants.DUBBO_VERSION_KEY, Version.getProtocolVersion());
map.put(Constants.TIMESTAMP_KEY, String.valueOf(System.currentTimeMillis()));
if (ConfigUtils.getPid() > 0) {
map.put(Constants.PID_KEY, String.valueOf(ConfigUtils.getPid()));
}

if (!isGeneric()) {// 非泛化服務
// 獲取版本
String revision = Version.getVersion(interfaceClass, version);
if (revision != null && revision.length() > 0) {
map.put("revision", revision);
}

// 獲取介面方法列表，並新增到 map 中
String[] methods = Wrapper.getWrapper(interfaceClass).getMethodNames();
if (methods.length == 0) {
map.put("methods", Constants.ANY_VALUE);
} else {
map.put("methods", StringUtils.join(new HashSet<String>(Arrays.asList(methods)), ","));
}
}
map.put(Constants.INTERFACE_KEY, interfaceName);
// 將 ApplicationConfig、ConsumerConfig、ReferenceConfig 等物件的欄位資訊新增到 map 中
appendParameters(map, application);
appendParameters(map, module);
appendParameters(map, consumer, Constants.DEFAULT_KEY);
appendParameters(map, this);

// -------------------------------:sparkles: 分割線4 :sparkles:------------------------------

String prefix = StringUtils.getServiceKey(map);
if (methods != null && !methods.isEmpty()) {
// 遍歷 MethodConfig 列表
for (MethodConfig method : methods) {
appendParameters(map, method, method.getName());
String retryKey = method.getName() + ".retry";
// 檢測 map 是否包含 methodName.retry
if (map.containsKey(retryKey)) {
String retryValue = map.remove(retryKey);
if ("false".equals(retryValue)) {
// 新增重試次數配置 methodName.retries
map.put(method.getName() + ".retries", "0");
}
}
 
// 新增 MethodConfig 中的“屬性”欄位到 attributes
// 比如 onreturn、onthrow、oninvoke 等
appendAttributes(attributes, method, prefix + "." + method.getName());
checkAndConvertImplicitConfig(method, map, attributes);
}
}

// -------------------------------:sparkles: 分割線5 :sparkles:------------------------------

// 獲取服務消費者 ip 地址
String hostToRegistry = ConfigUtils.getSystemProperty(Constants.DUBBO_IP_TO_REGISTRY);
if (hostToRegistry == null || hostToRegistry.length() == 0) {
hostToRegistry = NetUtils.getLocalHost();
} else if (isInvalidLocalHost(hostToRegistry)) {
throw new IllegalArgumentException("Specified invalid registry ip from property..." );
}
map.put(Constants.REGISTER_IP_KEY, hostToRegistry);

// 儲存 attributes 到系統上下文中
StaticContext.getSystemContext().putAll(attributes);

// 建立代理類
ref = createProxy(map);

// 根據服務名，ReferenceConfig，代理類構建 ConsumerModel，
// 並將 ConsumerModel 存入到 ApplicationModel 中
ConsumerModel consumerModel = new ConsumerModel(getUniqueServiceName(), this, ref, interfaceClass.getMethods());
ApplicationModel.initConsumerModel(getUniqueServiceName(), consumerModel);
}

private T createProxy(Map<String, String> map) {
URL tmpUrl = new URL("temp", "localhost", 0, map);
final boolean isJvmRefer;
if (isInjvm() == null) {
// url 配置被指定，則不做本地引用
if (url != null && url.length() > 0) {
isJvmRefer = false;
// 根據 url 的協議、scope 以及 injvm 等引數檢測是否需要本地引用
// 比如如果使用者顯式配置了 scope=local，此時 isInjvmRefer 返回 true
} else if (InjvmProtocol.getInjvmProtocol().isInjvmRefer(tmpUrl)) {
isJvmRefer = true;
} else {
isJvmRefer = false;
}
} else {
// 獲取 injvm 配置值
isJvmRefer = isInjvm().booleanValue();
}

// 本地引用
if (isJvmRefer) {
// 生成本地引用 URL，協議為 injvm
URL url = new URL(Constants.LOCAL_PROTOCOL, NetUtils.LOCALHOST, 0, interfaceClass.getName()).addParameters(map);
// 呼叫 refer 方法構建 InjvmInvoker 例項
invoker = refprotocol.refer(interfaceClass, url);

// 遠端引用
} else {
// url 不為空，表明使用者可能想進行點對點呼叫
if (url != null && url.length() > 0) {
// 當需要配置多個 url 時，可用分號進行分割，這裡會進行切分
String[] us = Constants.SEMICOLON_SPLIT_PATTERN.split(url);
if (us != null && us.length > 0) {
for (String u : us) {
URL url = URL.valueOf(u);
if (url.getPath() == null || url.getPath().length() == 0) {
// 設定介面全限定名為 url 路徑
url = url.setPath(interfaceName);
}

// 檢測 url 協議是否為 registry，若是，表明使用者想使用指定的註冊中心
if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
// 將 map 轉換為查詢字串，並作為 refer 引數的值新增到 url 中
urls.add(url.addParameterAndEncoded(Constants.REFER_KEY, StringUtils.toQueryString(map)));
} else {
// 合併 url，移除服務提供者的一些配置（這些配置來源於使用者配置的 url 屬性），
// 比如執行緒池相關配置。並保留服務提供者的部分配置，比如版本，group，時間戳等
// 最後將合併後的配置設定為 url 查詢字串中。
urls.add(ClusterUtils.mergeUrl(url, map));
}
}
}
} else {
// 載入註冊中心 url
List<URL> us = loadRegistries(false);
if (us != null && !us.isEmpty()) {
for (URL u : us) {
URL monitorUrl = loadMonitor(u);
if (monitorUrl != null) {
map.put(Constants.MONITOR_KEY, URL.encode(monitorUrl.toFullString()));
}
// 新增 refer 引數到 url 中，並將 url 新增到 urls 中
urls.add(u.addParameterAndEncoded(Constants.REFER_KEY, StringUtils.toQueryString(map)));
}
}

// 未配置註冊中心，丟擲異常
if (urls.isEmpty()) {
throw new IllegalStateException("No such any registry to reference...");
}
}

// 單個註冊中心或服務提供者(服務直聯，下同)
if (urls.size() == 1) {
// 呼叫 RegistryProtocol 的 refer 構建 Invoker 例項
invoker = refprotocol.refer(interfaceClass, urls.get(0));

// 多個註冊中心或多個服務提供者，或者兩者混合
} else {
List<Invoker<?>> invokers = new ArrayList<Invoker<?>>();
URL registryURL = null;

// 獲取所有的 Invoker
for (URL url : urls) {
// 通過 refprotocol 呼叫 refer 構建 Invoker，refprotocol 會在執行時
// 根據 url 協議頭載入指定的 Protocol 例項，並呼叫例項的 refer 方法
invokers.add(refprotocol.refer(interfaceClass, url));
if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
registryURL = url;
}
}
if (registryURL != null) {
// 如果註冊中心連結不為空，則將使用 AvailableCluster
URL u = registryURL.addParameter(Constants.CLUSTER_KEY, AvailableCluster.NAME);
// 建立 StaticDirectory 例項，並由 Cluster 對多個 Invoker 進行合併
invoker = cluster.join(new StaticDirectory(u, invokers));
} else {
invoker = cluster.join(new StaticDirectory(invokers));
}
}
}

Boolean c = check;
if (c == null && consumer != null) {
c = consumer.isCheck();
}
if (c == null) {
c = true;
}

// invoker 可用性檢查
if (c && !invoker.isAvailable()) {
throw new IllegalStateException("No provider available for the service...");
}

// 生成代理類
return (T) proxyFactory.getProxy(invoker);
}

public <T> Invoker<T> refer(Class<T> serviceType, URL url) throws RpcException {
optimizeSerialization(url);
// 建立 DubboInvoker
DubboInvoker<T> invoker = new DubboInvoker<T>(serviceType, url, getClients(url), invokers);
invokers.add(invoker);
return invoker;
}

private ExchangeClient[] getClients(URL url) {
// 是否共享連線
boolean service_share_connect = false;
// 獲取連線數，預設為0，表示未配置
int connections = url.getParameter(Constants.CONNECTIONS_KEY, 0);
// 如果未配置 connections，則共享連線
if (connections == 0) {
service_share_connect = true;
connections = 1;
}

ExchangeClient[] clients = new ExchangeClient[connections];
for (int i = 0; i < clients.length; i++) {
if (service_share_connect) {
// 獲取共享客戶端
clients[i] = getSharedClient(url);
} else {
// 初始化新的客戶端
clients[i] = initClient(url);
}
}
return clients;
}

private ExchangeClient getSharedClient(URL url) {
String key = url.getAddress();
// 獲取帶有“引用計數”功能的 ExchangeClient
ReferenceCountExchangeClient client = referenceClientMap.get(key);
if (client != null) {
if (!client.isClosed()) {
// 增加引用計數
client.incrementAndGetCount();
return client;
} else {
referenceClientMap.remove(key);
}
}

locks.putIfAbsent(key, new Object());
synchronized (locks.get(key)) {
if (referenceClientMap.containsKey(key)) {
return referenceClientMap.get(key);
}

// 建立 ExchangeClient 客戶端
ExchangeClient exchangeClient = initClient(url);
// 將 ExchangeClient 例項傳給 ReferenceCountExchangeClient，這裡明顯用了裝飾模式
client = new ReferenceCountExchangeClient(exchangeClient, ghostClientMap);
referenceClientMap.put(key, client);
ghostClientMap.remove(key);
locks.remove(key);
return client;
}
}

private ExchangeClient initClient(URL url) {

// 獲取客戶端型別，預設為 netty
String str = url.getParameter(Constants.CLIENT_KEY, url.getParameter(Constants.SERVER_KEY, Constants.DEFAULT_REMOTING_CLIENT));

// 新增編解碼和心跳包引數到 url 中
url = url.addParameter(Constants.CODEC_KEY, DubboCodec.NAME);
url = url.addParameterIfAbsent(Constants.HEARTBEAT_KEY, String.valueOf(Constants.DEFAULT_HEARTBEAT));

// 檢測客戶端型別是否存在，不存在則丟擲異常
if (str != null && str.length() > 0 && !ExtensionLoader.getExtensionLoader(Transporter.class).hasExtension(str)) {
throw new RpcException("Unsupported client type: ...");
}

ExchangeClient client;
try {
// 獲取 lazy 配置，並根據配置值決定建立的客戶端型別
if (url.getParameter(Constants.LAZY_CONNECT_KEY, false)) {
// 建立懶載入 ExchangeClient 例項
client = new LazyConnectExchangeClient(url, requestHandler);
} else {
// 建立普通 ExchangeClient 例項
client = Exchangers.connect(url, requestHandler);
}
} catch (RemotingException e) {
throw new RpcException("Fail to create remoting client for service...");
}
return client;
}

public static ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException {
if (url == null) {
throw new IllegalArgumentException("url == null");
}
if (handler == null) {
throw new IllegalArgumentException("handler == null");
}
url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");
// 獲取 Exchanger 例項，預設為 HeaderExchangeClient
return getExchanger(url).connect(url, handler);
}

public ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException {
// 這裡包含了多個呼叫，分別如下：
// 1. 建立 HeaderExchangeHandler 物件
// 2. 建立 DecodeHandler 物件
// 3. 通過 Transporters 構建 Client 例項
// 4. 建立 HeaderExchangeClient 物件
return new HeaderExchangeClient(Transporters.connect(url, new DecodeHandler(new HeaderExchangeHandler(handler))), true);
}

public static Client connect(URL url, ChannelHandler... handlers) throws RemotingException {
if (url == null) {
throw new IllegalArgumentException("url == null");
}
ChannelHandler handler;
if (handlers == null || handlers.length == 0) {
handler = new ChannelHandlerAdapter();
} else if (handlers.length == 1) {
handler = handlers[0];
} else {
// 如果 handler 數量大於1，則建立一個 ChannelHandler 分發器
handler = new ChannelHandlerDispatcher(handlers);
}

// 獲取 Transporter 自適應拓展類，並呼叫 connect 方法生成 Client 例項
return getTransporter().connect(url, handler);
}

public Client connect(URL url, ChannelHandler listener) throws RemotingException {
// 建立 NettyClient 物件
return new NettyClient(url, listener);
}

public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
// 取 registry 引數值，並將其設定為協議頭
url = url.setProtocol(url.getParameter(Constants.REGISTRY_KEY, Constants.DEFAULT_REGISTRY)).removeParameter(Constants.REGISTRY_KEY);
// 獲取註冊中心例項
Registry registry = registryFactory.getRegistry(url);
// 這個判斷暫時不知道有什麼意圖，為什麼要給 RegistryService 型別生成 Invoker ？
if (RegistryService.class.equals(type)) {
return proxyFactory.getInvoker((T) registry, type, url);
}

// 將 url 查詢字串轉為 Map
Map<String, String> qs = StringUtils.parseQueryString(url.getParameterAndDecoded(Constants.REFER_KEY));
// 獲取 group 配置
String group = qs.get(Constants.GROUP_KEY);
if (group != null && group.length() > 0) {
if ((Constants.COMMA_SPLIT_PATTERN.split(group)).length > 1
|| "*".equals(group)) {
// 通過 SPI 載入 MergeableCluster 例項，並呼叫 doRefer 繼續執行引用服務邏輯
return doRefer(getMergeableCluster(), registry, type, url);
}
}

// 呼叫 doRefer 繼續執行引用服務邏輯
return doRefer(cluster, registry, type, url);
}

private <T> Invoker<T> doRefer(Cluster cluster, Registry registry, Class<T> type, URL url) {
// 建立 RegistryDirectory 例項
RegistryDirectory<T> directory = new RegistryDirectory<T>(type, url);
// 設定註冊中心和協議
directory.setRegistry(registry);
directory.setProtocol(protocol);
Map<String, String> parameters = new HashMap<String, String>(directory.getUrl().getParameters());
// 生成服務消費者連結
URL subscribeUrl = new URL(Constants.CONSUMER_PROTOCOL, parameters.remove(Constants.REGISTER_IP_KEY), 0, type.getName(), parameters);

// 註冊服務消費者，在 consumers 目錄下新節點
if (!Constants.ANY_VALUE.equals(url.getServiceInterface())
&& url.getParameter(Constants.REGISTER_KEY, true)) {
registry.register(subscribeUrl.addParameters(Constants.CATEGORY_KEY, Constants.CONSUMERS_CATEGORY,
Constants.CHECK_KEY, String.valueOf(false)));
}

// 訂閱 providers、configurators、routers 等節點資料
directory.subscribe(subscribeUrl.addParameter(Constants.CATEGORY_KEY,
Constants.PROVIDERS_CATEGORY
+ "," + Constants.CONFIGURATORS_CATEGORY
+ "," + Constants.ROUTERS_CATEGORY));

// 一個註冊中心可能有多個服務提供者，因此這裡需要將多個服務提供者合併為一個
Invoker invoker = cluster.join(directory);
ProviderConsumerRegTable.registerConsumer(invoker, url, subscribeUrl, directory);
return invoker;
}

public <T> T getProxy(Invoker<T> invoker) throws RpcException {
// 呼叫過載方法
return getProxy(invoker, false);
}

public <T> T getProxy(Invoker<T> invoker, boolean generic) throws RpcException {
Class<?>[] interfaces = null;
// 獲取介面列表
String config = invoker.getUrl().getParameter("interfaces");
if (config != null && config.length() > 0) {
// 切分介面列表
String[] types = Constants.COMMA_SPLIT_PATTERN.split(config);
if (types != null && types.length > 0) {
interfaces = new Class<?>[types.length + 2];
// 設定服務介面類和 EchoService.class 到 interfaces 中
interfaces[0] = invoker.getInterface();
interfaces[1] = EchoService.class;
for (int i = 0; i < types.length; i++) {
// 載入介面類
interfaces[i + 1] = ReflectUtils.forName(types[i]);
}
}
}
if (interfaces == null) {
interfaces = new Class<?>[]{invoker.getInterface(), EchoService.class};
}

// 為 http 和 hessian 協議提供泛化呼叫支援，參考 pull request #1827
if (!invoker.getInterface().equals(GenericService.class) && generic) {
int len = interfaces.length;
Class<?>[] temp = interfaces;
// 建立新的 interfaces 陣列
interfaces = new Class<?>[len + 1];
System.arraycopy(temp, 0, interfaces, 0, len);
// 設定 GenericService.class 到陣列中
interfaces[len] = GenericService.class;
}

// 呼叫過載方法
return getProxy(invoker, interfaces);
}

public abstract <T> T getProxy(Invoker<T> invoker, Class<?>[] types);

public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
// 生成 Proxy 子類（Proxy 是抽象類）。並呼叫Proxy 子類的 newInstance 方法生成 Proxy 例項
return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
}

public static Proxy getProxy(Class<?>... ics) {
// 呼叫過載方法
return getProxy(ClassHelper.getClassLoader(Proxy.class), ics);
}

public static Proxy getProxy(ClassLoader cl, Class<?>... ics) {
if (ics.length > 65535)
throw new IllegalArgumentException("interface limit exceeded");

StringBuilder sb = new StringBuilder();
// 遍歷介面列表
for (int i = 0; i < ics.length; i++) {
String itf = ics[i].getName();
// 檢測型別是否為介面
if (!ics[i].isInterface())
throw new RuntimeException(itf + " is not a interface.");

Class<?> tmp = null;
try {
// 重新載入介面類
tmp = Class.forName(itf, false, cl);
} catch (ClassNotFoundException e) {
}

// 檢測介面是否相同，這裡 tmp 有可能為空
if (tmp != ics[i])
throw new IllegalArgumentException(ics[i] + " is not visible from class loader");

// 拼接介面全限定名，分隔符為 ;
sb.append(itf).append(';');
}

// 使用拼接後接口名作為 key
String key = sb.toString();

Map<String, Object> cache;
synchronized (ProxyCacheMap) {
cache = ProxyCacheMap.get(cl);
if (cache == null) {
cache = new HashMap<String, Object>();
ProxyCacheMap.put(cl, cache);
}
}

Proxy proxy = null;
synchronized (cache) {
do {
// 從快取中獲取 Reference<Proxy> 例項
Object value = cache.get(key);
if (value instanceof Reference<?>) {
proxy = (Proxy) ((Reference<?>) value).get();
if (proxy != null) {
return proxy;
}
}

// 多執行緒控制，保證只有一個執行緒可以進行後續操作
if (value == PendingGenerationMarker) {
try {
// 其他執行緒在此處進行等待
cache.wait();
} catch (InterruptedException e) {
}
} else {
// 放置標誌位到快取中，並跳出 while 迴圈進行後續操作
cache.put(key, PendingGenerationMarker);
break;
}
}
while (true);
}

long id = PROXY_CLASS_COUNTER.getAndIncrement();
String pkg = null;
ClassGenerator ccp = null, ccm = null;
try {
// 建立 ClassGenerator 物件
ccp = ClassGenerator.newInstance(cl);

Set<String> worked = new HashSet<String>();
List<Method> methods = new ArrayList<Method>();

for (int i = 0; i < ics.length; i++) {
// 檢測介面訪問級別是否為 protected 或 privete
if (!Modifier.isPublic(ics[i].getModifiers())) {
// 獲取介面包名
String npkg = ics[i].getPackage().getName();
if (pkg == null) {
pkg = npkg;
} else {
if (!pkg.equals(npkg))
// 非 public 級別的介面必須在同一個包下，否者丟擲異常
throw new IllegalArgumentException("non-public interfaces from different packages");
}
}

// 新增介面到 ClassGenerator 中
ccp.addInterface(ics[i]);

// 遍歷介面方法
for (Method method : ics[i].getMethods()) {
// 獲取方法描述，可理解為方法簽名
String desc = ReflectUtils.getDesc(method);
// 如果已包含在 worked 中，則忽略。考慮這種情況，
// A 介面和 B 介面中包含一個完全相同的方法
if (worked.contains(desc))
continue;
worked.add(desc);

int ix = methods.size();
// 獲取方法返回值型別
Class<?> rt = method.getReturnType();
// 獲取引數列表
Class<?>[] pts = method.getParameterTypes();

// 生成 Object[] args = new Object[1...N]
StringBuilder code = new StringBuilder("Object[] args = new Object[").append(pts.length).append("];");
for (int j = 0; j < pts.length; j++)
// 生成 args[1...N] = ($w)$1...N;
code.append(" args[").append(j).append("] = ($w)$").append(j + 1).append(";");
// 生成 InvokerHandler 介面的 invoker 方法呼叫語句，如下：
// Object ret = handler.invoke(this, methods[1...N], args);
code.append(" Object ret = handler.invoke(this, methods[" + ix + "], args);");

// 返回值不為 void
if (!Void.TYPE.equals(rt))
// 生成返回語句，形如 return (java.lang.String) ret;
code.append(" return ").append(asArgument(rt, "ret")).append(";");

methods.add(method);
// 新增方法名、訪問控制符、引數列表、方法程式碼等資訊到 ClassGenerator 中 
ccp.addMethod(method.getName(), method.getModifiers(), rt, pts, method.getExceptionTypes(), code.toString());
}
}

if (pkg == null)
pkg = PACKAGE_NAME;

// 構建介面代理類名稱：pkg + ".proxy" + id，比如 com.tianxiaobo.proxy0
String pcn = pkg + ".proxy" + id;
ccp.setClassName(pcn);
ccp.addField("public static java.lang.reflect.Method[] methods;");
// 生成 private java.lang.reflect.InvocationHandler handler;
ccp.addField("private " + InvocationHandler.class.getName() + " handler;");

// 為介面代理類新增帶有 InvocationHandler 引數的構造方法，比如：
// porxy0(java.lang.reflect.InvocationHandler arg0) {
//handler=$1;
// }
ccp.addConstructor(Modifier.PUBLIC, new Class<?>[]{InvocationHandler.class}, new Class<?>[0], "handler=$1;");
// 為介面代理類新增預設構造方法
ccp.addDefaultConstructor();

// 生成介面代理類
Class<?> clazz = ccp.toClass();
clazz.getField("methods").set(null, methods.toArray(new Method[0]));

// 構建 Proxy 子類名稱，比如 Proxy1，Proxy2 等
String fcn = Proxy.class.getName() + id;
ccm = ClassGenerator.newInstance(cl);
ccm.setClassName(fcn);
ccm.addDefaultConstructor();
ccm.setSuperClass(Proxy.class);
// 為 Proxy 的抽象方法 newInstance 生成實現程式碼，形如：
// public Object newInstance(java.lang.reflect.InvocationHandler h) { 
//return new com.tianxiaobo.proxy0($1);
// }
ccm.addMethod("public Object newInstance(" + InvocationHandler.class.getName() + " h){ return new " + pcn + "($1); }");
// 生成 Proxy 實現類
Class<?> pc = ccm.toClass();
// 通過反射建立 Proxy 例項
proxy = (Proxy) pc.newInstance();
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException(e.getMessage(), e);
} finally {
if (ccp != null)
// 釋放資源
ccp.release();
if (ccm != null)
ccm.release();
synchronized (cache) {
if (proxy == null)
cache.remove(key);
else
// 寫快取
cache.put(key, new WeakReference<Proxy>(proxy));
// 喚醒其他等待執行緒
cache.notifyAll();
}
}
return proxy;
}

package org.apache.dubbo.common.bytecode;

public class proxy0 implements org.apache.dubbo.demo.DemoService {

public static java.lang.reflect.Method[] methods;

private java.lang.reflect.InvocationHandler handler;

public proxy0() {
}

public proxy0(java.lang.reflect.InvocationHandler arg0) {
handler = $1;
}

public java.lang.String sayHello(java.lang.String arg0) {
Object[] args = new Object[1];
args[0] = ($w) $1;
Object ret = handler.invoke(this, methods[0], args);
return (java.lang.String) ret;
}
}