Dubbo源码简述

最新推荐文章于 2024-08-28 21:56:54 发布
最新推荐文章于 2024-08-28 21:56:54 发布
阅读量643 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/goligu/article/details/124116654
版权

本章分析

本章分析内容大致如下，不打算走大段大段的源码分析了，就讲个大概，源码这东西吧，还是得自己过一遍。所以，看完应该只能了解个整体大概，细分领域就可以不用看了（可以给我留言，如果有人感兴趣可以写个分析下）。

  1. 服务暴露流程
  2. 服务引用流程

image.png
在前面的《「Dubbo源码」Spring整合Dubbo》中已经发分析，这篇主要就以ServiceBean和ReferenceBean为主了

服务暴露流程

大致流程如下

image.png

ServiceBean

image.png
其他对bean创建过程中的生命周期就略过了（就是赋值啥的，自己看看吧），这里主要分析下ApplicationListener,
ServiceBean在监听ContextRefreshedEvent时间的时候（此时已经bean已经初始化完成了），调用com.alibaba.dubbo.config.ServiceConfig#export方法，此处为方法暴露的主入口。

ServiceConfig

image.png
此处会生成一个代理对象。既然是代理对象，根据前面阅读代理对象的经历，肯定会有一个实际执行的对象穿进去，而ref为接口实现类引用，就是实际执行者。又是根据模版拼接类所需的字符串，加载到内存，就不跟源码了，这里可以看一下invokeMethods方法（没啥重要的，主要是我好奇）。
image.png

DubboProtocol

下面就来到DubboProtocol的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);
    
    return exporter;
}

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);
       }
    }
}


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 {
        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;
}

众所周知Dubbo底层是Netty，对应的处理Handler就是requestHandler。

Excharger&&Transporters&&NettyServer

这三个类就依次调用就简单，就一起分析了。

image.png

核心就是这个调用NettyServer::doOpen启动Netty服务，外面传进来的requestHandler也封装进NettyServer再封装进NettyHandler。

@Override
protected void doOpen() throws Throwable {
    NettyHelper.setNettyLoggerFactory();
    ExecutorService boss = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerBoss", true));
    ExecutorService worker = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerWorker", true));
    ChannelFactory channelFactory = new NioServerSocketChannelFactory(boss, worker, getUrl().getPositiveParameter(Constants.IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS));
    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;
        }
    });
    // bind
    channel = bootstrap.bind(getBindAddress());
}

RegistryProtocol

dubbo spi由于是根据url自动适配的，由于初始前缀基本上都是registry，所以每次在执行前都会执行RegistryProtocol，它主要就是负责服务注册&订阅

image.png

总结

正常Spring IoC管理后，监听ContextRefreshedEvent时间，然后对于在xml配置中配置了<dubbo:service>标签的，就启动一个Netty服务。然后再向注册中心注册

至于Invoker我觉得应该服务暴露流程的范畴，在这边讲的话这边就会很乱，就放到下面了。

服务引用流程

服务提供者可以获取到对象，启动一个Netty服务，但是消费者获取不到啊，它只能拿到接口，要怎么解决依赖注入的问题呢，在用的时候就很好奇了。能想到的，就是生成一个代理对象，否则依赖注入那边过不去啊。回到正题，服务引用流程大致流程如下

image.png

ReferenceBean

它实现了FactoryBean在依赖注入中获取bean的时候会调用getObject获取到bean
image.png

image.png

ReferenceConfig

随后就进入ReferenceConfig会调用核心方法createProxy
image.png

RegistryProtocol

这里和上面一样，只不过会有个RegistryDirectory订阅服务提供者，当服务提供者变动的时候，会调用notify方法更新他们内部的url&Invokers

public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
       url = url.setProtocol(url.getParameter(Constants.REGISTRY_KEY, Constants.DEFAULT_REGISTRY)).removeParameter(Constants.REGISTRY_KEY);
       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(Constants.REFER_KEY));
       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);
   }

