由浅入深Netty入门案例

àì夳堔傛蜴生んèń 2024-03-22 19:43 110阅读 0赞

#### 目录 ####

*  1 概述
 *   *  1.1 Netty 是什么？
     *  1.2 Netty 的作者
     *  1.3 Netty 的地位
     *  1.4 Netty 的优势
 *  2 Hello World
 *   *  2.1 目标
     *  2.2 服务器端
     *  2.3 客户端
     *  2.4 流程梳理
     *  2.5 提示

--------------------

## 1 概述 ##

![在这里插入图片描述][0f04b29287da4e8b82468f68e8efd6be.png]

### 1.1 Netty 是什么？ ###

Netty is an asynchronous event-driven network application framework
    for rapid development of maintainable high performance protocol servers & clients.

Netty 是一个异步的、基于事件驱动的网络应用框架，用于快速开发可维护、高性能的网络服务器和客户端

### 1.2 Netty 的作者 ###

![在这里插入图片描述][51db803fe22f45669be8d35af65b9bdf.png]

他还是另一个著名网络应用框架 Mina 的重要贡献者

### 1.3 Netty 的地位 ###

Netty 在 Java 网络应用框架中的地位就好比：Spring 框架在 JavaEE 开发中的地位

以下的框架都使用了 Netty，因为它们有网络通信需求！

*  Cassandra - nosql 数据库
 *  Spark - 大数据分布式计算框架
 *  Hadoop - 大数据分布式存储框架
 *  RocketMQ - ali 开源的消息队列
 *  ElasticSearch - 搜索引擎
 *  gRPC - rpc 框架
 *  Dubbo - rpc 框架
 *  Spring 5.x - flux api 完全抛弃了 tomcat ，使用 netty 作为服务器端
 *  Zookeeper - 分布式协调框架

### 1.4 Netty 的优势 ###

*  Netty vs NIO，工作量大，bug 多
    
     *  需要自己构建协议
     *  解决 TCP 传输问题，如粘包、半包
     *  epoll 空轮询导致 CPU 100%
     *  对 API 进行增强，使之更易用，如 FastThreadLocal => ThreadLocal，ByteBuf => ByteBuffer
 *  Netty vs 其它网络应用框架
    
     *  Mina 由 apache 维护，将来 3.x 版本可能会有较大重构，破坏 API 向下兼容性，Netty 的开发迭代更迅速，API 更简洁、文档更优秀
     *  久经考验，16年，Netty 版本
        
         *  2.x 2004
         *  3.x 2008
         *  4.x 2013
         *  5.x 已废弃（没有明显的性能提升，维护成本高）

## 2 Hello World ##

### 2.1 目标 ###

开发一个简单的服务器端和客户端

*  客户端向服务器端发送 hello, world
 *  服务器仅接收，不返回

加入依赖

<dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>
        <version>4.1.39.Final</version>
    </dependency>

### 2.2 服务器端 ###

new ServerBootstrap()
        .group(new NioEventLoopGroup()) // 1
        .channel(NioServerSocketChannel.class) // 2
        .childHandler(new ChannelInitializer<NioSocketChannel>() {
         // 3
            protected void initChannel(NioSocketChannel ch) {
        
                ch.pipeline().addLast(new StringDecoder()); // 5
                ch.pipeline().addLast(new SimpleChannelInboundHandler<String>() {
         // 6
                    @Override
                    protected void channelRead0(ChannelHandlerContext ctx, String msg) {
        
                        System.out.println(msg);
                    }
                });
            }
        })
        .bind(8080); // 4

代码解读

*  1 处，创建 NioEventLoopGroup，可以简单理解为 `线程池 + Selector` 后面会详细展开
 *  2 处，选择服务 Scoket 实现类，其中 NioServerSocketChannel 表示基于 NIO 的服务器端实现，其它实现还有

![在这里插入图片描述][3cbac505f3ab463caa199cc9acc5fa91.png]

