Dubbo源码分析----网络通信相关

最新推荐文章于 2023-06-03 19:11:01 发布
最新推荐文章于 2023-06-03 19:11:01 发布
阅读量567 收藏
点赞数
分类专栏： 源码分析 dubbo 文章标签： Dubbo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013160932/article/details/79339739
版权

Server

在暴露服务，执行到DubboProtocol的export方法的时候，会调用openServer方法，从这里开始，就是Dubbo开启请求监听的地方

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

看下Exchangers.bind

    public static ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
        if (url == null) {
            throw new IllegalArgumentException("url == null");
        }
        if (handler == null) {
            throw new IllegalArgumentException("handler == null");
        }
        url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");
        return getExchanger(url).bind(url, handler);
    }

根据Dubbo扩展机制知道getExchange获取到的是HeaderExchanger，其bind方法如下

    public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
        return new HeaderExchangeServer(Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
    }

从这里会发现，Server和Handler都使用了装饰者模式，为其扩展了很多功能。后面会发现源码中已经在外面包了很多层，提供了很多新的功能
Handler：
1. DecodeHandler：提供了编码解码的功能
2. DecodeHandler：提供数据校验，异常处理，已经将Channel转换成ExchangeChannel

Channel主要是底层的通信类，内部负责利用netty进行通信，而ExchangeChannel在通信方法前后提供了对象的转换，校验的功能。Server那边同理

接下来看下Transporters.bind方法，这之前看到类上有个注释

Transporter facade. (API, Static, ThreadSafe)

可见Transporters主要是获取Server和Client的工厂类，主要为了统一出口，屏蔽内部实现细节，只需要给外面提供Server或者Client的对象就可以了，内部使用什么实现外部可以不用管
然后看下方法

    public static Server bind(URL url, ChannelHandler... handlers) throws RemotingException {
        ....
        ChannelHandler handler;
        if (handlers.length == 1) {
            handler = handlers[0];
        } else {
            handler = new ChannelHandlerDispatcher(handlers);
        }
        return getTransporter().bind(url, handler);
    }

Transporter是传输层的对象，目前有netty，mina和Grizzly3种实现，根据扩展机制，得到的是NettyTransporter，其bind方法返回NettyServer对象，看下NettyServer的继承结构
image.png
调用NettyServer的构造方法时会先调用父类的

    public AbstractPeer(URL url, ChannelHandler handler) {
        ....
        this.url = url;
        this.handler = handler;
    }
    public AbstractServer(URL url, ChannelHandler handler) throws RemotingException {
        super(url, handler);
        ....
        try {
            doOpen();
            ....
        } catch (Throwable t) {
            ....
        }
        if (handler instanceof WrappedChannelHandler ){
            executor = ((WrappedChannelHandler)handler).getExecutor();
        }
    }
    public AbstractEndpoint(URL url, ChannelHandler handler) {
        super(url, handler);
        this.codec = getChannelCodec(url);
        this.timeout = url.getPositiveParameter(Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT);
        this.connectTimeout = url.getPositiveParameter(Constants.CONNECT_TIMEOUT_KEY, Constants.DEFAULT_CONNECT_TIMEOUT);
    }
  1. AbstractPeer：属性初始化
  2. AbstractEndpoint：也是属性初始化
  3. AbstractServer：真正初始化网络通信的地方，实现在NettyServer的doOpen方法中
    @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();
        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;
            }
        });
        channel = bootstrap.bind(getBindAddress());
    }

其他先不看，这里主要看nettyHandler，熟悉Netty的看到这就知道请求会经过NettyHandler，逻辑的处理就是在这里面了，当然最后会调用到在DubboProtocol里初始化的RequestHandler
到这里，网络通信部分就结束了，这里涉及的类很多，整个获取Server以及初始化的流程如下
初始化.png
这仅仅是Server的初始化过程，Client的初始化类似

以下内容2018-08-11补充：

Client

在DubboPrototol的refer方法引用服务的时候，会调用getClients方法获取Client的对象

    private ExchangeClient[] getClients(URL url){
        //是否共享连接
        boolean service_share_connect = false;
        int connections = url.getParameter(Constants.CONNECTIONS_KEY, 0);//获取connections参数
        //如果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;
    }

getSharedClient和initClient的区别在于，getSharedClient会调用initClient去初始化连接，并且缓存起来，key是provider的ip地址

   /**
     *获取共享连接 
     */
    private ExchangeClient getSharedClient(URL url){
        String key = url.getAddress();
        ReferenceCountExchangeClient client = referenceClientMap.get(key);
        if ( client != null ){
            if ( !client.isClosed()){//连接未关闭
                client.incrementAndGetCount();//使用的数量加1
                return client;
            } else {
//                logger.warn(new IllegalStateException("client is closed,but stay in clientmap .client :"+ client));
                referenceClientMap.remove(key);
            }
        }
        ExchangeClient exchagneclient = initClient(url);// 初始化连接
        // ReferenceCountExchangeClient包装了原始的Client，增加了一些功能
        client = new ReferenceCountExchangeClient(exchagneclient, ghostClientMap);
        referenceClientMap.put(key, client);
        ghostClientMap.remove(key);
        return client; 
    }

