dubbo源码学习dubbo暴露服务的过程
Posted 车文亮
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了dubbo源码学习dubbo暴露服务的过程相关的知识，希望对你有一定的参考价值。
初学dubbo的源码，只做尝试性的去学习，做为自己学习的一个记录，各位看官如果觉得写的有错误或理解的不对，请在留言区告诉我，互相学习。本人能力有限，有大神进入 时请指点。
dubbo采用的nio异步的通信，通信协议默认为 netty,当然也可以选择 mina,grizzy。在服务端（provider）在启动时主要是开启netty监听，在zookeeper上注册服务节点，处理消费者请求，返回处理后的消息给消费者，消费者使用服务时主要是订阅服务的节点，监听zookeeper节点目录，服务端的变化时zookeeper会推送给消费者，消费者重新缓存服务地址等。服务者、消费者、zookeeper三者之间都是长连接。
下面看dubbo源码来看服务暴露的过程，服务暴露的入口为：com.alibaba.dubbo.config.ServiceConfig#export 方法，代码如下：
//是否延时暴露
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();
}/*
检查默认设置,如果xml中没有配置<dubbo:provider
主要是从系统环境变量中寻找是否有相应的provider的配置
*/
checkDefault();
//下面设置的内容如果没有配置<dubbo:provider时基本上都是Null
if (provider != null) {
if (application == null) {
application = provider.getApplication();
}
if (module == null) {
module = provider.getModule();
}
if (registries == null) {
registries = provider.getRegistries();
}
if (monitor == null) {
monitor = provider.getMonitor();
}
if (protocols == null) {
protocols = provider.getProtocols();
}
}
if (module != null) {
//registries一般都会配置
if (registries == null) {
registries = module.getRegistries();
}
if (monitor == null) {
monitor = module.getMonitor();
}
}
if (application != null) {
//application一般也会配置
if (registries == null) {
registries = application.getRegistries();
}
if (monitor == null) {
monitor = application.getMonitor();
}
}
//是否泛化调用
if (ref instanceof GenericService) {
interfaceClass = GenericService.class;
if (StringUtils.isEmpty(generic)) {
generic = Boolean.TRUE.toString();
}
} else {
try {
interfaceClass = Class.forName(interfaceName, true, Thread.currentThread()
.getContextClassLoader());
} catch (ClassNotFoundException e) {
throw new IllegalStateException(e.getMessage(), e);
}
/*
检查即将暴露的接口的方法配置,检查方法是否在接口中存在
一般不会配置所以一般情况下methods为null
<dubbo:service > <dubbo:method /> </dubbo:serivce>
*/
checkInterfaceAndMethods(interfaceClass, methods);
/*
检查接口的引用不为空,并且必须实现的是要暴露的接口
*/
checkRef();
generic = Boolean.FALSE.toString();
}所有的检查通过之后，会调用 ：com.alibaba.dubbo.config.ServiceConfig#doExportUrls 方法，因为dubbo支持多通信协议时，都进行暴露，所以在代码中可以看到
/*
将注册协议转化成url
registry://45.119.68.23:2181/com.alibaba.dubbo.registry.RegistryService?
application=test-dubbo&dubbo=2.5.3&pid=7648®istry=zookeeper×tamp=1462349748801
*/
List<URL> registryURLs = loadRegistries(true);
//配置多通信协议时，都进行暴露
for (ProtocolConfig protocolConfig : protocols) {
doExportUrlsFor1Protocol(protocolConfig, registryURLs);
}/*
将不为null的配置对象中的属性设置到 map 中
即将 xml 配置文件中的配置设置的值全转化成为map
{side=provider, application=alijk-dubbo, accepts=1000,
dubbo=2.5.3, threads=100, pid=7236, interface=cn.eoncloud.account.sdk.export.AccountService,
threadpool=fixed, version=1.0.0, timeout=500, anyhost=true, timestamp=1462347843960}
*/
appendParameters(map, application);
appendParameters(map, module);
appendParameters(map, provider, Constants.DEFAULT_KEY);
appendParameters(map, protocolConfig);
appendParameters(map, this);
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
/*
将配置信息转化成 url ,主要根据之前map里的数据组装成url
调用 URL#buildString方法
dubbo://10.6.13.137:9998/cn.eoncloud.account.sdk.export.AccountService
?accepts=1000&anyhost=true&application=test-dubbo&dubbo=2.5.3
&interface=cn.eoncloud.account.sdk.export.AccountService
&methods=getAccountName,getAllTest&pid=7236&revision=1.0.0&side=provider
&threadpool=fixed&threads=100&timeout=500×tamp=1462347843960&version=1.0.0
*/
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);
}
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));
//com.alibaba.dubbo.registry.integration.RegistryProtocol#export 即将进行暴露
Exporter<?> exporter = protocol.export(invoker);public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
//export invoker doLocalExport调用dubboProtocol.export开启netty服务监听
final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker);
//registry provider
final Registry registry = getRegistry(originInvoker);
final URL registedProviderUrl = getRegistedProviderUrl(originInvoker);
//调用zodoRegister的doRegister 创建zookeeper的服务节点
registry.register(registedProviderUrl);
// 订阅override数据
// FIXME 提供者订阅时，会影响同一JVM即暴露服务，又引用同一服务的的场景，因为subscribed以服务名为缓存的key，导致订阅信息覆盖。
final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registedProviderUrl);
final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl);
overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
//订阅
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);
}
}
};
}final Invoker<?> invokerDelegete = new InvokerDelegete<T>(originInvoker, getProviderUrl(originInvoker));
//此处protol为dubboProtocol
exporter = new ExporterChangeableWrapper<T>((Exporter<T>)protocol.export(invokerDelegete), originInvoker); private void openServer(URL url) {
// find server. ip:port
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) {
//创建 Server
serverMap.put(key, createServer(url));
} else {
//server支持reset,配合override功能使用
server.reset(url);
}
}
}
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));
//默认使用netty
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);
//默认使用dubbo协议编码
url = url.addParameter(Constants.CODEC_KEY, Version.isCompatibleVersion() ? COMPATIBLE_CODEC_NAME : DubboCodec.NAME);
ExchangeServer server;
try {
//HeaderExchangeServer 在此处已经开启了Netty Server 进行监听
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;
}public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
//Transporters默认为NettyTransporter
return new HeaderExchangeServer(Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
}public static final String NAME = "netty";
public Server bind(URL url, ChannelHandler listener) throws RemotingException {
return new NettyServer(url, listener);
}已经能看到NettyServer了，dubbo在暴露服务最终开启的netty服务监听，监听消费者发送的请求，通过反射调用方法得到结果通过 tcp/ip 网络传输返回给消费者。再进入到NettyServer中我们就能看到非常传统的开启Netty服务的代码了
protected void doOpen() throws Throwable {
NettyHelper.setNettyLoggerFactory();
ExecutorService boss = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerBoss", true));
ExecutorService worker = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerWorker", true));
//最后一个参数为 NIO 最大工作线程数
ChannelFactory channelFactory = new NioserverSocketChannelFactory(boss, worker, getUrl().getPositiveParameter(Constants.IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS));
//netty server 启动器
bootstrap = new ServerBootstrap(channelFactory);
final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);
channels = nettyHandler.getChannels();
// https://issues.jboss.org/browse/NETTY-365
// https://issues.jboss.org/browse/NETTY-379
// final Timer timer = new HashedWheelTimer(new NamedThreadFactory("NettyIdleTimer", true));
bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
public ChannelPipeline getPipeline() {
NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec() ,getUrl(), NettyServer.this);
ChannelPipeline pipeline = Channels.pipeline();
/*int idleTimeout = getIdleTimeout();
if (idleTimeout > 10000) {
pipeline.addLast("timer", new IdleStateHandler(timer, idleTimeout / 1000, 0, 0));
}*/
pipeline.addLast("decoder", adapter.getDecoder());
pipeline.addLast("encoder", adapter.getEncoder());
pipeline.addLast("handler", nettyHandler);
return pipeline;
}
});
// 创建一个绑定到指定地址的新通道，也就是绑定IP、端口供客户端连接
channel = bootstrap.bind(getBindAddress());
}NettyHandler extends SimpleChannelHandler /**
* 收到消息时触发
* @param ctx
* @param e
* @throws Exception
*/
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
NettyChannel channel = NettyChannel.getOrAddChannel(ctx.getChannel(), url, handler);
try {
handler.received(channel, e.getMessage());
} finally {
NettyChannel.removeChannelIfDisconnected(ctx.getChannel());
}
}//registry provider
final Registry registry = getRegistry(originInvoker);
final URL registedProviderUrl = getRegistedProviderUrl(originInvoker);
//调用zodoRegister的doRegister 创建zookeeper的服务节点
registry.register(registedProviderUrl);
// 订阅override数据
// FIXME 提供者订阅时，会影响同一JVM即暴露服务，又引用同一服务的的场景，因为subscribed以服务名为缓存的key，导致订阅信息覆盖。
final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registedProviderUrl);
final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl);
overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
//订阅
registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);dubbo服务在zookeeper上的节点注册是：com.alibaba.dubbo.registry.support.FailbackRegistry#register
@Override
public void register(URL url) {
super.register(url);
failedRegistered.remove(url);
failedUnregistered.remove(url);
try {
// 向服务器端发送注册请求
doRegister(url);
从上图可以看到doRegister实现有 dubbo、redis、zookeeper，这也是在我们配置时经常看到的 注册协议的配置 ，最为常用的就是 zookeeper了，所以再看ZookeeperRegistry的代码，看他的doRegistry干什么了如下
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);
}
}
至此，dubbo的暴露基本上已经完成，开启了netty服务，注册了zookeeper的节点，就等着消费者连接上来使用了。下一节将介绍dubbo的消息发送和接收，NIO异步通讯的实现。
以上是关于dubbo源码学习dubbo暴露服务的过程的主要内容，如果未能解决你的问题，请参考以下文章