時序圖
在講解源碼前，先看下官方文檔提供的時序圖，后面的講解基本是這個路線，但是會更細節化
服務暴露.png
大致邏輯
首先服務的實現bean在我們的spring容器中，我們會創建一個Invoker通過代理調用ref中的方法，同時Invoker會在protocol的export方法中會轉換為Exporter，并且保存在protocol對象的exporterMap中，然后進行暴露。
重要概念
Protocol
Protocol 是服務域，它是 Invoker 暴露和引用的主功能入口，它負責 Invoker
的生命周期管理。
接口定義如下
@SPI("dubbo")
public interface Protocol {
/**
* 獲取缺省端口，當用戶沒有配置端口時使用。
*
* @return 缺省端口
*/
int getDefaultPort();
/**
* 暴露遠程服務：<br>
* 1. 協議在接收請求時，應記錄請求來源方地址信息：RpcContext.getContext().setRemoteAddress();<br>
* 2. export()必須是冪等的，也就是暴露同一個URL的Invoker兩次，和暴露一次沒有區別。<br>
* 3. export()傳入的Invoker由框架實現并傳入，協議不需要關心。<br>
*
* @param <T> 服務的類型
* @param invoker 服務的執行體
* @return exporter 暴露服務的引用，用于取消暴露
* @throws RpcException 當暴露服務出錯時拋出，比如端口已占用
*/
@Adaptive
<T> Exporter<T> export(Invoker<T> invoker) throws RpcException;
/**
* 引用遠程服務：<br>
* 1. 當用戶調用refer()所返回的Invoker對象的invoke()方法時，協議需相應執行同URL遠端export()傳入的Invoker對象的invoke()方法。<br>
* 2. refer()返回的Invoker由協議實現，協議通常需要在此Invoker中發送遠程請求。<br>
* 3. 當url中有設置check=false時，連接失敗不能拋出異常，并內部自動恢復。<br>
*
* @param <T> 服務的類型
* @param type 服務的類型
* @param url 遠程服務的URL地址
* @return invoker 服務的本地代理
* @throws RpcException 當連接服務提供方失敗時拋出
*/
@Adaptive
<T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;
/**
* 釋放協議：<br>
* 1. 取消該協議所有已經暴露和引用的服務。<br>
* 2. 釋放協議所占用的所有資源，比如連接和端口。<br>
* 3. 協議在釋放后，依然能暴露和引用新的服務。<br>
*/
void destroy();
}
Invoker
Invoker 是實體域，它是 Dubbo 的核心模型，其它模型都向它靠擾，或轉換成
它，它代表一個可執行體，可向它發起 invoke 調用，它有可能是一個本地的
實現，也可能是一個遠程的實現，也可能一個集群實現。
接口定義如下
public interface Invoker<T> extends Node {
Class<T> getInterface();
Result invoke(Invocation invocation) throws RpcException;
}
Invocation
Invocation 是會話域，它持有調用過程中的變量，比如方法名，參數等。
接口定義如下
public interface Invocation {
String getMethodName();
Class<?>[] getParameterTypes();
Object[] getArguments();
Map<String, String> getAttachments();
String getAttachment(String key);
String getAttachment(String key, String defaultValue);
Invoker<?> getInvoker();
}
Exporter
Exporter用來封裝不同協議暴露的Invoker，因為Invoker可以被多個Protocol暴露，因為每種Protocol都有各自的Exproter子類
接口定義如下
public interface Exporter<T> {
Invoker<T> getInvoker();
void unexport();
}
我的一些定義
本地暴露
本地暴露分為兩種，通過遠程協議還是本地協議暴露
本地協議的話，基于進程通信，所以不需要進行遠程暴露，具體實現只有InjvmProtocol
而基于遠程協議的暴露，需要開啟服務監聽，處理其他進程發來的rpc請求，同時可以選擇進行遠程暴露，具體實現有DubboProtocol，HessianProtocol等
遠程暴露
遠程暴露，就是將本地暴露的url發布到注冊中心，這個暴露為了讓服務引用者感知到服務的存在
遠程暴露對應RegistryProtocol
遠程暴露URL和本地暴露URL
進行遠程暴露的時候，要先進行本地暴露，所以遠程暴露URL里面有一個export參數會包含本地暴露URL
遠程暴露URL主要是用來選擇暴露的注冊中心，注冊本地暴露URL，以及增加事件監聽
源碼分析
解析配置
先看下我們平時是如何配置dubbo服務暴露的
<dubbo:service interface="com.alibaba.dubbo.demo.bid.BidService" ref="bidService" protocol="dubbo" />
上面的配置會通過自定義解析器DubboNamespaceHandler解析到ServiceBean對象
registerBeanDefinitionParser("service", new DubboBeanDefinitionParser(ServiceBean.class, true));
然后在ServiceBean初始化完成后進行服務暴露
image.png
可以看到ServiceBean實現了Initializing接口，可以在afterPropertiesSet看到服務暴露的邏輯
if (! isDelay()) {
export();
}
這邊的Delay并不是服務具體的暴露行為進行延遲，而是控制這個暴露行為在什么時候觸發
private boolean isDelay() {
Integer delay = getDelay();
ProviderConfig provider = getProvider();
if (delay == null && provider != null) {
delay = provider.getDelay();
}
return supportedApplicationListener && (delay == null || delay.intValue() == -1);
}
上述代碼的意思是，如果支持Spring的事件監聽，并且沒有配置延遲暴露，推遲到容器refresh完成的時候觸發服務暴露邏輯，如果配置了delay,那么直接在afterPropertiesSet內調用暴露方法
我理解為一個是容器級別的delay，一個是服務級別的delay
export方法
export方法在ServiceConfig中
public synchronized void export() {
if (provider != null) {
if (export == null) {
export = provider.getExport();
}
if (delay == null) {
delay = provider.getDelay();
}
}
if (export != null && ! export.booleanValue()) {
return;
}
if (delay != null && delay > 0) {
Thread thread = new Thread(new Runnable() {
public void run() {
try {
Thread.sleep(delay);
} catch (Throwable e) {
}
doExport();
}
});
thread.setDaemon(true);
thread.setName("DelayExportServiceThread");
thread.start();
} else {
doExport();
}
}
這邊會根據是否配置了delay參數，進行延遲暴露，通過線程休眠來實現
doExport方法涉及很多參數的校驗與設置，遇到具體功能點再做分析，具體暴露邏輯調用了方法doExportUrls
private void doExportUrls() {
List<URL> registryURLs = loadRegistries(true);
for (ProtocolConfig protocolConfig : protocols) {
doExportUrlsFor1Protocol(protocolConfig, registryURLs);
}
}
doExportUrls方法首先會獲取注冊中心的URL，雖說可以配置很多個注冊中心，但是我們就把它當成一個好了
然后根據service配置的不同協議，調用doExportUrlsFor1Protocol方法分別進行暴露
在doExportUrlsFor1Protocol的前半部分又是各種參數的提取，用來生成最終暴露的URL，我們關注核心的暴露邏輯
//1
URL url = new URL(name, host, port, (contextPath == null || contextPath.length() == 0 ? "" : contextPath + "/") + path, map);
if (ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
.hasExtension(url.getProtocol())) {
url = ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
.getExtension(url.getProtocol()).getConfigurator(url).configure(url);
}
//2
String scope = url.getParameter(Constants.SCOPE_KEY);
//配置為none不暴露
if (! Constants.SCOPE_NONE.toString().equalsIgnoreCase(scope)) {
//配置不是remote的情況下做本地暴露 (配置為remote，則表示只暴露遠程服務)
//3
if (!Constants.SCOPE_REMOTE.toString().equalsIgnoreCase(scope)) {
exportLocal(url);
}
//如果配置不是local則暴露為遠程服務.(配置為local，則表示只暴露遠程服務)
//4
if (! Constants.SCOPE_LOCAL.toString().equalsIgnoreCase(scope) ){
if (logger.isInfoEnabled()) {
logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);
}
//5
if (registryURLs != null && registryURLs.size() > 0
&& url.getParameter("register", true)) {
for (URL registryURL : registryURLs) {
url = url.addParameterIfAbsent("dynamic", registryURL.getParameter("dynamic"));
URL monitorUrl = loadMonitor(registryURL);
if (monitorUrl != null) {
url = url.addParameterAndEncoded(Constants.MONITOR_KEY, monitorUrl.toFullString());
}
if (logger.isInfoEnabled()) {
logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL);
}
Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));
Exporter<?> exporter = protocol.export(invoker);
exporters.add(exporter);
}
} else {
Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, url);
Exporter<?> exporter = protocol.export(invoker);
exporters.add(exporter);
}
}
}
this.urls.add(url);
注意上面代碼1處，就是使用之前提取的參數生成本地暴露url的邏輯
而代碼2處的scope也還是比較重要的，它控制了服務應該怎么暴露，我們項目中一般對service不進行scope配置，那么取到的值為null，代碼3和代碼4的條件都會滿足，既會進行本地協議的本地暴露，也會進行遠程暴露
而代碼5，我們可以配置register="false",直接進行遠程協議的本地暴露，不記錄到注冊中心上去，但是我們還是可以通過在消費者強制配置url來調用
<dubbo:service interface="com.alibaba.dubbo.demo.bid.BidService" ref="bidService" protocol="dubbo" register="false"/>
服務暴露的邏輯其實是同一套
Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, url);
Exporter<?> exporter = protocol.export(invoker);
主要的區別點還是在于Url的不同，因為url帶了不同的protocol以及其他配置，然后具體暴露時，使用之前講的SPI來調用不同實現
比如在exportLocal方法里，其實會把url的protocol修改為injvm
private void exportLocal(URL url) {
if (!Constants.LOCAL_PROTOCOL.equalsIgnoreCase(url.getProtocol())) {
//修改protocol為Injvm
URL local = URL.valueOf(url.toFullString())
.setProtocol(Constants.LOCAL_PROTOCOL)
.setHost(NetUtils.LOCALHOST)
.setPort(0);
// modified by lishen
ServiceClassHolder.getInstance().pushServiceClass(getServiceClass(ref));
Exporter<?> exporter = protocol.export(
proxyFactory.getInvoker(ref, (Class) interfaceClass, local));
exporters.add(exporter);
logger.info("Export dubbo service " + interfaceClass.getName() +" to local registry");
}
}
在存在注冊中心，并且服務的Registry屬性不為false的情況下會進行遠程暴露，會在注冊中心url的export參數帶上原先的本地暴露url進行遠程暴露，因此暴露使用的protocol也相應變為RegistryProtocol
Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));
下面講解具體暴露的邏輯
ref轉換為Invoker
在進行暴露之前，我們需要將spring容器內的接口實現ref轉換為invoker，通過proxyFactory.getInvoker(ref, (Class) interfaceClass, local)方法
proxyFactory是一個擴展點，有javaassist和jdk動態代理兩種實現，默認實現為javaassist，并且提供一個包裝類StubProxyFactoryWrapper用于提供降級服務(以后單獨講解)
public class JavassistProxyFactory extends AbstractProxyFactory {
@SuppressWarnings("unchecked")
public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
}
public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
// TODO Wrapper類不能正確處理帶$的類名
final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);
return new AbstractProxyInvoker<T>(proxy, type, url) {
@Override
protected Object doInvoke(T proxy, String methodName,
Class<?>[] parameterTypes,
Object[] arguments) throws Throwable {
return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
}
};
}
}
JavassistProxyFactory 中的Wapper類是動態生成的，可以針對接口的每個方法生成直接調用的代碼，避免了反射，因為做了緩存，多次調用的情況下，會加快效率，而jdk實現用的反射效率應該差多了
//JdkProxyFactory的AbstractProxyInvoker實現
return new AbstractProxyInvoker<T>(proxy, type, url) {
@Override
protected Object doInvoke(T proxy, String methodName,
Class<?>[] parameterTypes,
Object[] arguments) throws Throwable {
Method method = proxy.getClass().getMethod(methodName, parameterTypes);
return method.invoke(proxy, arguments);
}
};
通過proxyFactory我們會得到一個父類為AbstractProxyInvoker的匿名Invoker類，內部通過反射或者動態生成字節碼來調用目標ref的方法
通過protocol暴露
在得到Invoker后，我們通過protocol去進行服務暴露，暴露成功后得到Exporter引用
<T> Exporter<T> export(Invoker<T> invoker) throws RpcException;
通過Protocol的export方法，需要將invoker轉換為exporter，為什么？
因為Invoker只負責對具體方法的調用，但是方法的調用可以暴露到多個Protocol，所以需要有具體的Exporter來對應,比如Dubbo暴露得到DubboExporter，injvm暴露得到InjvmExporter
下面講解每種protocol的暴露
通過InjvmProtocol暴露
InjvmProtocol是本地暴露中唯一使用本地協議的，意思就是說這個服務的url不能發布到注冊中心，只能本地消費，在dubbo引用服務的邏輯中，如果發現本地InjvmProtocol中有所需要的Exproter，會優先選擇引用本地
看下暴露的代碼
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
return new InjvmExporter<T>(invoker, invoker.getUrl().getServiceKey(), exporterMap);
}
exporterMap為InjvmProtocol繼承AbstractProtocol的一個參數，用來保存Exproter引用，同時exporterMap也會在InjvmExporter內被引用，主要用于卸載功能
class InjvmExporter<T> extends AbstractExporter<T> {
private final String key;
private final Map<String, Exporter<?>> exporterMap;
InjvmExporter(Invoker<T> invoker, String key, Map<String, Exporter<?>> exporterMap){
super(invoker);
this.key = key;
this.exporterMap = exporterMap;
exporterMap.put(key, this);
}
public void unexport() {
super.unexport();
exporterMap.remove(key);
}
}
關于這個exporterMap，由于每個Protocol實現都繼承了AbstractProtocol，所以都會有exporterMap屬性，并且每種Protocol在容器內只存在一個，我們可以在每個Protocol對象的exporterMap中拿到這個Protocol暴露的所有Exproter
通過RegistryProtocol暴露
這是遠程暴露，在進行本地暴露的同時將本地暴露的url注冊到注冊中心同時也注冊事件監聽
public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
//export invoker
//1
final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker);
//registry provider
final Registry registry = getRegistry(originInvoker);
final URL registedProviderUrl = getRegistedProviderUrl(originInvoker);
registry.register(registedProviderUrl);
// 訂閱override數據
// FIXME 提供者訂閱時，會影響同一JVM即暴露服務，又引用同一服務的的場景，因為subscribed以服務名為緩存的key，導致訂閱信息覆蓋。
final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registedProviderUrl);
final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl);
overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
//注冊監聽事件，用于url被修改時回調，進行exporter重新暴露
registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
//保證每次export都返回一個新的exporter實例
return new Exporter<T>() {
public Invoker<T> getInvoker() {
return exporter.getInvoker();
}
public void unexport() {
try {
exporter.unexport();
} catch (Throwable t) {
logger.warn(t.getMessage(), t);
}
try {
registry.unregister(registedProviderUrl);
} catch (Throwable t) {
logger.warn(t.getMessage(), t);
}
try {
overrideListeners.remove(overrideSubscribeUrl);
registry.unsubscribe(overrideSubscribeUrl, overrideSubscribeListener);
} catch (Throwable t) {
logger.warn(t.getMessage(), t);
}
}
};
}
注意代碼1處，有一個本地暴露，看下代碼
private <T> ExporterChangeableWrapper<T> doLocalExport(final Invoker<T> originInvoker){
String key = getCacheKey(originInvoker);
ExporterChangeableWrapper<T> exporter = (ExporterChangeableWrapper<T>) bounds.get(key);
if (exporter == null) {
synchronized (bounds) {
exporter = (ExporterChangeableWrapper<T>) bounds.get(key);
if (exporter == null) {
final Invoker<?> invokerDelegete = new InvokerDelegete<T>(originInvoker, getProviderUrl(originInvoker));
exporter = new ExporterChangeableWrapper<T>((Exporter<T>)protocol.export(invokerDelegete), originInvoker);
bounds.put(key, exporter);
}
}
}
return (ExporterChangeableWrapper<T>) exporter;
}
getProviderUrl用于從遠程暴露url中的export參數中獲取本地暴露的url
private URL getProviderUrl(final Invoker<?> origininvoker){
String export = origininvoker.getUrl().getParameterAndDecoded(Constants.EXPORT_KEY);
if (export == null || export.length() == 0) {
throw new IllegalArgumentException("The registry export url is null! registry: " + origininvoker.getUrl());
}
URL providerUrl = URL.valueOf(export);
return providerUrl;
}
export參數對應的url才是需要實際本地暴露的，而作為export方法的遠程暴露url只是為了注冊提供者url到注冊中心以及增加事件監聽
同時注意一下bounds參數的校驗是為了防止同一個invoker重復暴露，而ExporterChangeableWrapper封裝是為了zookeeper中url發生改變時能修改Exporter
在完成本地暴露之后，會通過遠程暴露url獲取注冊中心對象，然后把本地暴露url注冊上去，同時也會給zookeeper中本地暴露url對應路徑注冊監聽器，用于監聽zookeeper上面的暴露url發生變化的時候，重新export（比如我們的控制臺可以對參數進行調整）
最后把export返回
通過DubboProtocol暴露
DubboProtocol是使用遠程協議的本地暴露，所以可以將暴露url注冊到注冊中心
看下它的export方法
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
URL url = invoker.getUrl();
// export service.
String key = serviceKey(url);
DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);
exporterMap.put(key, exporter);
//export an stub service for dispaching event
Boolean isStubSupportEvent = url.getParameter(Constants.STUB_EVENT_KEY,Constants.DEFAULT_STUB_EVENT);
Boolean isCallbackservice = url.getParameter(Constants.IS_CALLBACK_SERVICE, false);
if (isStubSupportEvent && !isCallbackservice){
String stubServiceMethods = url.getParameter(Constants.STUB_EVENT_METHODS_KEY);
if (stubServiceMethods == null || stubServiceMethods.length() == 0 ){
if (logger.isWarnEnabled()){
logger.warn(new IllegalStateException("consumer [" +url.getParameter(Constants.INTERFACE_KEY) +
"], has set stubproxy support event ,but no stub methods founded."));
}
} else {
stubServiceMethodsMap.put(url.getServiceKey(), stubServiceMethods);
}
}
openServer(url);
// modified by lishen
optimizeSerialization(url);
return exporter;
}
首先會把invoker轉換為DubboExporter，放到exporterMap中
然后有一些stub的邏輯，這個以后單獨再講
接下來就是打開netty服務，用于監聽服務引用者的請求，打開服務器邏輯在openServer中
private void openServer(URL url) {
// find server.
String key = url.getAddress();
//client 也可以暴露一個只有server可以調用的服務。
boolean isServer = url.getParameter(Constants.IS_SERVER_KEY,true);
if (isServer) {
ExchangeServer server = serverMap.get(key);
if (server == null) {
serverMap.put(key, createServer(url));
} else {
//server支持reset,配合override功能使用
server.reset(url);
}
}
}
從String key = url.getAddress();以及ExchangeServer server = serverMap.get(key);可以看出來在一個應用中，netty服務器針對每種協議只會起一個，因為每種協議只能配置一個端口
而reset方法，會使用之后暴露url的參數，覆蓋已經開啟netty服務內的參數
那么我們的服務器是怎么處理接收的rpc請求并調用對應exporter調用呢，進入createServer方法我們可以看到會netty服務的開啟時會綁定一個requestHandler
private ExchangeServer createServer(URL url) {
//默認開啟server關閉時發送readonly事件
url = url.addParameterIfAbsent(Constants.CHANNEL_READONLYEVENT_SENT_KEY, Boolean.TRUE.toString());
//默認開啟heartbeat
url = url.addParameterIfAbsent(Constants.HEARTBEAT_KEY, String.valueOf(Constants.DEFAULT_HEARTBEAT));
String str = url.getParameter(Constants.SERVER_KEY, Constants.DEFAULT_REMOTING_SERVER);
if (str != null && str.length() > 0 && ! ExtensionLoader.getExtensionLoader(Transporter.class).hasExtension(str))
throw new RpcException("Unsupported server type: " + str + ", url: " + url);
url = url.addParameter(Constants.CODEC_KEY, Version.isCompatibleVersion() ? COMPATIBLE_CODEC_NAME : DubboCodec.NAME);
ExchangeServer server;
try {
//1 綁定requestHandler
server = Exchangers.bind(url, requestHandler);
} catch (RemotingException e) {
throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);
}
str = url.getParameter(Constants.CLIENT_KEY);
if (str != null && str.length() > 0) {
Set<String> supportedTypes = ExtensionLoader.getExtensionLoader(Transporter.class).getSupportedExtensions();
if (!supportedTypes.contains(str)) {
throw new RpcException("Unsupported client type: " + str);
}
}
return server;
}
這個requestHandler就是用來處理接收到的rpc調用請求的，看下它內部的邏輯
private ExchangeHandler requestHandler = new ExchangeHandlerAdapter() {
public Object reply(ExchangeChannel channel, Object message) throws RemotingException {
if (message instanceof Invocation) {
Invocation inv = (Invocation) message;
//通過inv獲取對應invoker
Invoker<?> invoker = getInvoker(channel, inv);
//如果是callback 需要處理高版本調用低版本的問題
if (Boolean.TRUE.toString().equals(inv.getAttachments().get(IS_CALLBACK_SERVICE_INVOKE))){
String methodsStr = invoker.getUrl().getParameters().get("methods");
boolean hasMethod = false;
if (methodsStr == null || methodsStr.indexOf(",") == -1){
hasMethod = inv.getMethodName().equals(methodsStr);
} else {
String[] methods = methodsStr.split(",");
for (String method : methods){
if (inv.getMethodName().equals(method)){
hasMethod = true;
break;
}
}
}
if (!hasMethod){
logger.warn(new IllegalStateException("The methodName "+inv.getMethodName()+" not found in callback service interface ,invoke will be ignored. please update the api interface. url is:" + invoker.getUrl()) +" ,invocation is :"+inv );
return null;
}
}
RpcContext.getContext().setRemoteAddress(channel.getRemoteAddress());
//用invoker執行調用，返回結果
return invoker.invoke(inv);
}
throw new RemotingException(channel, "Unsupported request: " + message == null ? null : (message.getClass().getName() + ": " + message) + ", channel: consumer: " + channel.getRemoteAddress() + " --> provider: " + channel.getLocalAddress());
}
@Override
public void received(Channel channel, Object message) throws RemotingException {
if (message instanceof Invocation) {
reply((ExchangeChannel) channel, message);
} else {
super.received(channel, message);
}
}
@Override
public void connected(Channel channel) throws RemotingException {
invoke(channel, Constants.ON_CONNECT_KEY);
}
@Override
public void disconnected(Channel channel) throws RemotingException {
if(logger.isInfoEnabled()){
logger.info("disconected from "+ channel.getRemoteAddress() + ",url:" + channel.getUrl());
}
invoke(channel, Constants.ON_DISCONNECT_KEY);
}
private void invoke(Channel channel, String methodKey) {
Invocation invocation = createInvocation(channel, channel.getUrl(), methodKey);
if (invocation != null) {
try {
received(channel, invocation);
} catch (Throwable t) {
logger.warn("Failed to invoke event method " + invocation.getMethodName() + "(), cause: " + t.getMessage(), t);
}
}
}
private Invocation createInvocation(Channel channel, URL url, String methodKey) {
String method = url.getParameter(methodKey);
if (method == null || method.length() == 0) {
return null;
}
RpcInvocation invocation = new RpcInvocation(method, new Class<?>[0], new Object[0]);
invocation.setAttachment(Constants.PATH_KEY, url.getPath());
invocation.setAttachment(Constants.GROUP_KEY, url.getParameter(Constants.GROUP_KEY));
invocation.setAttachment(Constants.INTERFACE_KEY, url.getParameter(Constants.INTERFACE_KEY));
invocation.setAttachment(Constants.VERSION_KEY, url.getParameter(Constants.VERSION_KEY));
if (url.getParameter(Constants.STUB_EVENT_KEY, false)){
invocation.setAttachment(Constants.STUB_EVENT_KEY, Boolean.TRUE.toString());
}
return invocation;
}
};
這邊主要講下replay方法，這個方法用來處理用戶的rpc請求，請求的序列化dubbo封裝的netty服務已經處理，所在在這個方法傳入的message直接就是Invocation對象，在getInvoker中，通過invocation對象可以我們可以生成exporterMap的key，用來拿到對應的Exporter
Invoker<?> getInvoker(Channel channel, Invocation inv) throws RemotingException{
boolean isCallBackServiceInvoke = false;
boolean isStubServiceInvoke = false;
int port = channel.getLocalAddress().getPort();
String path = inv.getAttachments().get(Constants.PATH_KEY);
//如果是客戶端的回調服務.
isStubServiceInvoke = Boolean.TRUE.toString().equals(inv.getAttachments().get(Constants.STUB_EVENT_KEY));
if (isStubServiceInvoke){
port = channel.getRemoteAddress().getPort();
}
//callback
isCallBackServiceInvoke = isClientSide(channel) && !isStubServiceInvoke;
if(isCallBackServiceInvoke){
path = inv.getAttachments().get(Constants.PATH_KEY)+"."+inv.getAttachments().get(Constants.CALLBACK_SERVICE_KEY);
inv.getAttachments().put(IS_CALLBACK_SERVICE_INVOKE, Boolean.TRUE.toString());
}
String serviceKey = serviceKey(port, path, inv.getAttachments().get(Constants.VERSION_KEY), inv.getAttachments().get(Constants.GROUP_KEY));
//2 通過invocation生成的key獲取exporter
DubboExporter<?> exporter = (DubboExporter<?>) exporterMap.get(serviceKey);
if (exporter == null)
throw new RemotingException(channel, "Not found exported service: " + serviceKey + " in " + exporterMap.keySet() + ", may be version or group mismatch " + ", channel: consumer: " + channel.getRemoteAddress() + " --> provider: " + channel.getLocalAddress() + ", message:" + inv);
//轉換為invoker
return exporter.getInvoker();
}
拿到Exporter之后，轉換為Invoker,直接調用invoke方法返回Result，之后返回給調用者的序列化等邏輯dubbo封裝的netty服務也幫我們處理了，我們不用關注
這章主要講解的是服務暴露，關于netty服務的實現不多分析(我也還沒怎么看過)，理解這個requestHandler處理器即可，知道它會怎么處理rpc請求對應的Invocation即可，什么序列化，加密解密全都當作黑盒。
服務引用，下章見