initClient

    private ExchangeClient initClient(URL url) {

        // ....

        ExchangeClient client ;
       //....
            //设置连接应该是lazy的 
            if (url.getParameter(Constants.LAZY_CONNECT_KEY, false)){
                client = new LazyConnectExchangeClient(url ,requestHandler);
            } else {
                client = Exchangers.connect(url ,requestHandler);
            }
       //....        
        return client;
    }

如果配置了lazy属性，则返回LazyConnectExchangeClient，该类型的Client在真正使用到Client请求的时候才会调用Exchangers.connect去初始化，故直接看Exchangers.connect方法

    public static ExchangeClient connect(String url) throws RemotingException {
        return connect(URL.valueOf(url));
    }
    public static ExchangeClient connect(URL url) throws RemotingException {
        return connect(url, new ChannelHandlerAdapter(), null);
    }
    public static ExchangeClient connect(URL url, ChannelHandler handler, Replier<?> replier) throws RemotingException {
        return connect(url, new ExchangeHandlerDispatcher(replier, handler));
    }

    public static ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException {
        if (url == null) {
            throw new IllegalArgumentException("url == null");
        }
        if (handler == null) {
            throw new IllegalArgumentException("handler == null");
        }
        url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");
        return getExchanger(url).connect(url, handler);
    }

代码原理和Server初始化的时候类似，最后返回的就是NettyClient，看下去构造方法：

    public NettyClient(final URL url, final ChannelHandler handler) throws RemotingException{
        super(url, wrapChannelHandler(url, handler));
    }

其父类是AbstractClient

    public AbstractClient(URL url, ChannelHandler handler) throws RemotingException {
        super(url, handler);
        // 发送请求的时候如果为true且未连接则调用connect方法
        send_reconnect = url.getParameter(Constants.SEND_RECONNECT_KEY, false);

        shutdown_timeout = url.getParameter(Constants.SHUTDOWN_TIMEOUT_KEY, Constants.DEFAULT_SHUTDOWN_TIMEOUT);

        //默认重连间隔2s，1800表示1小时warning一次.
        reconnect_warning_period = url.getParameter("reconnect.waring.period", 1800);
        //....
        doOpen();// 子类实现，NettyClient中是初始化Netty
        //....
        connect();
        //....

        executor = (ExecutorService) ExtensionLoader.getExtensionLoader(DataStore.class)
            .getDefaultExtension().get(Constants.CONSUMER_SIDE, Integer.toString(url.getPort()));
        ExtensionLoader.getExtensionLoader(DataStore.class)
            .getDefaultExtension().remove(Constants.CONSUMER_SIDE, Integer.toString(url.getPort()));
    }

connect方法

//....
if (isConnected()) {
                return;
            }
            initConnectStatusCheckCommand();//重连机制
            doConnect();//具体连接逻辑，子类实现
            if (! isConnected()) {//连接失败
                throw new RemotingException(this, "Failed connect to server " + getRemoteAddress() + " from " + getClass().getSimpleName() + " "
                                            + NetUtils.getLocalHost() + " using dubbo version " + Version.getVersion()
                                            + ", cause: Connect wait timeout: " + getTimeout() + "ms.");
            } else {// 连接成功
                if (logger.isInfoEnabled()){
                    logger.info("Successed connect to server " + getRemoteAddress() + " from " + getClass().getSimpleName() + " "
                                            + NetUtils.getLocalHost() + " using dubbo version " + Version.getVersion()
                                            + ", channel is " + this.getChannel());
                }
            }
//....