private <T> Invoker<T> doRefer(Cluster cluster, Registry registry, Class<T> type, URL url) {
    RegistryDirectory<T> directory = new RegistryDirectory<T>(type, url);
    directory.setRegistry(registry);
    directory.setProtocol(protocol);
    URL subscribeUrl = new URL(Constants.CONSUMER_PROTOCOL, NetUtils.getLocalHost(), 0, type.getName(), directory.getUrl().getParameters());
    if (! Constants.ANY_VALUE.equals(url.getServiceInterface())
            && url.getParameter(Constants.REGISTER_KEY, true)) {
        registry.register(subscribeUrl.addParameters(Constants.CATEGORY_KEY, Constants.CONSUMERS_CATEGORY,
                Constants.CHECK_KEY, String.valueOf(false)));
    }
    directory.subscribe(subscribeUrl.addParameter(Constants.CATEGORY_KEY, 
            Constants.PROVIDERS_CATEGORY 
            + "," + Constants.CONFIGURATORS_CATEGORY 
            + "," + Constants.ROUTERS_CATEGORY));
    return cluster.join(directory);
}

DubboProtocol

public <T> Invoker<T> refer(Class<T> serviceType, URL url) throws RpcException {
    // create rpc invoker.
    DubboInvoker<T> invoker = new DubboInvoker<T>(serviceType, url, getClients(url), invokers);
    invokers.add(invoker);
    return invoker;
}

private ExchangeClient[] getClients(URL url){
    //是否共享连接
    boolean service_share_connect = false;
    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;
}

    private ExchangeClient getSharedClient(URL url){
        String key = url.getAddress();
        //。。。略
        ExchangeClient exchagneclient = initClient(url);
        
        client = new ReferenceCountExchangeClient(exchagneclient, ghostClientMap);
        referenceClientMap.put(key, client);
        ghostClientMap.remove(key);
        return client; 
    }

private ExchangeClient initClient(URL url) {
    
    //。。。略
    
    ExchangeClient client ;
    try {
        //设置连接应该是lazy的 
        if (url.getParameter(Constants.LAZY_CONNECT_KEY, 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;
}

Exchanger&&Transporters&&NettyTransporter

和上面一样经过层层调用，会返回一个NettyClient此处的handler和服务暴露的handler是同一个

image.png
image.png
NettyClient内部会创建一个Netty客户端并与Netty服务端链接。同样，也是只会启动Netty客户端

@Override
protected void doOpen() throws Throwable {
    NettyHelper.setNettyLoggerFactory();
    bootstrap = new ClientBootstrap(channelFactory);
    // config
    // @see org.jboss.netty.channel.socket.SocketChannelConfig
    bootstrap.setOption("keepAlive", true);
    bootstrap.setOption("tcpNoDelay", true);
    bootstrap.setOption("connectTimeoutMillis", getTimeout());
    final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);
    bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
        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);
        
        if (ret && future.isSuccess()) {
            Channel newChannel = future.getChannel();
            newChannel.setInterestOps(Channel.OP_READ_WRITE);
            try {
                // 关闭旧的连接
                Channel oldChannel = NettyClient.this.channel; // copy reference
                if (oldChannel != null) {
                    try {
                        if (logger.isInfoEnabled()) {
                            logger.info("Close old netty channel " + oldChannel + " on create new netty channel " + newChannel);
                        }
                        oldChannel.close();
                    } finally {
                        NettyChannel.removeChannelIfDisconnected(oldChannel);
                    }
                }
            } finally {
                if (NettyClient.this.isClosed()) {
                    try {
                        if (logger.isInfoEnabled()) {
                            logger.info("Close new netty channel " + newChannel + ", because the client closed.");
                        }
                        newChannel.close();
                    } finally {
                        NettyClient.this.channel = null;
                        NettyChannel.removeChannelIfDisconnected(newChannel);
                    }
                } else {
                    NettyClient.this.channel = newChannel;
                }
            }
        } else if (future.getCause() != null) {
            throw new RemotingException(this, "client(url: " + getUrl() + ") failed to connect to server "
                    + getRemoteAddress() + ", error message is:" + future.getCause().getMessage(), future.getCause());
        } else {
            throw new RemotingException(this, "client(url: " + getUrl() + ") failed to connect to server "
                    + getRemoteAddress() + " client-side timeout "
                    + getConnectTimeout() + "ms (elapsed: " + (System.currentTimeMillis() - start) + "ms) from netty client "
                    + NetUtils.getLocalHost() + " using dubbo version " + Version.getVersion());
        }
    }finally{
        if (! isConnected()) {
            future.cancel();
        }
    }
}

