Dubbo学习记录(十五) - 服务调用【一】-之 服务端Netty的hander包装过程与 服务端线程模型_dispacterhander

于 2024-05-15 11:43:03 发布
阅读量346 收藏 7
点赞数 5
分类专栏： 程序员 文章标签： c语言 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84973716/article/details/138902322
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

ExchangeHandlerAdapter

当请求到来的时候, 首先是调用received(Channel channel, Object message),然后会调用reply(ExchangeChannel channel, Object message)处理ing求，message就是请求的数据， channel则表示与客户端的长连接；
工作过程： 最终就是通过反射技术调用Method.invoke执行服务；

  1. 类型转换， 将Object转换为Invocation;
  2. 调用getInvoker获取服务提供者的执行器；（这个Invoker会被多层包装）
  3. 设置远程地址remoteAddress给RpcContext
  4. 调用执行器的invoke方法， 返回结果；
  5. 返回一个CompletionFuture实例；
private ExchangeHandler requestHandler = new ExchangeHandlerAdapter() {

        @Override
        public CompletableFuture<Object> reply(ExchangeChannel channel, Object message) throws RemotingException {
            Invocation inv = (Invocation) message;
            Invoker<?> invoker = getInvoker(channel, inv); 
			//省略部分代码
            RpcContext.getContext().setRemoteAddress(channel.getRemoteAddress());
            Result result = invoker.invoke(inv);
            return result.completionFuture().thenApply(Function.identity());
        }

        @Override
        public void received(Channel channel, Object message) throws RemotingException {
            if (message instanceof Invocation) {
                // 这是服务端接收到Invocation时的处理逻辑
                reply((ExchangeChannel) channel, message);
            } else {
                super.received(channel, message);
            }
        }
}

Exchangers.bind(url, requestHandler)

过程：

  1. 调用getExchanger(url)，通过SPI机制获取Exchanger的扩展实现类， 默认的实现类是HeaderExhanger
  2. 调用bind方法启动netty;
    public static ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
        // codec表示协议编码方式
        url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");
        // 通过url得到HeaderExchanger， 利用HeaderExchanger进行bind，将得到一个HeaderExchangeServer
        return getExchanger(url).bind(url, handler);
    }
HeaderExchanger#bind(Url, hander)