initConnectStatusCheckCommand方法主要是开启了一个定时器，在未连接成功的情况下定时进行重连

    private synchronized void initConnectStatusCheckCommand(){
        //reconnect=false to close reconnect 
        int reconnect = getReconnectParam(getUrl());
        if(reconnect > 0 && (reconnectExecutorFuture == null || reconnectExecutorFuture.isCancelled())){
            Runnable connectStatusCheckCommand =  new Runnable() {
                public void run() {
                    try {
                        if (! isConnected()) {
                            connect();
                        } else {
                            lastConnectedTime = System.currentTimeMillis();
                        }
                    } catch (Throwable t) { 
                        String errorMsg = "client reconnect to "+getUrl().getAddress()+" find error . url: "+ getUrl();
                        // 如果断开连接的时间大于shutdown_timeout，则打印日志，默认15分钟
                        if (System.currentTimeMillis() - lastConnectedTime > shutdown_timeout){
                            if (!reconnect_error_log_flag.get()){
                                reconnect_error_log_flag.set(true);
                                logger.error(errorMsg, t);
                                return ;
                            }
                        }
                        //每reconnect_warning_period次失败都打印warn日志
                        if ( reconnect_count.getAndIncrement() % reconnect_warning_period == 0){
                            logger.warn(errorMsg, t);
                        }
                    }
                }
            };
            reconnectExecutorFuture = reconnectExecutorService.scheduleWithFixedDelay(connectStatusCheckCommand, reconnect, reconnect, TimeUnit.MILLISECONDS);
        }
    }
六道木_
关注
专栏目录
Dubbo 源码分析11 网络通信篇NettyServer、HeaderExchangeServer
郭传志的博客
09-22 157
NettyServer   1、private Map< String, Channel> channels：< ip:port, channel> 所有通道。   2、private ServerBootstrap bootstrap ： netty 服务端启动器。   3、private io.netty.channel.Channel channel：服务端监听...
Java基础教程：dubbo源码解析-网络通信
CZ-001的博客
09-19 412
在之前的内容中，我们讲解了消费者端服务发现与提供者端服务暴露的相关内容，同时也知道消费者端通过内置的负载均衡算法获取合适的调用invoker进行远程调用。那么，本章节重点关注的就是远程调用过程即网络通信。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LNttkF3K-1663574197863)(assets/1592381672559.png)]客户端与服务端连通性问题粘包拆包问题异步多线程数据一致问题。
dubbo之网络通讯
懒猫的脚印
03-16 305
dubbo通信层主要有3部份组成Transporter和Exchanger。Transporter负责netty的封装，Exchanger负责将异步同步化，Protocol 负责服务化
dubbo网络通讯(四)
weixin_34015566的博客
11-19 294
dubbo网络层功能 dubbo网络通讯层主要实现了以下功能： 多种网络通讯框架的抽象封装（netty,mina,grizzly） 每个客户端主机和服务端保存单个长链接通信 异步调用转同步 tcp链接的心跳和自动重连 基于header头通讯协议，请求的编解码器 dubbo网络通讯框架抽象 dubbo的网络通信基于NIO框架，一般基于事件的NIO网络框架都涉及到 channel , channe...
dubbo源码解析（十五）远程通信——Mina
weixin_34419326的博客
12-26 473
远程通讯——Mina 目标：介绍基于Mina的来实现的远程通信、介绍dubbo-remoting-mina内的源码解析。 前言 Apache MINA是一个网络应用程序框架，可帮助用户轻松开发高性能和高可扩展性的网络应用程序。它通过Java NIO在各种传输（如TCP / IP和UDP / IP）上提供抽象的事件驱动异步API。它通常被称...
Dubbo 源码分析12 网络通信篇
郭传志的博客
09-22 244
  以Dubbo协议为例，DubboProtocol#refer中，在创建Invoker时，通过getClient方法，开始Client（连接的）创建过程，先重点看一下：  代码@1：参数URL,服务提供者URL。   代码@2：获取< dubbo:reference connections = “” />，默认0表示客户端对同一个服务提供者的所有服务，使用共享一个连接，如果该值...