总结

对于<dubbo:reference>标签的，Spring会在创建阶段，生成一个代理对象，底层会创建Netty客户端。

本来还想写其他的，发现要写的太多了，看后面有没有啥机会再写吧

山间小僧
关注
Dubbo原理简述三：启动解析、加载配置信息
.... 永远年轻，永远热泪盈眶
01-15 5万+
&lt;dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"&gt;&lt;/dubbo:registry&gt; &lt;dubbo:protocol name="dubbo" port="20882"&gt;&lt;/dubbo:protocol&gt; &lt;dubbo:ser
Dubbo原理简述四：服务暴露、服务引用和调用流程
热门推荐
.... 永远年轻，永远热泪盈眶
01-15 5万+
关于服务暴露，首先需要了解：ServiceBean.java 此类实现了几个Spring中比较重要的接口：如InitializingBean、ApplicationContextAware、ApplicationListener等，查看该类结构图： 接下来分析一下该类的一些主要方法： 在ServiceBean.afterPropertiesSet()方法中，就是将配置文件的各项属性信息都配置到该...
dubbo 源码
03-23
dubbo 源码dubbo 源码dubbo 源码dubbo 源码dubbo 源码dubbo 源码dubbo 源码dubbo 源码
dubbo源码分析（一）
dhka8040652的博客
03-02 219
阅读源码的作用 提取设计思路，增强设计能力 理解运行机制，便于快速解决问题以及功能扩展 常见有关dubbo的问题 dubbo的负载均衡是在哪个组件中处理的？ dubbo默认的负载均衡算法是什么？ 如果注册中心挂掉了客户端是否能够继续调用dubbo？ 一个请求从调用端到服务端的处理流程是什么？ 如果你有仔细的研读dubbo的开发文档，大部分问题都是有...
Dubbo源码解析之@DubboService、@DubboReference（Dubbo源码一）
最新发布
小道仙的后宫
08-28 1219
对于Dubbo用的最多的就是@DubboService、@DubboReference，与之对应的就是服务的提供方、调用方。之所以加上注解就可以运行，定是生成了代理对象，这篇文章就来讲讲如何基于这两个注解生成代理对象。不管是服务端还是客户端，在使用Dubbo的时候都会先使用，比如下面的demo@EnableDubbo 是一个组合注解，它头上还有@DubboComponentScan和@EnableDubboConfig，它们就是分别来解析@DubboService、@DubboReference。
dubbo源码
weixin_41029286的博客
10-18 2764
dubbo源码构建参考 官方文档 Provider: 暴露服务的服务提供方 Protocol 负责提供者和消费者之间协议交互数据 Service 真实的业务服务信息 可以理解成接口 和 实现 Container Dubbo的运行环境 Consumer: 调用远程服务的服务消费方 Protocol 负责提供者和消费者之间协议交互数据 Cluster 感知提供者端的列表信息 Proxy 可以理解成 提供者的服务调用代理类 由它接管 Consumer中的接口调用逻辑 Registry: 注册中心，用于作为服务发
Dubbo源代码（2.8.4）
09-30
Dubbo的源代码打包，2.8.4开发发布版，及与Maven构建，本人亲测，可以编译通过。
深入解析Dubbo源码：核心机制与设计模式详解
本文深入解析了Dubbo框架的源码，涵盖了从架构理解、Hello...本文是一篇全面的Dubbo源码解析，涵盖了框架结构、核心机制、整合方式以及关键技术实现的深度剖析，对于理解Dubbo的工作原理和源码实现具有很高的参考价值。
Dubbo源码解析：根据标志位处理请求与事件类型
"本文档是基于Dubbo源码学习的笔记，主要讲解如何根据标志位判断消息为请求类型的细节，涉及Dubbo服务治理、RPC中间件相关知识，并提供了Dubbo官方文档链接和SPI机制的简单介绍。" Dubbo作为一款强大的服务治理...
Dubbo源码通~服务暴露之本地暴露
一只打杂的码农
07-04 518
Dubbo服务暴露~本地暴露 功能：具体服务转换成Invoker，Invoker 转换成 Exporter 1、逻辑简述 Spring服务暴露入口：ServiceBean.onApplicationEvent() -> ServiceBean.export() Spring容器发布刷新事件，调用Dubbo的export()会进行服务暴露。 Dubbo服务暴露入口：ServiceCo...
Dubbo源码分析
01-29
Dubbo源码分析；模块说明；总体架构；图例说明；各层说明：关系说明：依赖关系；调用链；配置文件解析；配置文件覆盖顺序；暴露服务时序；dubbo的远程调用(NIO机制)以及序列化；RPC 通信过程；消费服务时序；
dubbo源码下载
02-26
博主也只自学到这里了，提供源码以便大家一起进步。希望大家满意。
Dubbo源代码（2.5.4）
10-27
Dubbo的源代码打包，2.5.4开发发布版，及与Maven构建，本人亲测，可以编译通过。
dubbo源码分析
01-14
dubbo源码分析系列 知秋整理 原文博客:https://my.oschina.net/ywbrj042/home 更多精彩学习内容，请关注本人github 一 项目工程结构介绍 摘要: dubbo是目前国内最流行的分布式服务框架，已经俨然成为行业的标准了，多数无自研能力的公司都在 使用这个框架，而且这个框架本身非常具有代表性，即使很多公司自研的分布式服务框架也都是对dubbo的扩 展或者借鉴了该框架，因此研究它的源码意义还是非常大的，对于掌握分布式服务框架的原理和实现细节有 着非常好的帮助。 项目源码地址 本系列文章是基于当当网维护的dubbox版本进行分析的，源码地址参 考：https://github.com/dangdangdotcom/dubbox 项目源码结构
dubbo源码解析
分享Java技术知识，共同成长进步！
09-20 3155
dubbo源码解析-网络通信 在之前的内容中，我们讲解了消费者端服务发现与提供者端服务暴露的相关内容，同时也知道消费者端通过内置的负载均衡算法获取合适的调用invoker进行远程调用。那么，本章节重点关注的就是远程调用过程即网络通信。 网络通信位于Remoting模块： Remoting 实现是 Dubbo 协议的实现，如果你选择 RMI 协议，整个 Remoting 都不会用上； Remoting 内部再划为 Transport 传输层 和 Exchange 信息交换层； Transport 层
想看dubbo源代码，看这篇就行了~ 吧，大概够了吧 ヾ(≧∇≦*)ゝ
胡歌粉丝的博客
03-12 1397
dubbo啊dubbo~前言正文可扩展SPI源代码思路以及流程获得扩展加载器获得实例 前言 第一次听到dubbo都忘记是啥时候了，好像是是dubboX来着，没记错的话还是当当网拿去弄的，再到后面第一次使用dubbo开发项目，已经是18年底，那时候公司架构走向SOA，作为职场小白的我调调别人写的API，管他啥是dubbo，能用就行，可开心了（这种态度非常非常非常不可取！！别人家优秀的人已经更加优秀，自己却还在傻乐，这怎么行！！） 一转眼两年过去了，着手了解了解它是怎么玩的，挺好~ 总有人说源代码有啥好看的，
Dubbo源码解析：调用机制与集群策略
1. **源码阅读路径**：理解Dubbo源码通常从分析其架构开始，然后深入到具体模块，如服务注册与发现、服务调用、集群策略等。 2. **Dubbo架构**：Dubbo架构包含服务提供者、服务消费者、注册中心、监控中心等组件。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值