*  3 处，为啥方法叫 childHandler，是接下来添加的处理器都是给 SocketChannel 用的，而不是给 ServerSocketChannel。ChannelInitializer 处理器（仅执行一次），它的作用是待客户端 SocketChannel 建立连接后，执行 initChannel 以便添加更多的处理器
 *  4 处，ServerSocketChannel 绑定的监听端口
 *  5 处，SocketChannel 的处理器，解码 ByteBuf => String
 *  6 处，SocketChannel 的业务处理器，使用上一个处理器的处理结果

### 2.3 客户端 ###

new Bootstrap()
        .group(new NioEventLoopGroup()) // 1
        .channel(NioSocketChannel.class) // 2
        .handler(new ChannelInitializer<Channel>() {
         // 3
            @Override
            protected void initChannel(Channel ch) {
        
                ch.pipeline().addLast(new StringEncoder()); // 8
            }
        })
        .connect("127.0.0.1", 8080) // 4
        .sync() // 5
        .channel() // 6
        .writeAndFlush(new Date() + ": hello world!"); // 7

代码解读

*  1 处，创建 NioEventLoopGroup，同 Server
 *  2 处，选择客户 Socket 实现类，NioSocketChannel 表示基于 NIO 的客户端实现，其它实现还有

![在这里插入图片描述][46afb523cef1495f81bd7e92ddae8f7e.png]

*  3 处，添加 SocketChannel 的处理器，ChannelInitializer 处理器（仅执行一次），它的作用是待客户端 SocketChannel 建立连接后，执行 initChannel 以便添加更多的处理器
 *  4 处，指定要连接的服务器和端口
 *  5 处，Netty 中很多方法都是异步的，如 connect，这时需要使用 sync 方法等待 connect 建立连接完毕
 *  6 处，获取 channel 对象，它即为通道抽象，可以进行数据读写操作
 *  7 处，写入消息并清空缓冲区
 *  8 处，消息会经过通道 handler 处理，这里是将 String => ByteBuf 发出
 *  数据经过网络传输，到达服务器端，服务器端 5 和 6 处的 handler 先后被触发，走完一个流程

### 2.4 流程梳理 ###

![在这里插入图片描述][2a4b95dede544e89a30124b59ba70cb1.png]

### 2.5 提示 ###

> 一开始需要树立正确的观念
> 
>  *  把 channel 理解为数据的通道
>  *  把 msg 理解为流动的数据，最开始输入是 ByteBuf，但经过 pipeline 的加工，会变成其它类型对象，最后输出又变成 ByteBuf
>  *  把 handler 理解为数据的处理工序
>     
>      *  工序有多道，合在一起就是 pipeline，pipeline 负责发布事件（读、读取完成…）传播给每个 handler， handler 对自己感兴趣的事件进行处理（重写了相应事件处理方法）
>      *  handler 分 Inbound 和 Outbound 两类
>  *  把 eventLoop 理解为处理数据的工人
>     
>      *  工人可以管理多个 channel 的 io 操作，并且一旦工人负责了某个 channel，就要负责到底（绑定）
>      *  工人既可以执行 io 操作，也可以进行任务处理，每位工人有任务队列，队列里可以堆放多个 channel 的待处理任务，任务分为普通任务、定时任务
>      *  工人按照 pipeline 顺序，依次按照 handler 的规划（代码）处理数据，可以为每道工序指定不同的工人

[0f04b29287da4e8b82468f68e8efd6be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/92c67d29d8934ab6a4d2ee4ba8df3970.png
[51db803fe22f45669be8d35af65b9bdf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/48f9a226c56b4298952325989278991e.png
[3cbac505f3ab463caa199cc9acc5fa91.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/ef2dea1db14247d08a8420dff8f27e19.png
[46afb523cef1495f81bd7e92ddae8f7e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/6c474d4b2a974a16bfbcb73665df5a28.png
[2a4b95dede544e89a30124b59ba70cb1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/84f082cd864a44989f283e8e7d821139.png