Dubbo源码分析
qfzhaohan的博客
12-20 2679
什么是Dubbo？ Dubbo一开始是由阿里巴巴开发，后面贡献给了Apache，所以后面我们称之为Apache Dubbo或者直接叫Dubbo。 Dubbo 是一款高性能、轻量级的开源服务框架 。 先纠正读法： 错误读法：diubo、dubo 正确读法：|ˈdʌbəʊ| Dubbo的六大核心能力 面向接口代理的高性能RPC调用 智能容错和负载均衡 服务自动注册和发现 高度可扩展能力 运行期流量调度 可视化的服务治理与运维。 开发中，我们都喜欢把Dubbo简称为RPC开源框架。 什么是R
Dubbo源码分析----DefaultFuture
菜鸟一名
07-22 3141
前面两篇文章已经分析了provider和consumer之间的通信过程，那么还有几个问题： 由于请求是异步的，provider返回结果到客户端之后，consumer怎么知道该结果是哪个请求的？ 由于请求是异步的，为何Dubbo能同步等待结果？ 由于请求是异步的，provider返回结果到客户端之后，consumer怎么知道该结果是哪个请求的？ 先看下第一个问题，因为provide...
alibaba-dubbo-dubbo-2.5.7-0-ge2d63ad.tar.gz
01-11
《阿里巴巴Dubbo 2.5.7源码分析与应用》 阿里巴巴的Dubbo是一款高性能、轻量级的开源Java RPC框架，它提供了服务发现、服务治理、流量控制等一系列完整的服务解决方案。本压缩包"alibaba-dubbo-dubbo-2.5.7-0-ge2d...
dubbo源码分析 -- 远程通信 netty
赵小叔
08-05 614
dubbo 底层通信选择了 netty 这个 nio 框架做为默认的网络通信框架并且通过自定义协议进行通信。dubbo 支持以下网络通信框架： Netty(默认) Mina Grizz ly  Netty是什么？ ①本质:由JBOSS提供的一个java开源框架(一个jar包) ②目的：快速开发高性能、高可靠性的网络服务器和客户端程序 ③优点：提供异步的、事件驱动的网络应用程序框架和工具...
dubbo源代码
10-30
dubbo分布式服务框架，方便大家对分布式服务的学习，方便对dubbo的扩展
Dubbo源代码（2.5.4）
10-27
Dubbo的源代码打包，2.5.4开发发布版，及与Maven构建，本人亲测，可以编译通过。
dubbo教学视频含源码
01-30
里面是dubbo教程视频还有视频配套源码百度网盘的链接和密码，导入即可运行，，，，，，，，，，，，，，，，，
dubbo-dubbo-2.7.2源码
10-23
本次我们将通过分析Dubbo 2.7.2的源码，来深入了解其设计理念和实现机制，帮助开发者更好地理解和运用这个强大的工具。 一、Dubbo架构概览 Dubbo的核心架构基于服务提供者（Provider）、消费者（Consumer）、注册...
【Java教程】dubbo源码解析-网络通信
Blue92120的博客
09-26 306
在之前的内容中，我们讲解了消费者端服务发现与提供者端服务暴露的相关内容，同时也知道消费者端通过内置的负载均衡算法获取合适的调用invoker进行远程调用。那么，本章节重点关注的就是远程调用过程即网络通信。Remoting 实现是 Dubbo 协议的实现，如果你选择 RMI 协议，整个 Remoting 都不会用上；Remoting 内部再划为和；Transport 层只负责单向消息传输，是对 Mina, Netty, Grizzly 的抽象，它也可以扩展 UDP 传输；
Dubbo源码解析一网络通信原理
最新发布
沉浸式Study
06-03 823
集群就是单机的多实例, 在多个服务器上部署部署N个节点，处理业务的能力就提升 N倍（大约），这些节点的集合就叫做集群Directory：它代表多个Invoker，从methodInvokerMap提取，但是他的值是动态，例如注册中心的变更Router：负责从多个Invoker中按路由规则选出子集，例如应用隔离或读写分离或灰度发布等等Cluster：将Directory中的多个Invoker伪装成一个Invoker,来容错，调用失败重试。
Dubbo系统间通信
天高任鸟飞
08-27 401
系统间通信 远程通信，实现方案 Webservice Restful Dubbo Webservice 基于soap协议，通信效率不高 主要特点，跨语言、跨平台 项目中，不推荐使用 可用于，不同公司之间的接口调用 Restful 基于http协议，形式http+json 一种架构风格，很多项目中应用 如果，服务太多 服务之间调用关系混乱，需要治疗服务 Dubbo ...
Dubbo的实现原理即网络通信原理
qyj226的博客
04-02 1566
Dubbo是一款高性能 Java RPC框架 。 实现了服务注册和发现 ，容错负载均衡，扩展性，基于接口的远程调用 1.Dubbo整合Spring的主要配置项 provider配置 <!--1. 应用配置，定义服务提供者--> <dubbo:application name="spring-provider36"/> <!--2. 将服务接口的实现类对象，放入Spring中--> <bean id="demoService" cla
dubbo网络通信的编解码过程解析
xiaovfight的专栏
03-24 462
写这篇文章的初衷是最近被别人问到dubbo的通信协议及底层序列化过程，发现自己比较欠缺这一块的知识。所以这个周末，结合了dubbo源码和一些网络教程，总结了一下。 编码和解码 首先做一下名词解释 编码：序列化，它将对象序列化为字节数组，用于网络传输，数据持久化或者其他用途。 解码：反序列化，把从网络，磁盘等读取的字节数还原成原始对象，以方便后续的业务逻辑操作。 dubbo在IP和TCP协议之上，又...
Dubbo源码解析：服务提供者暴露服务过程
"阿里巴巴Dubbo实现的源码分析" 在深入探讨阿里巴巴Dubbo的源码之前，首先要理解Dubbo的核心功能和设计目标。Dubbo是一个分布式服务框架，它提供了高性能的RPC（Remote Procedure Call）解决方案，使得服务调用变得...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值