工作：

  1. 首先会传进来的ExchangeHandlerAdapter实例handler进行包装， 包装为HeaderExchangerHandler;
  2. 再对HeaderExchangerHandler包装为DecodeHandler的实例；
  3. 调用Transporters#bind方法创建一个NettyServer,
  4. 将NettyServer实例包装为HeaderExchangerServer； 返回；
    @Override
    public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {

        // 下面会去启动Netty
        // 对handler包装了两层，表示当处理一个请求时，每层Handler负责不同的处理逻辑
        // 为什么在connect和bind时都是DecodeHandler，解码，解的是把InputStream解析成RpcInvocation对象
        return new HeaderExchangeServer(Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
    }
Transporters.bind(url, handlers)

工作流程：

  1. 如果bind了多个handler，那么当有一个连接过来时，会循环每个handler去处理连接
  2. 调用getTransport()方法通过SPI机制获取一个Transporter实例， 默认情况下是NettyTransporter实例；
  3. 调用NettyTransport#bind方法，创建一个nettyServer;
    public static Server bind(URL url, ChannelHandler... handlers) throws RemotingException {
		//....

        // 
        ChannelHandler handler;
        if (handlers.length == 1) {
            handler = handlers[0];
        } else {
            handler = new ChannelHandlerDispatcher(handlers);
        }
        // 调用NettyTransporter去绑定，Transporter表示网络传输层
        return getTransporter().bind(url, handler);
    }
NettyTransporter#bind(url, listener)

创建Nettyserver实例；

public class NettyTransporter implements Transporter {

    public static final String NAME = "netty";

    @Override
    public Server bind(URL url, ChannelHandler listener) throws RemotingException {
        return new NettyServer(url, listener);
    }

    @Override
    public Client connect(URL url, ChannelHandler listener) throws RemotingException {
        return new NettyClient(url, listener);
    }

}
NettyServer(URL url, ChannelHandler handler)
  1. 调用ChannerHandlers.wrap方法包装DecoderHandler实例；
  2. 调用父类构造方法；
public class NettyServer extends AbstractServer implements Server {
    private Map<String, Channel> channels;

    private ServerBootstrap bootstrap;

	private io.netty.channel.Channel channel;

    private EventLoopGroup bossGroup;
    private EventLoopGroup workerGroup;

    public NettyServer(URL url, ChannelHandler handler) throws RemotingException {
        super(url, ChannelHandlers.wrap(handler, ExecutorUtil.setThreadName(url, SERVER_THREAD_POOL_NAME)));
    }
ChannelHandlers.wrap(ChannelHandler handler, URL url)
  1. 调用ChannelHandlers#getInstance()方法获取单例ChannelHandlers, 使用的是饿汉式；
  2. 调用wrapInternal(handler, url) 包装DecoderHandler实例handler：
    public static ChannelHandler wrap(ChannelHandler handler, URL url) {
        return ChannelHandlers.getInstance().wrapInternal(handler, url);
    }
ChannelHandlers#wrapInternal(handler, url)

工作流程：

  1. 通过Spi机制调用将DecoderHandler实例包装为AllChannelHandler实例；
  2. 再将AllChannelHandler包装为MultiMessageHandler实例；
public class ChannelHandlers {
    // 单例模式
    private static ChannelHandlers INSTANCE = new ChannelHandlers();

    protected ChannelHandlers() {
    }

    public static ChannelHandler wrap(ChannelHandler handler, URL url) {
        return ChannelHandlers.getInstance().wrapInternal(handler, url);
    }

    protected static ChannelHandlers getInstance() {
        return INSTANCE;
    }

    static void setTestingChannelHandlers(ChannelHandlers instance) {
        INSTANCE = instance;
    }

    protected ChannelHandler wrapInternal(ChannelHandler handler, URL url) {
        // 先通过ExtensionLoader.getExtensionLoader(Dispatcher.class).getAdaptiveExtension().dispatch(handler, url)
        // 得到一个AllChannelHandler(handler, url)
        // 然后把AllChannelHandler包装成HeartbeatHandler，HeartbeatHandler包装成MultiMessageHandler
        // 所以当Netty接收到一个数据时，会经历MultiMessageHandler--->HeartbeatHandler---->AllChannelHandler
        // 而AllChannelHandler会调用handler
        return new MultiMessageHandler(new HeartbeatHandler(ExtensionLoader.getExtensionLoader(Dispatcher.class)
                .getAdaptiveExtension().dispatch(handler, url)));
    }
}

这里Dispacter涉及到服务端的线程模型， 标记

AbstractServer(URL url, ChannelHandler handler)

创建NettyServer实例会将调用父类构造方法， 父类式AbstractServer， 抽象类；
工作流程：

  1. 调用父类的构造方法， 将handler赋值给父类AbstractPeer的handler属性；
  2. 获取本地地址localAddress;
  3. 获取服务绑定的IP；
  4. 获取服务绑定的端口号；
  5. 创建InetSocketAddress实例， 用来创建Socke连接的构造参数；
  6. 调用doOpen()启动netty;
public AbstractServer(URL url, ChannelHandler handler) throws RemotingException {
        super(url, handler);
        localAddress = getUrl().toInetSocketAddress();

        String bindIp = getUrl().getParameter(Constants.BIND_IP_KEY, getUrl().getHost());
        int bindPort = getUrl().getParameter(Constants.BIND_PORT_KEY, getUrl().getPort());
        if (url.getParameter(ANYHOST_KEY, false) || NetUtils.isInvalidLocalHost(bindIp)) {
            bindIp = ANYHOST_VALUE;
        }
        bindAddress = new InetSocketAddress(bindIp, bindPort);
        this.accepts = url.getParameter(ACCEPTS_KEY, DEFAULT_ACCEPTS);
        this.idleTimeout = url.getParameter(IDLE_TIMEOUT_KEY, DEFAULT_IDLE_TIMEOUT);
        try {
            doOpen();
            if (logger.isInfoEnabled()) {
                logger.info("Start " + getClass().getSimpleName() + " bind " + getBindAddress() + ", export " + getLocalAddress());
            }
        } catch (Throwable t) {
           //....
        }
//...
    }
AbstractEndpoint(url, handler)

调用父类构造方法， 设置编码方式， 设置服务提供者的超时时间， 设置创建连接的超时时间。

    public AbstractEndpoint(URL url, ChannelHandler handler) {
        super(url, handler);
        this.codec = getChannelCodec(url);
        this.timeout = url.getPositiveParameter(TIMEOUT_KEY, DEFAULT_TIMEOUT);
        this.connectTimeout = url.getPositiveParameter(Constants.CONNECT_TIMEOUT_KEY, Constants.DEFAULT_CONNECT_TIMEOUT);
    }
AbstractPeer(URL url, ChannelHandler handler)

将handler保存起来；

public abstract class AbstractPeer implements Endpoint, ChannelHandler {

    private final ChannelHandler handler;
    private volatile URL url;
    private volatile boolean closing;
    private volatile boolean closed;
    public AbstractPeer(URL url, ChannelHandler handler) {
        this.url = url;
        this.handler = handler;
    }
NettyServer#doOpen()

上面过程中，调用new NettyServer, 会将MultiMessageHandler赋值给NettyServer的Handler属性；
因此，NettyServer另一种身份是一个MultiMessageHandler:
工作流程：

  1. 创建ServerBootstrap服务端；
  2. 创建工作线程组，IO事件线程组；
  3. 创建NettyServerHandler， 将this传进去， 即传了一个MultiMessageHandler，包装为一个NettyServerHandler实例；
  4. 服务端参数的设置；
@Override
    protected void doOpen() throws Throwable {
        bootstrap = new ServerBootstrap();

        bossGroup = new NioEventLoopGroup(1, new DefaultThreadFactory("NettyServerBoss", true));
        workerGroup = new NioEventLoopGroup(getUrl().getPositiveParameter(IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS),
                new DefaultThreadFactory("NettyServerWorker", true));

        final NettyServerHandler nettyServerHandler = new NettyServerHandler(getUrl(), this);
        channels = nettyServerHandler.getChannels();

        bootstrap.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childOption(ChannelOption.TCP_NODELAY, Boolean.TRUE)
                .childOption(ChannelOption.SO_REUSEADDR, Boolean.TRUE)
                .childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT)
                .childHandler(new ChannelInitializer<NioSocketChannel>() {
                    @Override
                    protected void initChannel(NioSocketChannel ch) throws Exception {
                        // FIXME: should we use getTimeout()?
                        int idleTimeout = UrlUtils.getIdleTimeout(getUrl());
                        NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec(), getUrl(), NettyServer.this);
                        ch.pipeline()//.addLast("logging",new LoggingHandler(LogLevel.INFO))//for debug
                                .addLast("decoder", adapter.getDecoder())
                                .addLast("encoder", adapter.getEncoder())
                                .addLast("server-idle-handler", new IdleStateHandler(0, 0, idleTimeout, MILLISECONDS))
                                .addLast("handler", nettyServerHandler);
                    }
                });
        // bind
        ChannelFuture channelFuture = bootstrap.bind(getBindAddress());
        channelFuture.syncUninterruptibly();
        channel = channelFuture.channel();

    }

服务端Netty的hander包装过程总结

  1. ExchangeHandlerAdapter的requestHandler实例包装为HeaderExchangerhandler
  2. 将HandlerExchangerHandler实例包装为Decodehandler;
  3. 将DecodeHandler实例包装为AllChannelHandler;
  4. 将AllChannelHandler实例包装为MultiMessageHandler实例；
  5. 将MultiMessageHandler实例包装为NettyServerHandler;
  6. 最终将NettyServerHandler绑定到PipeLine种的handler处理器；

服务端线程模型

涉及的过程是 ： 将DecodeHandler包装为AllChannelhandler的过程；

    protected ChannelHandler wrapInternal(ChannelHandler handler, URL url) {
        return new MultiMessageHandler(new HeartbeatHandler(ExtensionLoader.getExtensionLoader(Dispatcher.class)
                .getAdaptiveExtension().dispatch(handler, url)));
    }

通过SPI机制获取Dispatcher的扩展实现类，

@SPI(AllDispatcher.NAME)
public interface Dispatcher {

    /\*\*
 \* dispatch the message to threadpool.
 \*
 \* @param handler
 \* @param url
 \* @return channel handler
 \*/
    @Adaptive({Constants.DISPATCHER_KEY, "dispather", "channel.handler"})
    // The last two parameters are reserved for compatibility with the old configuration
    ChannelHandler dispatch(ChannelHandler handler, URL url);

}

默认使用AllDispatcher#dispatch方法；

AllDispatcher #dispatch(handler, url)

创建AllChannelHandler实例， 包装了一个handler;

public class AllDispatcher implements Dispatcher {

    public static final String NAME = "all";

    @Override
    public ChannelHandler dispatch(ChannelHandler handler, URL url) {
        return new AllChannelHandler(handler, url);
    }

}
AllChannelHandler

当netty接收到数据后，会调用received方法

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

{
return new AllChannelHandler(handler, url);
}

}


