前言
在前面的章節中，我們已經完成Dubbo服務暴露的流程分析。今天我們一起來看Dubbo怎麼引用這些服務的。
關於服務引用，Dubbo有兩種方式。一種是基於註冊中心進行服務引用，一種是服務直連進行引用。服務直連主要用於測試聯調階段，生產環境不推薦使用。它的配置也比較簡單，在消費者端指定服務url即可。
<dubbo:reference id="infoUserService"
interface="com.viewscenes.netsupervisor.service.InfoUserService"
url="dubbo://192.168.139.129:20880"/>
複製程式碼本文將重點分析通過註冊中心方式，服務引用的過程。開始之前，我們再回顧一下消費者端專案整體的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">
<!-- 消費者方應用資訊，用於計算依賴關係 -->
<dubbo:application name="dubbo_consumer"/>
<!-- 用於配置連線註冊中心相關資訊 -->
<dubbo:registry protocol="zookeeper" address="192.168.139.131:2181" client="zkclient" />
<!-- 引用配置 用於建立一個遠端介面服務代理 -->
<dubbo:reference id="infoUserService"
interface="com.viewscenes.netsupervisor.service.InfoUserService"/>
</beans>
複製程式碼一、引用的是什麼？
在上述配置檔案中，infoUserService只是Spring中的一個Bean。在程式碼中，我們通過getBean()來獲取它，然後呼叫它的方法。
我們在RPC基本原理以及如何用Netty來實現RPC這篇文章中已經分析過，這裡的bean其實是一個FactoryBean，通過它可以返回一個介面的代理物件，完成呼叫邏輯的處理。
在程式碼中，我們通過這樣來獲取這個Bean。
InfoUserService infoUserService = (InfoUserService) context.getBean("infoUserService");
複製程式碼這裡的infoUserService就是一個代理物件，比如像proxy@2903這種。當然了，它必然會包含一個InvocationHandler，如下所示：
服務引用就是其實通過動態代理給介面建立代理物件並返回。當我們呼叫介面方法時，則呼叫到InvocationHandler相關方法，處理相關請求。
二、從哪裡開始？
在上面的配置檔案中，dubbo:reference對應的是ReferenceBean處理類。那麼Spring在例項化這個Bean的時候，就呼叫到裡面方法。我們先看看它的類結構
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);
}
//設定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介面。有了它，則證明當前bean是一個工廠Bean，所以我們重點關注它的getObject方法，當我們的服務被注入到其他類中時，就會呼叫到此方法。
其次，是InitializingBean介面。它是Bean的初始化方法，當Bean完成例項化之後被呼叫。在上述程式碼中，當init()條件判斷成立後呼叫getObject。我們可以在配置檔案中以這種方式來啟用它：init="true"
以上就是服務引用的兩個不同時機。再專業點來講，一個是懶漢式，一個是餓漢式。Dubbo預設是懶漢式引用，需要時才會呼叫。
上述程式碼中，getObject方法會呼叫到父類的init方法。這個方法內容比較多，前面的部分是各種配置檢查、賦值，然後就是建立代理物件返回。
private void init() {
//避免重複初始化
if (initialized) {
return;
}
//省略相關配置檢查、賦值等程式碼...
//建立代理
ref = createProxy(map);
}
複製程式碼上述程式碼中，重點是createProxy方法。它負責建立Invoker例項和建立代理物件。
也許我們還記得，在服務暴露的時候，會分為本地暴露和遠端暴露。在這裡，服務引用也是這樣。Dubbo首先判斷服務引用是本地引用還是遠端引用，預設是遠端引用。然後判斷是否為直連服務，根據協議呼叫refer方法建立invoker物件 。最後建立服務代理物件並返回。
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不為空則代表是服務直連
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));
}
}
}
//建立代理類
return (T) proxyFactory.getProxy(invoker);
}
複製程式碼前面的整個流程我們可以分為兩大部分：建立Invoker和建立代理。
三、建立Invoker
1、連線註冊中心
我們以本文開頭的XML配置檔案為例，它是基於單個註冊中心的遠端服務引用。所以，我們重點分析invoker = refprotocol.refer(interfaceClass, urls.get(0));
我們需要清楚的認識到，urls.get(0)獲取到的是註冊中心的地址。內容如下：registry://192.168.139.131:2181/org.apache.dubbo.registry.RegistryService?...
所以，我們先來看RegistryProtocol.refer方法。它主要是獲取註冊中心，並執行服務引用。
public class RegistryProtocol implements Protocol {
public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
//轉換協議
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);我們可以認為它主要做了3件事：
- 向註冊中心註冊服務消費者(本身)
- 向註冊中心訂閱服務提供者
- 通過Cluster建立Invoker物件
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
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)) {
//向註冊中心註冊服務消費者
registry.register(subscribeUrl.addParameters("category", "consumers",
"check", String.valueOf(false)));
}
// 向註冊中心訂閱服務提供者
directory.subscribe(subscribeUrl.addParameter(Constants.CATEGORY_KEY,
Constants.PROVIDERS_CATEGORY
+ "," + Constants.CONFIGURATORS_CATEGORY
+ "," + Constants.ROUTERS_CATEGORY));
//建立Invoker物件
Invoker invoker = cluster.join(directory);
ProviderConsumerRegTable.registerConsumer(invoker, url, subscribeUrl, directory);
return invoker;
}
複製程式碼如上程式碼， 它的重點在於directory.subscribe ，它通過訂閱註冊中心的服務提供者，呼叫相關協議的引用方法。比如DubboProtocol.refer，下面我們來看它是怎麼呼叫的。
2、訂閱服務提供者
我們通過directory.subscribe這句程式碼， 會定位到ZookeeperRegistry.doSubscribe方法。
public class ZookeeperRegistry extends FailbackRegistry {
protected void doSubscribe(final URL url, final NotifyListener listener) {
List<URL> urls = new ArrayList<URL>();
//獲取註冊中心除了消費者資訊之外的所有節點
//比如configurators, routers, providers
String[] paths = toCategoriesPath(url);
for (String path :paths) {
//獲取節點監聽器管理容器
ConcurrentMap<NotifyListener, ChildListener> listeners = zkListeners.get(url);
if (listeners == null) {
zkListeners.putIfAbsent(url,
new ConcurrentHashMap<NotifyListener, ChildListener>());
listeners = zkListeners.get(url);
}
//獲取節點監聽器
ChildListener zkListener = listeners.get(listener);
//如果為空，則建立一個監聽器
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);
}
//建立節點
zkClient.create(path, false);
//訂閱節點path 資料變化，通知到zkListener
//即通知到ZookeeperRegistry.this.notify
List<String> children = zkClient.addChildListener(path, zkListener);
if (children != null) {
urls.addAll(toUrlsWithEmpty(url, path, children));
}
}
//通知
notify(url, listener, urls);
}
}
複製程式碼如上程式碼，重點就是通過註冊中心獲取到服務提供者的url，呼叫notify方法。同時還訂閱了服務提供者的節點資料變化，如果有變化也呼叫notify方法。
而在notify方法中，最終會根據url呼叫服務引用方法refer，再封裝成InvokerDelegate物件。
invoker = new InvokerDelegate<T>(protocol.refer(serviceType, url), url, providerUrl);
這樣不僅完成了本次的服務引用，而且當服務提供者上下線的時候，消費者也可以動態感知。
3、Listener和Filter
以DubboProtocol為例，它是Wrapper包裝類的物件，關於這一點我們一定要牢記。
回憶服務暴露的過程，我們可以監聽服務暴露的過程，在構建呼叫鏈的時候可以增加Filter。在這裡，服務引用也是一樣的。
- 服務引用監聽
在InvokerListener 介面中，有兩個方法。分別是服務引用後呼叫和服務銷燬時呼叫。
@SPI
public interface InvokerListener {
//服務引用
void referred(Invoker<?> invoker) throws RpcException;
//服務銷燬
void destroyed(Invoker<?> invoker);
}
複製程式碼我們先自定義監聽器，來實現介面的方法。
public class MyInvokerListener1 implements InvokerListener{
public void referred(Invoker<?> invoker) throws RpcException {
System.out.println("服務引用111.."+invoker.getUrl());
}
public void destroyed(Invoker<?> invoker) {
System.out.println("服務銷燬111.."+invoker.getUrl());
}
}
複製程式碼然後建立擴充套件點配置檔案，檔名稱為：
com.alibaba.dubbo.rpc.InvokerListener
內容為：
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("呼叫之前-----------");
Result result = invoker.invoke(invocation);
System.out.println("呼叫之後-----------");
return result;
}
}
複製程式碼然後建立擴充套件點配置檔案，檔名稱為：
com.alibaba.dubbo.rpc.Filter
內容為：
myfilter1=com.viewscenes.netsupervisor.filter.MyFilter
最後，修改XML配置檔案，說明自定義的過濾器在預設過濾器之前。
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);
//建立DubboInvoker物件
DubboInvoker<T> invoker = new DubboInvoker<T>(serviceType, url, client, invokers);
invokers.add(invoker);
return invoker;
}
}
複製程式碼這裡主要分為兩個步驟：
- 建立通訊客戶端
在getClients方法裡面，主要判斷是否為共享連線的客戶端。
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;
}
複製程式碼如果未配置，Dubbo預設建立共享連線客戶端。我們繼續看getSharedClient方法。
private ExchangeClient getSharedClient(URL url) {
//服務地址
String key = url.getAddress();
//查詢快取是否已經建立了客戶端
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物件，用於引用計數
client = new ReferenceCountExchangeClient(exchangeClient, ghostClientMap);
//放入快取並返回
referenceClientMap.put(key, client);
ghostClientMap.remove(key);
return client;
}
}
複製程式碼如上程式碼，先從快取中獲取客戶端，未命中則呼叫initClient方法初始化客戶端。並將它封裝成ReferenceCountExchangeClient 物件返回。在initClient方法中，設定客戶端型別、編解碼和心跳資訊，並呼叫connect建立客戶端。
private ExchangeClient initClient(URL url) {
//客戶端型別 預設為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 {
//建立連線客戶端
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會呼叫到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，它會呼叫到NettyClient的構造方法。最終呼叫doOpen和doConnect方法，連線通訊伺服器。
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();
//獲取伺服器地址，並連線
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 {
//設定當前Channel
NettyClient.this.channel = newChannel;
}
}
}
}
}
}
複製程式碼以上大部分都是Netty的程式碼，連線伺服器成功後獲取到Channel儲存。 我們重點看NettyHandler，它是事件處理器。這裡的messageReceived負責接收處理返回的訊息。接收到訊息後，通過執行緒池拿到執行緒去執行後續的處理。不同的是，這裡的執行緒池型別是CachedThreadPool ，即快取型執行緒池。
這裡的流程處理完畢，我們再把目光回到DubboInvoker，它通過一個構造方法返回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物件已經建立完畢。我們回到開頭的createProxy方法。最後一步是為這個Invoker物件建立代理。
五、建立代理
在Dubbo，預設使用Javassist來建立代理。
public class JavassistProxyFactory extends AbstractProxyFactory {
public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
//呼叫處理程式
InvocationHandler invocationHandler = new InvokerInvocationHandler(invoker)
//建立代理
return (T) Proxy.getProxy(interfaces).newInstance(invocationHandler);
}
}
複製程式碼建立的過程很簡單，我們主要來看InvocationHandler 。既然是代理物件，我們每次呼叫介面方法的時候，會呼叫到這個物件的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]);
}
//把請求的方法名和引數等封裝成RpcInvocation物件
//呼叫invoke
return invoker.invoke(new RpcInvocation(method, args)).recreate();
}
}
複製程式碼至此，服務引用的大體流程我們已經分析完了。我們再來總結一下它的過程：
- 通過Spring 工廠Bean或者afterPropertiesSet方法觸發引用方法
- 連線註冊中心，獲取服務提供者列表，建立invoker
- 訂閱服務提供者節點，資料變更時獲得通知
- 連線通訊伺服器，獲得客戶端
- 建立代理並返回
- 此時，dubbo:reference宣告的物件就是這個代理物件