前言
在前面的章節(jié)中，我們已經(jīng)完成Dubbo服務(wù)暴露的流程分析。今天我們一起來看Dubbo怎么引用這些服務(wù)的。
關(guān)于服務(wù)引用，Dubbo有兩種方式。一種是基于注冊中心進行服務(wù)引用，一種是服務(wù)直連進行引用。服務(wù)直連主要用于測試聯(lián)調(diào)階段，生產(chǎn)環(huán)境不推薦使用。它的配置也比較簡單，在消費者端指定服務(wù)url即可。
<dubbo:reference id="infoUserService"
interface="com.viewscenes.netsupervisor.service.InfoUserService"
url="dubbo://192.168.139.129:20880"/>
本文將重點分析通過注冊中心方式，服務(wù)引用的過程。開始之前，我們再回顧一下消費者端項目整體的XML文件配置。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
<!-- 消費者方應(yīng)用信息，用于計算依賴關(guān)系 -->
<dubbo:application name="dubbo_consumer"/>
<!-- 用于配置連接注冊中心相關(guān)信息 -->
<dubbo:registry protocol="zookeeper" address="192.168.139.131:2181" client="zkclient" />
<!-- 引用配置 用于創(chuàng)建一個遠程接口服務(wù)代理 -->
<dubbo:reference id="infoUserService"
interface="com.viewscenes.netsupervisor.service.InfoUserService"/>
</beans>
一、引用的是什么？
在上述配置文件中，infoUserService只是Spring中的一個Bean。在代碼中，我們通過getBean()來獲取它，然后調(diào)用它的方法。
我們在RPC基本原理以及如何用Netty來實現(xiàn)RPC這篇文章中已經(jīng)分析過，這里的bean其實是一個FactoryBean，通過它可以返回一個接口的代理對象，完成調(diào)用邏輯的處理。
在代碼中，我們通過這樣來獲取這個Bean。
InfoUserService infoUserService = (InfoUserService) context.getBean("infoUserService");
這里的infoUserService就是一個代理對象，比如像proxy@2903這種。當(dāng)然了，它必然會包含一個InvocationHandler，如下所示：
服務(wù)引用就是其實通過動態(tài)代理給接口創(chuàng)建代理對象并返回。當(dāng)我們調(diào)用接口方法時，則調(diào)用到InvocationHandler相關(guān)方法，處理相關(guān)請求。
二、從哪里開始？
在上面的配置文件中，dubbo:reference對應(yīng)的是ReferenceBean處理類。那么Spring在實例化這個Bean的時候，就調(diào)用到里面方法。我們先看看它的類結(jié)構(gòu)
package com.alibaba.dubbo.config.spring;
public class ReferenceBean<T> extends ReferenceConfig<T> implements
FactoryBean, ApplicationContextAware, InitializingBean, DisposableBean {
private transient ApplicationContext applicationContext;
public ReferenceBean() {
super();
}
public ReferenceBean(Reference reference) {
super(reference);
}
//設(shè)置applicationContext
public void setApplicationContext(ApplicationContext applicationContext) {
this.applicationContext = applicationContext;
}
//返回代理對象
public Object getObject() throws Exception {
return get();
}
//返回代理對象接口類型
public Class<?> getObjectType() {
return getInterfaceClass();
}
//是否為單例
@Parameter(excluded = true)
public boolean isSingleton() {
return true;
}
//Bean初始化方法
public void afterPropertiesSet() throws Exception {
if(isInit()){
getObject();
}
}
}
首先，映入眼簾的是FactoryBean接口。有了它，則證明當(dāng)前bean是一個工廠Bean，所以我們重點關(guān)注它的getObject方法，當(dāng)我們的服務(wù)被注入到其他類中時，就會調(diào)用到此方法。
其次，是InitializingBean接口。它是Bean的初始化方法，當(dāng)Bean完成實例化之后被調(diào)用。在上述代碼中，當(dāng)init()條件判斷成立后調(diào)用getObject。我們可以在配置文件中以這種方式來激活它：init="true"
以上就是服務(wù)引用的兩個不同時機。再專業(yè)點來講，一個是懶漢式，一個是餓漢式。Dubbo默認(rèn)是懶漢式引用，需要時才會調(diào)用。
上述代碼中，getObject方法會調(diào)用到父類的init方法。這個方法內(nèi)容比較多，前面的部分是各種配置檢查、賦值，然后就是創(chuàng)建代理對象返回。
private void init() {
//避免重復(fù)初始化
if (initialized) {
return;
}
//省略相關(guān)配置檢查、賦值等代碼...
//創(chuàng)建代理
ref = createProxy(map);
}
上述代碼中，重點是createProxy方法。它負(fù)責(zé)創(chuàng)建Invoker實例和創(chuàng)建代理對象。
也許我們還記得，在服務(wù)暴露的時候，會分為本地暴露和遠程暴露。在這里，服務(wù)引用也是這樣。Dubbo首先判斷服務(wù)引用是本地引用還是遠程引用，默認(rèn)是遠程引用。然后判斷是否為直連服務(wù)，根據(jù)協(xié)議調(diào)用refer方法創(chuàng)建invoker對象 。最后創(chuàng)建服務(wù)代理對象并返回。
private T createProxy(Map<String, String> map) {
URL tmpUrl = new URL("temp", "localhost", 0, map);
final boolean isJvmRefer;
//獲取配置判斷是否為本地引用
if (isInjvm() == null) {
if (url != null && url.length() > 0) {
isJvmRefer = false;
} else if (InjvmProtocol.getInjvmProtocol().isInjvmRefer(tmpUrl)) {
// by default, reference local service if there is
isJvmRefer = true;
} else {
isJvmRefer = false;
}
} else {
isJvmRefer = isInjvm().booleanValue();
}
//本地引用
if (isJvmRefer) {
URL url = new URL(Constants.LOCAL_PROTOCOL, NetUtils.LOCALHOST, 0, interfaceClass.getName()).addParameters(map);
invoker = refprotocol.refer(interfaceClass, url);
if (logger.isInfoEnabled()) {
logger.info("Using injvm service " + interfaceClass.getName());
}
//遠程引用
} else {
//url不為空則代表是服務(wù)直連
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.setPath(interfaceName);
}
if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
urls.add(url.addParameterAndEncoded(Constants.REFER_KEY, StringUtils.toQueryString(map)));
} else {
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()));
}
urls.add(u.addParameterAndEncoded(Constants.REFER_KEY, StringUtils.toQueryString(map)));
}
}
}
//單個注冊中心
if (urls.size() == 1) {
invoker = refprotocol.refer(interfaceClass, urls.get(0));
//多個注冊中心
} else {
List<Invoker<?>> invokers = new ArrayList<Invoker<?>>();
URL registryURL = null;
for (URL url : urls) {
invokers.add(refprotocol.refer(interfaceClass, url));
if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
registryURL = url;
}
}
if (registryURL != null) {
// use AvailableCluster only when register's cluster is available
URL u = registryURL.addParameter(Constants.CLUSTER_KEY, AvailableCluster.NAME);
invoker = cluster.join(new StaticDirectory(u, invokers));
} else {
invoker = cluster.join(new StaticDirectory(invokers));
}
}
}
//創(chuàng)建代理類
return (T) proxyFactory.getProxy(invoker);
}
前面的整個流程我們可以分為兩大部分：創(chuàng)建Invoker和創(chuàng)建代理。
三、創(chuàng)建Invoker
1、連接注冊中心
我們以本文開頭的XML配置文件為例，它是基于單個注冊中心的遠程服務(wù)引用。所以，我們重點分析invoker = refprotocol.refer(interfaceClass, urls.get(0));
我們需要清楚的認(rèn)識到，urls.get(0)獲取到的是注冊中心的地址。內(nèi)容如下：registry://192.168.139.131:2181/org.apache.dubbo.registry.RegistryService?...
所以，我們先來看RegistryProtocol.refer方法。它主要是獲取注冊中心，并執(zhí)行服務(wù)引用。
public class RegistryProtocol implements Protocol {
public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
//轉(zhuǎn)換協(xié)議
url = url.setProtocol(url.getParameter("registry", "dubbo")).removeParameter("registry");
//通過zookeeper連接到注冊中心
Registry registry = registryFactory.getRegistry(url);
if (RegistryService.class.equals(type)) {
return proxyFactory.getInvoker((T) registry, type, url);
}
// group="a,b" or group="*"
Map<String, String> qs = StringUtils.parseQueryString(url.getParameterAndDecoded("refer"));
String group = qs.get(Constants.GROUP_KEY);
if (group != null && group.length() > 0) {
if ((Constants.COMMA_SPLIT_PATTERN.split(group)).length > 1
|| "*".equals(group)) {
return doRefer(getMergeableCluster(), registry, type, url);
}
}
return doRefer(cluster, registry, type, url);
}
}
我們接著看doRefer(cluster, registry, type, url);我們可以認(rèn)為它主要做了3件事：
- 向注冊中心注冊服務(wù)消費者(本身)
- 向注冊中心訂閱服務(wù)提供者
- 通過Cluster創(chuàng)建Invoker對象
private <T> Invoker<T> doRefer(Cluster cluster, Registry registry, Class<T> type, URL url) {
// 創(chuàng)建 RegistryDirectory 對象，并設(shè)置注冊中心
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());
//創(chuàng)建訂閱 URL
URL subscribeUrl = new URL(Constants.CONSUMER_PROTOCOL, parameters.
remove("register.ip"), 0, type.getName(), parameters);
if (!Constants.ANY_VALUE.equals(url.getServiceInterface())
&& url.getParameter(Constants.REGISTER_KEY, true)) {
//向注冊中心注冊服務(wù)消費者
registry.register(subscribeUrl.addParameters("category", "consumers",
"check", String.valueOf(false)));
}
// 向注冊中心訂閱服務(wù)提供者
directory.subscribe(subscribeUrl.addParameter(Constants.CATEGORY_KEY,
Constants.PROVIDERS_CATEGORY
+ "," + Constants.CONFIGURATORS_CATEGORY
+ "," + Constants.ROUTERS_CATEGORY));
//創(chuàng)建Invoker對象
Invoker invoker = cluster.join(directory);
ProviderConsumerRegTable.registerConsumer(invoker, url, subscribeUrl, directory);
return invoker;
}
如上代碼， 它的重點在于directory.subscribe ，它通過訂閱注冊中心的服務(wù)提供者，調(diào)用相關(guān)協(xié)議的引用方法。比如DubboProtocol.refer，下面我們來看它是怎么調(diào)用的。
2、訂閱服務(wù)提供者
我們通過directory.subscribe這句代碼， 會定位到ZookeeperRegistry.doSubscribe方法。
public class ZookeeperRegistry extends FailbackRegistry {
protected void doSubscribe(final URL url, final NotifyListener listener) {
List<URL> urls = new ArrayList<URL>();
//獲取注冊中心除了消費者信息之外的所有節(jié)點
//比如configurators, routers, providers
String[] paths = toCategoriesPath(url);
for (String path :paths) {
//獲取節(jié)點監(jiān)聽器管理容器
ConcurrentMap<NotifyListener, ChildListener> listeners = zkListeners.get(url);
if (listeners == null) {
zkListeners.putIfAbsent(url,
new ConcurrentHashMap<NotifyListener, ChildListener>());
listeners = zkListeners.get(url);
}
//獲取節(jié)點監(jiān)聽器
ChildListener zkListener = listeners.get(listener);
//如果為空，則創(chuàng)建一個監(jiān)聽器
if (zkListener == null) {
listeners.putIfAbsent(listener, new ChildListener() {
@Override
public void childChanged(String parentPath, List<String> currentChilds) {
ZookeeperRegistry.this.notify(url, listener,
toUrlsWithEmpty(url, parentPath, currentChilds));
}
});
zkListener = listeners.get(listener);
}
//創(chuàng)建節(jié)點
zkClient.create(path, false);
//訂閱節(jié)點path 數(shù)據(jù)變化，通知到zkListener
//即通知到ZookeeperRegistry.this.notify
List<String> children = zkClient.addChildListener(path, zkListener);
if (children != null) {
urls.addAll(toUrlsWithEmpty(url, path, children));
}
}
//通知
notify(url, listener, urls);
}
}
如上代碼，重點就是通過注冊中心獲取到服務(wù)提供者的url，調(diào)用notify方法。同時還訂閱了服務(wù)提供者的節(jié)點數(shù)據(jù)變化，如果有變化也調(diào)用notify方法。
而在notify方法中，最終會根據(jù)url調(diào)用服務(wù)引用方法refer，再封裝成InvokerDelegate對象。
invoker = new InvokerDelegate<T>(protocol.refer(serviceType, url), url, providerUrl);
這樣不僅完成了本次的服務(wù)引用，而且當(dāng)服務(wù)提供者上下線的時候，消費者也可以動態(tài)感知。
3、Listener和Filter
以DubboProtocol為例，它是Wrapper包裝類的對象，關(guān)于這一點我們一定要牢記。
回憶服務(wù)暴露的過程，我們可以監(jiān)聽服務(wù)暴露的過程，在構(gòu)建調(diào)用鏈的時候可以增加Filter。在這里，服務(wù)引用也是一樣的。
- 服務(wù)引用監(jiān)聽
在InvokerListener 接口中，有兩個方法。分別是服務(wù)引用后調(diào)用和服務(wù)銷毀時調(diào)用。
@SPI
public interface InvokerListener {
//服務(wù)引用
void referred(Invoker<?> invoker) throws RpcException;
//服務(wù)銷毀
void destroyed(Invoker<?> invoker);
}
我們先自定義監(jiān)聽器，來實現(xiàn)接口的方法。
public class MyInvokerListener1 implements InvokerListener{
public void referred(Invoker<?> invoker) throws RpcException {
System.out.println("服務(wù)引用111.."+invoker.getUrl());
}
public void destroyed(Invoker<?> invoker) {
System.out.println("服務(wù)銷毀111.."+invoker.getUrl());
}
}
然后創(chuàng)建擴展點配置文件，文件名稱為：
com.alibaba.dubbo.rpc.InvokerListener
內(nèi)容為：
listener1=com.viewscenes.netsupervisor.listener.MyInvokerListener1
最后，修改XML配置文件
<dubbo:consumer listener="listener1"/>
- Filter過濾器
首先自定義過濾器
public class MyFilter implements Filter{
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
System.out.println("調(diào)用之前-----------");
Result result = invoker.invoke(invocation);
System.out.println("調(diào)用之后-----------");
return result;
}
}
然后創(chuàng)建擴展點配置文件，文件名稱為：
com.alibaba.dubbo.rpc.Filter
內(nèi)容為：
myfilter1=com.viewscenes.netsupervisor.filter.MyFilter
最后，修改XML配置文件，說明自定義的過濾器在默認(rèn)過濾器之前。
filter="myfilter1,default""/>
4、DubboProtocol
前面啰啰嗦嗦一大堆，終于來到正主。這里主要是獲取通信客戶端，拿到ExchangeClient，然后封裝為DubboInvoker對象并返回。
public class DubboProtocol extends AbstractProtocol {
public <T> Invoker<T> refer(Class<T> serviceType, URL url) throws RpcException {
optimizeSerialization(url);
//獲取通信客戶端
ExchangeClient[] client = getClients(url);
//創(chuàng)建DubboInvoker對象
DubboInvoker<T> invoker = new DubboInvoker<T>(serviceType, url, client, invokers);
invokers.add(invoker);
return invoker;
}
}
這里主要分為兩個步驟：
- 創(chuàng)建通信客戶端
在getClients方法里面，主要判斷是否為共享連接的客戶端。
private ExchangeClient[] getClients(URL url) {
// 是否共享連接
boolean service_share_connect = false;
// 獲取連接數(shù)，默認(rèn)為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;
}
如果未配置，Dubbo默認(rèn)創(chuàng)建共享連接客戶端。我們繼續(xù)看getSharedClient方法。
private ExchangeClient getSharedClient(URL url) {
//服務(wù)地址
String key = url.getAddress();
//查詢緩存是否已經(jīng)創(chuàng)建了客戶端
ReferenceCountExchangeClient client = referenceClientMap.get(key);
if (client != null) {
if (!client.isClosed()) {
client.incrementAndGetCount();
return client;
} else {
referenceClientMap.remove(key);
}
}
synchronized (key.intern()) {
//初始化客戶端
ExchangeClient exchangeClient = initClient(url);
//封裝成ReferenceCountExchangeClient對象，用于引用計數(shù)
client = new ReferenceCountExchangeClient(exchangeClient, ghostClientMap);
//放入緩存并返回
referenceClientMap.put(key, client);
ghostClientMap.remove(key);
return client;
}
}
如上代碼，先從緩存中獲取客戶端，未命中則調(diào)用initClient方法初始化客戶端。并將它封裝成ReferenceCountExchangeClient 對象返回。在initClient方法中，設(shè)置客戶端類型、編解碼和心跳信息，并調(diào)用connect創(chuàng)建客戶端。
private ExchangeClient initClient(URL url) {
//客戶端類型 默認(rèn)為netty
String str = url.getParameter("client", url.getParameter("server","netty"));
//編解碼
url = url.addParameter("codes", "dubbo");
//心跳
url = url.addParameterIfAbsent("heartbeat","60000");
ExchangeClient client;
try {
if (url.getParameter("lazy", false)) {
client = new LazyConnectExchangeClient(url, requestHandler);
} else {
//創(chuàng)建連接客戶端
client = Exchangers.connect(url, requestHandler);
}
} catch (RemotingException e) {
throw new RpcException("Fail to create remoting
client for service(" + url + "): " + e.getMessage(), e);
}
return client;
}
如上代碼，connect會調(diào)用到HeaderExchangeClient.connect方法。
public class HeaderExchanger implements Exchanger {
public ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException {
HeaderExchangeHandler headerExchangeHandler = new HeaderExchangeHandler(handler);
DecodeHandler decodeHandler = new DecodeHandler(headerExchangeHandler);
Client client = Transporters.connect(url, decodeHandler);
return new HeaderExchangeClient(client,true);
}
}
我們重點來看Transporters.connect，它會調(diào)用到NettyClient的構(gòu)造方法。最終調(diào)用doOpen和doConnect方法，連接通信服務(wù)器。
public class NettyClient extends AbstractClient {
protected void doOpen() throws Throwable {
NettyHelper.setNettyLoggerFactory();
bootstrap = new ClientBootstrap(channelFactory);
bootstrap.setOption("keepAlive", true);
bootstrap.setOption("tcpNoDelay", true);
bootstrap.setOption("connectTimeoutMillis", getTimeout());
//處理器
final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);
bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
@Override
public ChannelPipeline getPipeline() {
NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec(),
getUrl(), NettyClient.this);
ChannelPipeline pipeline = Channels.pipeline();
pipeline.addLast("decoder", adapter.getDecoder());
pipeline.addLast("encoder", adapter.getEncoder());
pipeline.addLast("handler", nettyHandler);
return pipeline;
}
});
}
protected void doConnect() throws Throwable {
long start = System.currentTimeMillis();
//獲取服務(wù)器地址，并連接
ChannelFuture future = bootstrap.connect(getConnectAddress());
try {
boolean ret = future.awaitUninterruptibly(getConnectTimeout(), TimeUnit.MILLISECONDS);
//連接成功后獲取Channel
if (ret && future.isSuccess()) {
Channel newChannel = future.getChannel();
newChannel.setInterestOps(Channel.OP_READ_WRITE);
try {
// Close old channel
Channel oldChannel = NettyClient.this.channel; // copy reference
if (oldChannel != null) {
try {
oldChannel.close();
} finally {
NettyChannel.removeChannelIfDisconnected(oldChannel);
}
}
} finally {
if (NettyClient.this.isClosed()) {
try {
newChannel.close();
} finally {
NettyClient.this.channel = null;
NettyChannel.removeChannelIfDisconnected(newChannel);
}
} else {
//設(shè)置當(dāng)前Channel
NettyClient.this.channel = newChannel;
}
}
}
}
}
}
以上大部分都是Netty的代碼，連接服務(wù)器成功后獲取到Channel保存。 我們重點看NettyHandler，它是事件處理器。這里的messageReceived負(fù)責(zé)接收處理返回的消息。接收到消息后，通過線程池拿到線程去執(zhí)行后續(xù)的處理。不同的是，這里的線程池類型是CachedThreadPool ，即緩存型線程池。
這里的流程處理完畢，我們再把目光回到DubboInvoker，它通過一個構(gòu)造方法返回Invoker對象。
public DubboInvoker(Class<T> serviceType, URL url,
ExchangeClient[] clients, Set<Invoker<?>> invokers) {
this.clients = clients;
this.version = url.getParameter(Constants.VERSION_KEY, "0.0.0");
this.invokers = invokers;
}
至此，Invoker對象已經(jīng)創(chuàng)建完畢。我們回到開頭的createProxy方法。最后一步是為這個Invoker對象創(chuàng)建代理。
五、創(chuàng)建代理
在Dubbo，默認(rèn)使用Javassist來創(chuàng)建代理。
public class JavassistProxyFactory extends AbstractProxyFactory {
public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
//調(diào)用處理程序
InvocationHandler invocationHandler = new InvokerInvocationHandler(invoker)
//創(chuàng)建代理
return (T) Proxy.getProxy(interfaces).newInstance(invocationHandler);
}
}
創(chuàng)建的過程很簡單，我們主要來看InvocationHandler 。既然是代理對象，我們每次調(diào)用接口方法的時候，會調(diào)用到這個對象的invoke方法。
public class InvokerInvocationHandler implements InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
Class<?>[] parameterTypes = method.getParameterTypes();
if (method.getDeclaringClass() == Object.class) {
return method.invoke(invoker, args);
}
if ("toString".equals(methodName) && parameterTypes.length == 0) {
return invoker.toString();
}
if ("hashCode".equals(methodName) && parameterTypes.length == 0) {
return invoker.hashCode();
}
if ("equals".equals(methodName) && parameterTypes.length == 1) {
return invoker.equals(args[0]);
}
//把請求的方法名和參數(shù)等封裝成RpcInvocation對象
//調(diào)用invoke
return invoker.invoke(new RpcInvocation(method, args)).recreate();
}
}
至此，服務(wù)引用的大體流程我們已經(jīng)分析完了。我們再來總結(jié)一下它的過程：
- 通過FactoryBean觸發(fā)服務(wù)引用方法
- 連接注冊中心，獲取服務(wù)提供者列表，創(chuàng)建invoker
- 訂閱服務(wù)提供者節(jié)點，數(shù)據(jù)變更時獲得通知
- 連接服務(wù)器，獲得客戶端
- 創(chuàng)建代理