##### AllChannelHandler


当netty接收到数据后，会调用received方法





[外链图片转存中...(img-Iu6HAGuO-1715744560750)]
[外链图片转存中...(img-XX8iKggC-1715744560751)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
2401_84973716
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ priority_queue用法总结
weixin_45055461的博客
01-07 1100
如果元素类型不支持操作符，或者你希望使用自定义的比较规则，可以通过提供比较函数来初始化。这样创建的是最小堆，元素按照升序排序。
数据结构——家谱管理系统
m0_62788711的博客
12-25 5837
数据结构期末的一个课程设计！
c++ priority_queue用法
bieliwuguiqi的博客
04-28 321
priority_queue
hook代码 svn_浅谈svn的hook机制
weixin_39625172的博客
12-19 317
一、什么是钩子所谓svn的hook机制，就是用户在管理数据仓库的时候，当特定的事件发生时，相应的hook会被调用，hook 其实就相当于特定事件的处理函数。当前 Subversion 提供了5种可以安装的 hook ：事件名时机与hook交互一般用途start-commit事务创建之前。传给 hook 的 参数：- 参 数 1 ， 代码库路径。- 参 数 2 ， 试...
家谱管理系统的设计与实现（附源码）
最新发布
weixin_63524946的博客
01-05 2441
数据结构课程设计：家谱管理系统的设计与实现
dubbo-user-book.rar_SOA_dubbo_dubbo-user-book_分布式
09-24
同时，Dubbo的丰富特性和易用性使其在企业级应用中得到广泛应用，成为Java平台上分布式服务治理的事实标准之一。 总结来说，了解和掌握SOA和Dubbo的相关知识，对于开发者来说是提升技能、应对复杂分布式环境挑战的...
alibaba-dubbo-dubbo-2.5.8-4-gc8093cf.zip_dubbo 2.5_dubbo 2.8.4_d
09-15
Dubbo是阿里巴巴开源的一款高性能、轻量级的服务治理框架，它主要应用于分布式服务之间的调用，为开发者提供了服务注册、服务发现、负载均衡、容错处理等功能，极大地提高了微服务架构下的开发效率和系统稳定性。...
02-VIP-Netty核心功能与线程模型精讲1
08-03
总的来说，Netty 是一个强大且灵活的网络通信框架，通过其高效的线程模型、易于使用的 API 和丰富的功能，极大地降低了开发网络应用的复杂性，提高了系统的性能和可扩展性。无论是在微服务架构、游戏后端，还是...
jmeter-plugins-dubbo-2.7.8-jar-with-dependencies.jar
06-22
jmeter的dubbo插件，jmeter-plugins-dubbo-2.7.8-jar-with-dependencies.jar，适用于JMeter5.4.1版本，将解压后的文件jmeter-plugins-dubbo-2.7.8-jar-with-dependencies放在Jmeter安装目录下的\lib\ext文件夹中，...
数据结构-家谱管理系统.txt
07-11
/*7、家谱管理系统 （4） 任务：实现具有下列功能的家谱管理系统 功能要求： 1). 输入文件以存放最初家谱中各成员的信息，成员的信息中均应包含以下内容： 姓名、出生日期、婚否、地址、健在否、死亡日期（若其已死亡），也可附加其它信息、但不是必需的。 2). 实现数据的存盘和读盘。 3). 以图形方式显示家谱。 4). 显示第n 代所有人的信息。 5). 按照姓名查询，输出成员信息（包括其本人、父亲、孩子的信息）。 6). 按照出生日期查询成员名单。 7). 输入两人姓名，确定其关系。 8). 某成员添加孩子。 9). 删除某成员（若其还有后代，则一并删除）。 10).修改某成员信息。 11).按出生日期对家谱中所有人排序。 12).打开一家谱时，提示当天生日的健在成员。 要求：建立至少30个成员的数据，以较为直观的方式显示结果，并提供文稿形式以便检查。 界面要求：有合理的提示，每个功能可以设立菜单，根据提示，可以完成相关的功能要求。 存储结构：学生自己根据系统功能要求自己设计，但是要求相关数据要存储在数据文件中。 测试数据：要求使用1、全部合法数据；2、局部非法数据。进行程序测试，以
数据结构—课程设计（家谱树管理系统）
06-28
这个是用MFC做的，有关数据结构—课程设计——家谱树管理系统的程序和代码
数据结构大作业(家谱管理系统)
05-28
计算机专业大作业,数据结构大作业(家谱管理系统)
家谱管理系统--数据结构大作业.doc
07-11
/* 家谱管理系统 任务：实现具有下列功能的家谱管理系统 功能要求： 1). 输入文件以存放最初家谱中各成员的信息，成员的信息中均应包含以下内容： 姓名、出生日期、婚否、地址、健在否、死亡日期（若其已死亡），也可附加其它信息 、但不是必需的。 2). 实现数据的存盘和读盘。 3). 以图形方式显示家谱。 4). 显示第n 代所有人的信息。 5). 按照姓名查询，输出成员信息（包括其本人、父亲、孩子的信息）。 6). 按照出生日期查询成员名单。 7). 输入两人姓名，确定其关系。 8). 某成员添加孩子。 9). 删除某成员（若其还有后代，则一并删除）。 10).修改某成员信息。 11).按出生日期对家谱中所有人排序。 12).打开一家谱时，提示当天生日的健在成员。 要求：建立至少30个成员的数据，以较为直观的方式显示结果，并提供文稿形式以便检 查。 界面要求：有合理的提示，每个功能可以设立菜单，根据提示，可以完成相关的功能要 求。 存储结构：学生自己根据系统功能要求自己设计，但是要求相关数据要存储在数据文件 中。 测试数据：要求使用1、全部合法数据；2、局部非法数据。进行程序测试，以保
数据库课程设计：家族族谱管理系统.zip
06-02
数据库课程设计：家族族谱管理系统.zip
c语言课程设计家谱管理系统,数据结构-家谱管理系统
weixin_28934081的博客
05-22 3060
《数据结构-家谱管理系统》由会员分享，可在线阅读，更多相关《数据结构-家谱管理系统(15页珍藏版)》请在人人文库网上搜索。1、宁波大红鹰学院信息工程学院课程设计报告项目名称：家谱查询系统项目组长：白钰琦项目成员：徐程凯、徐海域、项鸿伟班级名称：10计科1班专业名称：计算机科学与技术完成时间:2012年12月1日信息工程学院制目 录一、案例描述- 3 -1、总体描述- 3 -2、模块描述- 3 -二...
QT编译报错：error: no matching function for call to ‘MainWindow::connect(QAction*&, void (QAction::*)....
weixin_A13253323604
09-02 2170
用qt编译，编译报错： error: no matching function for call to 'MainWindow::connect(QAction*&, void (QAction::*)(bool), MainWindow* const, MainWindow::MainWindow(QWidget*)::__lambda0)'}); 这是因为QT的版本太低。如果我们在写代码的时候，用到了Lambda表达式，如果QT的版本是5.4以前，需要在.pro文件中，加入这样一行代码： CO
二叉树家谱系统
m0_64122265的博客
11-22 1394
二叉树实现家谱系统
"Dubbo学习笔记：RPC远程过程调用原理与实践
学习dubbo的过程中，我逐字逐句地记录了下来。内容包括了dubbo与springboot的整合，以及如何在springcloud中构建dubbo项目，以及dubbo项目之间的通信等方面。首先，我对RPC（远程过程调用）进行了学习。RPC是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值