服务暴露分为两种：本地暴露（暴露在JVM中,不需要网络通信）；远程暴露（将ip,端口等信息暴露给远程客户端,调用时需要网络通信）
1. 服务暴露起点
- 自定义XML文件解析
<!-- 声明需要暴露的服务接口 -->
<dubbo:service interface="com.test.dubbo.common.Iface" ref="demoService"/>
解析dubbo-service标签
registerBeanDefinitionParser("service", new DubboBeanDefinitionParser(ServiceBean.class, true));
由此可以看出，服务暴露的过程，也就是ServiceBean的创建过程。
-
ServiceBean
ServiceBean
从类图可以看出，ServiceBean和Spring的关系很大，它继承了InitializingBean和ApplicationEvent。在bean初始化完成后，会调用InitializingBean.afterPropertiesSet方法来执行服务暴露的准备工作。在spring的context完成初始化之后，会触发ApplicationEventListener事件，从而进行服务暴露。
2. ServiceBean.afterPropertiesSet
读取服务提供配置文件，初始化服务配置参数：protocol（dubbo 、hessian、http...) 、registry(注册中心类型: zk，地址，端口号)、monitor、module...
public void afterPropertiesSet() throws Exception {
if (getProvider() == null) {
...
setProvider(providerConfig);
...
}
if (getApplication() == null && (getProvider() == null || getProvider().getApplication() == null)) {
setApplication(applicationConfig);
}
//同样的方式，给config中setModule，setRegistry，setProtocol
}
3. ServiceBean.onApplicationEvent
在Spring的容器完成之后，开始export服务。
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
if (isDelay() && !isExported() && !isUnexported()) {
if (logger.isInfoEnabled()) {
logger.info("The service ready on spring started. service: " + getInterface());
}
export();
}
}
4. export 暴露服务
- doExport： check 参数
synchronized void doExport() {
//check 要暴露的类
checkInterfaceAndMethods(interfaceClass, methods);
checkRef();
checkApplication();
checkRegistry();
checkProtocol();
appendProperties(this);
checkStub(interfaceClass);
checkMock(interfaceClass);
...
//继续执行暴露流程
doExportUrls();
}
- doExportUrls
private void doExportUrls() {
//获取registry: 包含zk地址，application名，protocol
//比如：registry://127.0.0.1:2181/com.alibaba.dubbo.registry.RegistryService?application=dubboProvider&dubbo=2.0.2&pid=22016®istry=zookeeper×tamp=1561879716285
List<URL> registryURLs = loadRegistries(true);
//dubbo支持不同的protocol
for (ProtocolConfig protocolConfig : protocols) {
doExportUrlsFor1Protocol(protocolConfig, registryURLs);
}
}
- doExportUrlsFor1Protocol
private void doExportUrlsFor1Protocol(){
// 将参数保存到map中，下图是map中保存的值
// 如果scope没有配置成remote，则export到本地
if (!Constants.SCOPE_REMOTE.toString().equalsIgnoreCase(scope)) {
exportLocal(url);
}
//导出到远程
Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));
DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
Exporter<?> exporter = protocol.export(wrapperInvoker);
exporters.add(exporter);
}
map
5. 暴露服务到本地
生成Invoker，并将Invoker转换成Exporter
private void exportLocal(URL url) {
...
Exporter<?> exporter = protocol.export(proxyFactory.getInvoker(ref, (Class) interfaceClass, local));
exporters.add(exporter);
}
- 生成Invoker
默认使用JavassistProxyFactory 生成Invoker
@Override
public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
//Dubbo 使用 ClassGenerator 生成Wrapper类
final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);
// 采用动态代理的模式生成Invoker，将RPC的结果封装在动态代理中
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);
}
};
}
- Invoker转换成Exporter（使用的是DubboProtocol进行转换）
Exporter其实就是对Invoker进行了简单的封装。最重要的是要在这一步，完成Netty server端的开启，让server开始监听请求。
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
//创建一个Exporter
DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);
exporterMap.put(key, exporter);
// 开启Netty 服务端
openServer(url);
return exporter;
}
6. 暴露服务到远程
服务暴露到本地和服务暴露到远程最大的区别是：暴露到远程时，需要注册服务。
- RegistryProtocol
@Override
public <T> Exporter<T> export(){
//导出服务
final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker);
// 注册服务
if (register) {
register(registryUrl, registeredProviderUrl);
ProviderConsumerRegTable.getProviderWrapper(originInvoker).setReg(true);
}
}
- doLocalExport
这里依然使用DubboProtocol来export Invoker（和暴露到本地一样）
private <T> ExporterChangeableWrapper<T> doLocalExport(){
...
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 exporter;
}
- 注册服务register
使用zk客户端创建节点，并注册节点。在这里就不详细展开，后续会专门研究，如何创建注册节点。
@Override
protected void doRegister(URL url) {
try {
zkClient.create(toUrlPath(url), url.getParameter(Constants.DYNAMIC_KEY, true));
} catch (Throwable e) {
throw new RpcException("Failed to register " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
}
}
7. Protocol
在暴露服务的过程中，远程暴露和本地暴露使用的Protocol不一样，Dubbo是如何实现这一功能的.
- Protocol 接口
接口添加了SPI注解，并设置了默认值为dubbo. 同时还定义了export和refer两个接口方法。由于两个方法没有指定key，那么将会从方法的参数中取出URL，然后取出 key 为"protocol" 的value，从而确定实例化哪个Protocol bean。
@SPI("dubbo")
public interface Protocol {
@Adaptive
<T> Exporter<T> export(Invoker<T> invoker) throws RpcException;
@Adaptive
<T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;
}
- Protocol SPI 配置文件
filter=com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper
listener=com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper
mock=com.alibaba.dubbo.rpc.support.MockProtocol
dubbo=com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol
injvm=com.alibaba.dubbo.rpc.protocol.injvm.InjvmProtocol
rmi=com.alibaba.dubbo.rpc.protocol.rmi.RmiProtocol
hessian=com.alibaba.dubbo.rpc.protocol.hessian.HessianProtocol
com.alibaba.dubbo.rpc.protocol.http.HttpProtocol
com.alibaba.dubbo.rpc.protocol.webservice.WebServiceProtocol
thrift=com.alibaba.dubbo.rpc.protocol.thrift.ThriftProtocol
memcached=com.alibaba.dubbo.rpc.protocol.memcached.MemcachedProtocol
redis=com.alibaba.dubbo.rpc.protocol.redis.RedisProtocol
rest=com.alibaba.dubbo.rpc.protocol.rest.RestProtocol
registry=com.alibaba.dubbo.registry.integration.RegistryProtocol
qos=com.alibaba.dubbo.qos.protocol.QosProtocolWrapper
- 回到本地暴露和远程暴露的方法中
在本地暴露时：
本地暴露
远程暴露时：
远程暴露
- Protocol的自适应
在ServiceConfig中是这么定义Protocol的
private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
那么，Protocol选择哪个实例，是在根据方法的参数确定的。比如本地暴露时，URL中的"protocol" = "dubbo" 那么就是使用DubboProtocol来进行服务暴露；同理，在远程暴露时，就使用RegistryProtocol
