概览
dubbo暴露服务有两种情况,一种是设置了延迟暴露(比如delay=”5000”),另外一种是没有设置延迟暴露或者延迟设置为-1(delay=”-1”):
- 设置了延迟暴露,dubbo在Spring实例化bean(initializeBean)的时候会对实现了InitializingBean的类进行回调,回调方法是afterPropertySet()。ServiceBean实现了如果InitializingBean接口,重写了afterPropertySet()方法。如果设置了延迟暴露,dubbo在这个方法中进行服务的发布。
- 没有设置延迟或者延迟为-1,dubbo会在Spring实例化完bean之后,在刷新容器最后一步发布ContextRefreshEvent事件的时候,通知实现了ApplicationListener的类进行回调onApplicationEvent,dubbo会在这个方法中发布服务。(ServiceBean实现了ApplicationListener接口)
但是不管延迟与否,都是使用ServiceConfig的export()方法进行服务的暴露。使用export初始化的时候会将Bean对象转换成URL格式,所有Bean属性转换成URL的参数。
暴露流程
- 首先将服务的实现封装成一个Invoker,Invoker中封装了服务的实现类。
- 将Invoker封装成Exporter,并缓存起来,缓存里使用Invoker的url作为key。
- 服务端Server启动,监听端口。(请求来到时,根据请求信息生成key,到缓存查找Exporter,就找到了Invoker,就可以完成调用。)
Spring容器初始化调用
当Spring容器实例化bean完成,走到最后一步发布ContextRefreshEvent事件的时候,ServiceBean会执行onApplicationEvent方法,该方法调用ServiceConfig的export方法,从而进行服务的暴露。
export的步骤简介
- 首先会检查各种配置信息,填充各种属性,总之就是保证我在开始暴露服务之前,所有的东西都准备好了,并且是正确的。
- 加载所有的注册中心,因为我们暴露服务需要注册到注册中心中去。
- 根据配置的所有协议和注册中心url分别进行服务暴露,暴露为 本地服务 或者 远程服务
3.1 不管是本地还是远程服务暴露,首先都会获取Invoker。
3.2 获取完Invoker之后,转换成对外的Exporter,缓存起来。
加载所有的注册中心
export方法先判断是否需要延迟暴露,如果是不延迟暴露,会执行doExport方法。
doExport方法先执行一系列的检查方法,然后调用doExportUrls方法。
doExportUrls方法先调用loadRegistries获取所有的注册中心url。
private void doExportUrls() {
List<URL> registryURLs = loadRegistries(true);
for (ProtocolConfig protocolConfig : protocols) {
doExportUrlsFor1Protocol(protocolConfig, registryURLs);
}
}
url如下:
registry://127.0.0.1:2181/com.alibaba.dubbo.registry.RegistryService?application=springProviderApplication&check=false&compiler=javassist&dubbo=2.0.2&logger=slf4j&organization=huangyuan&owner=huangyuan&pid=1689®ister=true®istry=zookeeper&session=60000&subscribe=true×tamp=1544326825698
根据配置的协议进行服务暴露
然后遍历调用doExportUrlsFor1Protocol方法。doExportUrlsFor1Protocol根据不同的协议将服务转换为URL形式,一些配置参数会附在URL后面。
根据scope的值,进行服务暴露。
- 如果scope配置为none则不暴露,
- 如果服务未配置成remote,则本地暴露exportLocal;
- 如果未配置成local,则暴露远程服务。
疑惑点:
(1)scope的值默认是null,按照代码的逻辑,会进行本地暴露,又进行远程暴露,为什么呢?
(2)关于(1)的解答,我觉得既然用户不设置为“不暴露”,也不设置为“只暴露远程服务”,也不设置为“只暴露本地服务”,那么dubbo就认为所以都需要进行暴露。
如果是暴露远程服务,则经过上面的操作之后,url变成:
dubbo://192.168.1.4:23801/com.huang.yuan.api.service.DemoService2?anyhost=true&application=springProviderApplication&bind.ip=192.168.1.4&bind.port=23801&compiler=javassist&default.cluster=failover&default.delay=-1&default.loadbalance=random&default.proxy=javassist&default.retries=2&default.serialization=hessian2&default.timeout=3000&delay=-1&dubbo=2.0.2&generic=false&interface=com.huang.yuan.api.service.DemoService2&logger=slf4j&methods=demoTest&organization=huangyuan&owner=huangyuan&pid=1831&revision=1.0-SNAPSHOT&side=provider×tamp=1544327969839&version=1.0
暴露为远程服务
先获取Invoker,然后导出成Exporter
// 根据服务具体实现,实现接口,以及registryUrl通过ProxyFactory将XXXServiceImpl封装成一个本地执行的Invoker
// invoker是对具体实现的一种代理。
Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));
// 使用Protocol将invoker导出成一个Exporter
// 暴露封装服务invoker
// 调用Protocol生成的适配类的export方法
Exporter<?> exporter = protocol.export(invoker);
暴露远程服务时的获取Invoker过程
这里会调用com.alibaba.dubbo.rpc.proxy.javassist.JavassistProxyFactory#getInvoker获取
public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
// 封装一个Wrapper类,如果类是以$开头,就使用接口类型获取,其他的使用实现类获取
final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);
// 返回一个Invoker实例,doInvoke方法中直接返回 wrapper的invokeMethod
// 关于生成的wrapper,请看下面列出的生成的代码,其中invokeMethod方法中就有实现类对实际方法的调用
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);
}
};
}
这里生成Wrapper对象,利用了javasisst动态代理技术,生成的代码如下:
public Object invokeMethod(Object o, String n, Class[] p, Object[] v) {
// 持有实际对象的引用
com.huang.yuan.dubbo.service.impl.DemoService2Impl w;
// 获取实际调用对象(进行类型转换)
w = ((com.huang.yuan.dubbo.service.impl.DemoService2Impl)$1);
// 执行真正的方法调用 (demoTest是接口中真正需要执行的方法)
w.demoTest((java.lang.String)$4[0]); }
由此可见,Invoker执行方法的时候,会调用doInvoke方法,会调用Wrapper的invokeMethod,这个方法中会有的实现类调用真实方法的代码。
(代码可以从com.alibaba.dubbo.common.bytecode.Wrapper#makeWrapper中获得)
本地暴露
private void exportLocal(URL url) {
if (!Constants.LOCAL_PROTOCOL.equalsIgnoreCase(url.getProtocol())) {
// 这时候转成本地暴露的url:injvm://127.0.0.1/dubbo.common.hello.service.HelloService?anyhost=true&......
URL local = URL.valueOf(url.toFullString())
.setProtocol(Constants.LOCAL_PROTOCOL)
.setHost(NetUtils.LOCALHOST)
.setPort(0);
// 首先还是先获得Invoker,然后导出成Exporter,并缓存
// 这里的proxyFactory实际是JavassistProxyFactory
// 导出expter使用com.alibaba.dubbo.rpc.protocol.injvm.InjvmProtocol#export
Exporter<?> exporter = protocol.export(
proxyFactory.getInvoker(ref, (Class) interfaceClass, local));
exporters.add(exporter);
logger.info("Export dubbo service " + interfaceClass.getName() +" to local registry");
}
}
到这里就把url转成了Invoker对象
导出Invoker为Exporter
Registry类型的Invoker处理过程
org.apache.dubbo.registry.integration.RegistryProtocol#export方法
@Override
public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
// 将invoker转成exporter
final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker);
// 获取RegistryUrl
URL registryUrl = getRegistryUrl(originInvoker);
/*
* 根据invoker中的url获取Registry实例
* 并且连接到注册中心
* 此时提供者作为消费者 引用 注册中心的核心服务 RegistryService
*/
final Registry registry = getRegistry(originInvoker);
//注册到注册中心的URL,如 dubb://XXXXX
final URL registeredProviderUrl = getRegisteredProviderUrl(originInvoker);
// 判断是否延迟发布
boolean register = registeredProviderUrl.getParameter("register", true);
// 将originInvoker加入本地缓存
ProviderConsumerRegTable.registerProvider(originInvoker, registryUrl, registeredProviderUrl);
if (register) {
/*
* 调用远端注册中心的register方法进行服务注册
* 若有消费者订阅此服务,则推送消息让消费者引用此服务。
* 注册中心缓存了所有提供者注册的服务以供消费者发现。
*/
register(registryUrl, registeredProviderUrl);
ProviderConsumerRegTable.getProviderWrapper(originInvoker).setReg(true);
}
/*
* 订阅override数据
*
* 提供者订阅时,会影响 同一JVM即暴露服务,又引用同一服务的的场景,
* 因为subscribed以服务名为缓存的key,导致订阅信息覆盖。
*/
final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registeredProviderUrl);
final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);
overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
/*
* 提供者向注册中心订阅所有注册服务
* 当注册中心有此服务的覆盖配置注册进来时,推送消息给提供者,重新暴露服务,这由管理页面完成。
*/
registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
/*
* 保证每次export都返回一个新的exporter实例
* 返回暴露后的Exporter给上层ServiceConfig进行缓存,便于后期撤销暴露。
*/
return new DestroyableExporter<T>(exporter, originInvoker, overrideSubscribeUrl, registeredProviderUrl);
}
将invoker转成exporter
## org.apache.dubbo.registry.integration.RegistryProtocol#doLocalExport方法
private <T> ExporterChangeableWrapper<T> doLocalExport(final Invoker<T> originInvoker) {
// 调用代码中的protocol.export方法,会根据协议名选择调用具体的实现类
// 这里会调用 DubboProtocol 的export方法
// 导出完之后,返回一个新的ExporterChangeableWrapper实例
exporter = new ExporterChangeableWrapper<T>((Exporter<T>) protocol.export(invokerDelegete), originInvoker);
......
}
DubboProtocol的export方法实现:
@Override
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
// 获取需要暴露的url
URL url = invoker.getUrl();
/*
* 通过url获取key
*
* key的例子:com.huang.yuan.api.service.DemoService2:1.0:23801
* 在服务调用的时候,同样通过这个key获取exporter
*/
String key = serviceKey(url);
// 生成exporter实例
DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);
// 缓存exporter
exporterMap.put(key, exporter);
/*
* todo 没理解 Constants.STUB_EVENT_KEY
* 是否支持本地存根
* 项目使用远程服务后,客户端通常只剩下接口,而实现全在服务器端
*
* 但提供方有些时候想在客户端也执行部分逻辑,
* 比如:做ThreadLocal缓存,提前验证参数,调用失败后伪造容错数据等等,此时就需要在API中带上Stub
*
* 客户端生成Proxy实例,会把Proxy通过构造函数传给Stub,然后把Stub暴露给用户,Stub可以决定要不要去调Proxy
*/
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);
}
}
// 根据URL绑定IP与端口,建立NIO框架的Server
openServer(url);
optimizeSerialization(url);
return exporter;
}
获取Register实例
/*
* 根据invoker中的url获取Registry实例
* 并且连接到注册中心
* 此时提供者作为消费者 引用 注册中心的核心服务 RegistryService
*/
final Registry registry = getRegistry(originInvoker);
具体的操作在中org.apache.dubbo.registry.integration.RegistryProtocol
/**
* 根据invoker的地址获取registry实例
*
* @param originInvoker
* @return
*/
private Registry getRegistry(final Invoker<?> originInvoker) {
URL registryUrl = getRegistryUrl(originInvoker);
/*
* 根据SPI机制获取具体的Registry实例,
* 会调用到com.alibaba.dubbo.registry.support.AbstractRegistryFactory#getRegistry
* 这里获取到的是ZookeeperRegistry
*/
return registryFactory.getRegistry(registryUrl);
}
这里会调用到org.apache.dubbo.registry.support.AbstractRegistry#AbstractRegistry的构造方法
public AbstractRegistry(URL url) {
// 设置注册中心url
setUrl(url);
// 是否开启"文件保存定时器"
syncSaveFile = url.getParameter(Constants.REGISTRY_FILESAVE_SYNC_KEY, false);
/*
* 保存的文件名称为:
* /Users/huangyuan/.dubbo/dubbo-registry-springProviderApplication-127.0.0.1:2181.cache
*
* dubbo中zookeeper做注册中心,如果注册中心集群都挂掉,那发布者和订阅者还能通信吗?
*
* 能,dubbo会将zookeeper的信息缓存到本地,
* 作为一个缓存文件,并且转换成properties对象方便使用
*
* 该文件在注册中心通知的时候,进行存储更新 notify(url.getBackupUrls());
*/
String filename = url.getParameter(Constants.FILE_KEY, System.getProperty("user.home") + "/.dubbo/dubbo-registry-" + url.getParameter(Constants.APPLICATION_KEY) + "-" + url.getAddress() + ".cache");
File file = null;
if (ConfigUtils.isNotEmpty(filename)) {
file = new File(filename);
if (!file.exists() && file.getParentFile() != null && !file.getParentFile().exists()) {
// 不存在则创建
if (!file.getParentFile().mkdirs()) {
throw new IllegalArgumentException("Invalid registry store file " + file + ", cause: Failed to create directory " + file.getParentFile() + "!");
}
}
}
this.file = file;
/*
* 加载文件中的属性,key-value形式,示例如下:
* "group1/com.huang.yuan.api.service.DemoService:1.0" -> "empty://192.168.1.2:23801/com.huang.yuan.api.service.DemoService?anyhost=true&application=springProviderApplication..."
*/
loadProperties();
// 通知订阅
// url.getBackupUrls() 获取的是注册中心的url
notify(url.getBackupUrls());
}
注册服务到注册中心
RegistryProtocol注册服务到注册中心(这里注册中心是Zookeeper,因此最终的注册操作是在org.apache.dubbo.registry.zookeeper.ZookeeperRegistry中执行,代码如下)
@Override
protected void doRegister(URL url) {
try {
/*
* 这里zkClient就是我们上面调用构造的时候生成的 ZkClientZookeeperClient
* ZkClientZookeeperClient 保存着连接到Zookeeper的zkClient实例
* 开始注册,也就是在Zookeeper中创建节点s
* 这里toUrlPath获取到的path为:(类似)
* /dubbo/com.huang.yuan.api.service.DemoService2/provider.....
* 这就是在Zookeeper上面创建的文件夹路径及节点
* 默认创建的节点是临时节点
*/
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);
}
}
订阅服务
com.alibaba.dubbo.registry.support.FailbackRegistry向注册中心订阅服务
public void subscribe(URL url, NotifyListener listener) {
super.subscribe(url, listener);
removeFailedSubscribed(url, listener);
try {
/*
* 想注册中心发送订阅请求
* 这里有一个地方比较有意思,就是自己的服务、依赖外部的服务,都会进行订阅。
* 这一步之后就会在/dubbo/dubbo.common.hello.service/XXXService节点下多一个configurators节点
*/
doSubscribe(url, listener);
} catch (Exception e) {
......
}
}
在org.apache.dubbo.registry.zookeeper.ZookeeperRegistry#doSubscribe完成订阅特定服务的操作。
List<URL> urls = new ArrayList<URL>();
/*
* toCategoriesPath是获取分类路径
* 比如说获取的path数组,含有下面3个值
* /dubbo/com.huang.yuan.api.service.DemoService2/providers
* /dubbo/com.huang.yuan.api.service.DemoService2/configurators
* /dubbo/com.huang.yuan.api.service.DemoService2/routers
*/
for (String path : toCategoriesPath(url)) {
// 获取订阅者
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) {
// 这里设置了监听回调的地址,即回调给FailbackRegistry中的notify
ZookeeperRegistry.this.notify(url, listener, toUrlsWithEmpty(url, parentPath, currentChilds));
}
});
zkListener = listeners.get(listener);
}
// 根据路径path创建节点
zkClient.create(path, false);
// 添加子节点监听器
List<String> children = zkClient.addChildListener(path, zkListener);
if (children != null) {
urls.addAll(toUrlsWithEmpty(url, path, children));
}
}
// 通知消费者
// 在org.apache.dubbo.registry.support.FailbackRegistry.notify中发布操作
notify(url, listener, urls);
}
会创建监听器,当订阅的服务有变更的时候,注册中心就会调用com.alibaba.dubbo.registry.NotifyListener#notify方法,告诉消费者
返回expoter