Netty进阶

最新推荐文章于 2022-05-04 13:57:24 发布
最新推荐文章于 2022-05-04 13:57:24 发布
阅读量214 收藏
点赞数
分类专栏： Netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ARSCCC/article/details/117638035
版权
文章目录1. Netty的粘包与半包现象1.1 粘包现象1. Netty的粘包与半包现象1.1 粘包现象
摘要由CSDN通过智能技术生成

文章目录

1. Netty的粘包与半包现象

1.1 粘包现象

  • 以下代码展示了黏包现象的产生

    package com.zhyn.nettyadvance;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class Server0 {
     
    public static void main(String[] args) {
     
        new Server0().start();
    }

    public void start() {
     
        NioEventLoopGroup boss = new NioEventLoopGroup(1);
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
     
            final ChannelFuture channelFuture = new ServerBootstrap()
                    .group(boss, worker)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
     
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
     
                            ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                            ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
     
                                @Override
                                // 连接建立时会执行该方法
                                public void channelActive(ChannelHandlerContext ctx) throws Exception {
     
                                    log.debug("connected {}", ctx.channel());
                                    super.channelActive(ctx);
                                }

                                @Override
                                // 连接断开时会执行该方法
                                public void channelInactive(ChannelHandlerContext ctx) throws Exception {
     
                                    log.debug("disconnect {}", ctx.channel());
                                    super.channelInactive(ctx);
                                }
                            });
                        }
                    }).bind(8080);
            log.debug("{} binding...", channelFuture.channel());
            channelFuture.sync();
            log.debug("{} bound", channelFuture.channel());
            // 关闭channel
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
     
            log.error("server error", e);
        } finally {
     
            boss.shutdownGracefully();
            worker.shutdownGracefully();
            log.debug("stopped");
        }
    }
}


    package com.zhyn.nettyadvance;

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import lombok.extern.slf4j.Slf4j;

import java.net.InetSocketAddress;

@Slf4j
public class Client0 {
     
    public static void main(String[] args) {
     
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
     
            ChannelFuture channelFuture = new Bootstrap()
                    .channel(NioSocketChannel.class)
                    .group(worker)
                    .handler(new ChannelInitializer<SocketChannel>() {
     
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
     
                            log.debug("connected...");
                            ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
     
                                @Override
                                public void channelActive(ChannelHandlerContext ctx) throws Exception {
     
                                    log.debug("sending...");
                                    // 每次发送16个字节的数据，一共发送10次
                                    for (int i = 0; i < 10; i++) {
     
                                        ByteBuf buffer = ctx.alloc().buffer();
                                        buffer.writeBytes(new byte[]{
     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
                                        ctx.writeAndFlush(buffer);
                                    }
                                }
                            });
                        }
                    })
                    .connect(new InetSocketAddress(8080))
                    .sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
     
            log.error("client error", e);
        } finally {
     
            worker.shutdownGracefully();
        }
    }
}

  • 输出结果：从输出结果中可以看出服务器一次就接受到了160个字节的数据，而不是分10次接收16个字节的数据，这就是黏包问题；

    10:38:07 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0x117c169d, L:/192.168.31.158:8080 - R:/192.168.31.158:54158] READ: 160B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000010| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000020| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000030| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000040| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000050| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000060| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000070| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000080| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000090| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
+--------+-------------------------------------------------+----------------+

1.2 半包现象

  • 将代码做以下的的修改，使得客户端代码发送 1 个消息，这个消息是 160 个字节，并将客户端-服务器之间的channel容量进行调整：

    // 对客户端的修改
ByteBuf buffer = ctx.alloc().buffer();
for (int i = 0; i < 10; i++) {
     
    buffer.writeBytes(new byte[]{
     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
}
ctx.writeAndFlush(buffer);

// 对服务端的修改
// serverBootstrap.option(ChannelOption.SO_RCVBUF, 10) 实际上影响的是底层接收缓冲区（即滑动窗口）的大小
// 它仅仅决定了 netty 读取数据的最小单位，但是 netty 实际上每次读取的数据大小一般是它的整数倍
serverBootstrap.option(ChannelOption.SO_RCVBUF, 10);

  • 输出结果：可以看到接收消息被分为两节，第一节为20个字节，第二节为140个字节，这就是半包现象；

    10:49:36 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xa1b502a3, L:/192.168.31.158:8080 - R:/192.168.31.158:54473] READ: 20B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f |................|
|00000010| 00 01 02 03                                     |....            |
+--------+-------------------------------------------------+----------------+
10:49:36 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xa1b502a3, L:/192.168.31.158:8080 - R:/192.168.31.158:54473] READ COMPLETE
10:49:36 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xa1b502a3, L:/192.168.31.158:8080 - R:/192.168.31.158:54473] READ: 140B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000010| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000020| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000030| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000040| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000050| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000060| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000070| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 00 01 02 03 |................|
|00000080| 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f             |............    |
+--------+-------------------------------------------------+----------------+

1.3 对于粘包现象和半包现象的分析

  • 粘包现象，发送 abc def，接收 abcdef；

  • 具体原因：

    • 应用层：接收方 ByteBuf 设置太大（Netty 默认 1024）
    • 滑动窗口：假设发送方 256 bytes 表示一个完整报文，但由于接收方处理不及时且窗口大小足够大，这 256 bytes 字节就会缓冲在接收方的滑动窗口中，当滑动窗口中缓冲了多个报文时就会发生粘包
    • Nagle 算法：TCP, IP的报头都是20个字节，哪怕我们想要传输的内容仅仅是1个字节，传输的时候也会有41个字节大小的数据，为了避免这一现象的发生，Nagle 算法会尽可能多地发送数据，所以会发生黏包现象；

  • 半包现象，发送 abcdef，接收 abc def

  • 具体原因：

    • 应用层：接收方 ByteBuf 小于实际发送数据量；
    • 滑动窗口：假设接收方的窗口只剩了 128 bytes，发送方的报文大小是 256 bytes，这时放不下了，只能先发送前 128 bytes，等待 ack 后才能发送剩余部分，这就造成了半包；
    • MSS 限制：当发送的数据大小超过 MSS 限制后，会将数据切分发送，就会造成半包(localhost回环地址，也就是我们平时做测试用的本机地址对MSS几乎是没有限制，非常的大，我们自己不容易复现这个现象；补充：MTU是最大传输单元，由硬件规定，以太网的MTU为1500字节；MSS是最大分节大小，为TCP数据包每次传输的最大数据分段大小，MSS的值为MTU减去IPv4Header和TCPHeader的大小得到的)；
    • 本质是因为 TCP 是流式协议，消息无边界；

  • 关于滑动窗口的补充：

    • TCP 以一个段（segment）为单位，每发送一个段就需要进行一次确认应答（ack）处理，这么做的缺点是包的往返时间越长性能就越差；
      在这里插入图片描述

    • 为了解决此问题，引入了窗口概念，窗口大小决定了无需等待应答而可以继续发送的数据的最大值；
      在这里插入图片描述

    • 窗口实际就起到一个缓冲区的作用，同时也能起到流量控制的作用

      • 该窗口是可以滑动的，每处理完一批数据，窗口就可以向下滑动继续处理下一批数据；
      • 窗口内的数据才允许被发送，当应答未到达前，窗口必须停止滑动
      • 假设发送方滑动窗口的大小是1000.如果 1001~2000 这个段的数据 ack 回来了，窗口就可以向前滑动；
      • 接收方也会维护一个窗口，只有落在窗口内的数据才能允许接收；
      • 滑动窗口的大小一般是可调整自适应的，不需要我们可以的设置滑动窗口的大小；
      • Netty对客户端默认的滑动窗口(缓冲区)大小是1024；

  • 关于MSS的补充

    • 链路层对一次能够发送的最大数据有限制，这个限制称之为 MTU（maximum transmission unit），不同的链路设备的 MTU 值也有所不同，例如以太网的 MTU 是 1500，FDDI（光纤分布式数据接口）的 MTU 是 4352，本地回环地址的 MTU 是 65535 - 本地测试不走网卡；
    • MSS 是最大段长度（maximum segment size），它是 MTU 刨去 tcp 头和 ip 头后剩余能够作为数据传输的字节数；
    • ipv4 tcp 头占用 20 bytes，ip 头占用 20 bytes，因此以太网 MSS 的值为 1500 - 40 = 1460；
    • TCP 在传递大量数据时，会按照 MSS 大小将数据进行分割发送；
    • MSS 的值在三次握手时通知对方自己 MSS 的值，然后在两者之间选择一个小值作为 MSS；

  • 关于Nagle 算法的补充

    • 即使发送一个字节，也需要加入 tcp 头和 ip 头，也就是总字节数会使用 41 bytes，非常不经济。因此为了提高网络利用率，tcp 希望尽可能发送足够大的数据，这就是 Nagle 算法产生的缘由；
    • 该算法是指发送端即使还有应该发送的数据，但如果这部分数据很少的话，则进行延迟发送；
    • 如果 SO_SNDBUF 的数据达到 MSS，则需要发送
    • 如果 SO_SNDBUF 中含有 FIN（表示需要连接关闭）这时将剩余数据发送，再关闭
    • 如果 TCP_NODELAY = true，则需要发送
    • 已发送的数据都收到 ack 时，则需要发送
    • 上述条件不满足，但发生超时（一般为 200ms）则需要发送
    • 除上述情况之外，会延迟发送

1.4 解决方案

  1. 短链接，即发一个包建立一次连接，这样连接建立到连接断开之间就是消息的边界，缺点就是效率太低；
  2. 每一条消息采用固定长度，缺点浪费空间；
  3. 每一条消息采用分隔符，例如 \n，缺点需要转义；
  4. 每一条消息分为 head 和 body，head 中包含 body 的长度；

方法1：短链接

  • 客户端每次向服务器发送数据以后，就与服务器断开连接，此时的消息边界为连接建立到连接断开；这时便无需使用滑动窗口等技术来缓冲数据，自然也不会发生粘包现象了；但如果一次性发送过多的数据而接收方又无法一次性容纳发送过来的所有数据，还是会发生半包现象，所以短链接无法解决半包现象；

  • 客户端代码更改：修改channelActive方法并将发送步骤封装为send()方法，在这里我们调用10次send()方法模拟10次数据的发送；

    package com.zhyn.nettyadvance;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty
最低0.47元/天 解锁文章
慕小容mango
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Netty 学习和进阶策略
cpongo5
12-25 183
《Netty 进阶之路》、《分布式服务框架原理与实践》作者李林锋手把手教你Netty框架如何学习和进阶。李林锋此后还将在InfoQ上开设Netty专题持续出稿，感兴趣的同学可以持续关注。背景Netty框架的特点Netty的一个特点就是入门相对比较容易，但是真正掌握并精通是非常困难的，原因有如下几个：涉及的知识面比较广：Netty作为一个高性能的NIO通信框架，涉及到的知识点包括网络通信、多线程编程...
netty指南及进阶
anys0039的博客
12-05 92
　　Netty是一个高性能的，提供异步的、事件驱动，非堵塞的IO(NIO)框架，用以快速开发高性能、高可靠性的网络服务器和客户端dsf。用于建立TCP等底层的连接，基于Netty可以建立高性能的Http服务器。 堵塞与非堵塞原理 　　传统硬件的堵塞如下，从内存中读取数据，然后写到磁盘，而CPU一直等到磁盘写完成，磁盘的写操作是慢的，这段时间CPU被堵塞不能发挥效率。 图一、 ...
Netty03-进阶
u011767319的博客
05-10 117
三. Netty 进阶 1. 粘包与半包 1.1 粘包现象 服务端代码 public class HelloWorldServer { static final Logger log = LoggerFactory.getLogger(HelloWorldServer.class); void start() { NioEventLoopGroup boss = new NioEventLoopGroup(1); NioEventLoopGroup worke
《Netty进阶之路 跟着案例学Netty》.rar
11-22
Java进阶技术-netty进阶之路
Netty进阶之路-跟着案例学Netty
05-16
《Netty进阶之路-跟着案例学Netty》是由知名技术专家李林峰撰写的一本专为Java开发者深入理解Netty框架而准备的书籍。这本书旨在通过实例教学，帮助读者全面掌握Netty的核心特性和实战技巧，提升网络编程的能力。 ...
《Netty进阶之路 跟着案例学Netty》_李林锋_
05-30
Netty进阶之路 跟着案例学Netty 整本书无密码，Netty进阶之路 跟着案例学Netty
Netty 进阶篇（待完成）
weixin_43102784的博客
04-17 346
第 1 章 Google Protobuf 1.1 编码和解码的基本介绍 编写网络应用程序时，因为数据在网络中传输的都是二进制字节码数据，在发送数据时就需要编码，接收数据时就需要解码 codec(编解码器) 的组成部分有两个：decoder(解码器)和 encoder(编码器)。encoder 负责把业务数据转换成字节 码数据，decoder 负责把字节码数据转换成业务数据 1.2 Netty 本身的编码解码的机制和问题分析 Netty 自身提供了一些 codec(编解码器) Netty 提
netty的实用进阶
素剑步青尘
11-05 226
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
Netty入门教程——认识Netty
Pannahouse的博客
01-19 7119
Netty 什么是Netty？ Netty 是一个利用 Java 的高级网络的能力，隐藏其背后的复杂性而提供一个易于使用的 API 的客户端/服务器框架。 Netty 是一个广泛使用的 Java 网络编程框架（Netty 在 2011 年获得了Duke’s Choice Award，见https://www.java.net/dukeschoice/2011）。它活跃和成长于用户社区，像大型公司 F
三. Netty 进阶
weixin_46633487的博客
04-30 400
三. Netty 进阶 笔记源于视频:https://www.bilibili.com/video/BV1py4y1E7oA?p=54&spm_id_from=pageDriver 1. 粘包与半包 1.1 粘包现象 服务端代码 public class HelloWorldServer { static final Logger log = LoggerFactory.getLogger(HelloWorldServer.class); void start() {
Netty框架初识
蜗牛的高铁
09-19 132
@[TOC]netty实战 1. 背景 Netty使用有一段时间了，在项目生产环境中也得以实践，最近想回炉温故一下理论，健全自己的知识体系，怕时间长了遗忘，在此做个笔记。 2. 整体认识 2.1 定义 Netty提供异步的、事件驱动的网络应用程序框架和工具，可 以快速开发高性能、高可靠的网络服务器和客户端程序。 异步：我理解为不用等待。 事件驱动：我理解为读或写操作。 2.2 示例 编写一个简单的服务，客户端发送一个英文字符到服务端，服务端立马返回。 netty版本 <dependency>
Netty应用高级篇一
liuzhengqiu0127的专栏
11-04 1026
本篇主要介绍Netty基于HTTP协议的开发应用   一，概念介绍   HTTP协议是建立在TCP传输协议之上的应用层的面向对象的协议。 主要特点如下： 1，支持Client/Server模式； 2，简单。客户端向服务端请求服务时，只需指定服务URL，携带必要的请求参数或者消息体； 3，灵活。HTTP允许传输任意类型的数据对象，传输的内容类型由HTTP消息头中的Content-...
Netty入门-Netty篇
又逢乱世
01-19 1381
Netty 是什么？、 EventLoop、 channel、 ChannelFuture、 sync 和 addListener 区别、 如何正确处理 客户端传输通道 channel 关闭以后的操作?、 优雅的结束进程、 Future & Promise、 jdk Future、 netty Future、 netty Promise、 Handler & Pipeline、 pipeline调试工具 EmbeddedChannel、 ByteBuf 读写操作、 调试 ByteBuf 的工具 log方法、
netty进阶
专栏
07-11 1048
Netty进阶 一、Netty 核心模块组件 (1) Bootstrap、ServerBootstrap Bootstrap 意思是引导，一个 Netty 应用通常由一个 Bootstrap 开始，主要作用是配置整个 Netty 程序，串联各个组件，Netty 中 Bootstrap 类是客户端程序的启动引导类，ServerBootstrap 是服务端启动引导类 常见的方法有 public ServerBootstrap group(EventLoopGroup parentGroup, Eve
互联网码农必备技能，Netty进阶篇，Netty核心组件详解
m0_64821673的博客
04-22 584
前言 上一次文章我们主要讲了一些模型框架，最后引出了Netty的框架结构，Netty 主要基于主从 Reactor多线程模型做了⼀定的改进，主从 Reactor 多线程模型有多个 Reactor，如下图： 今天会带在大家一起学习上述架构中的一些核心组件，废话不多说了，下面我们进入正题。 Bootstrap、ServerBootstrap Bootstrap是引导，⼀个Netty应⽤通常由⼀个Bootstrap开始，主要作⽤是配置Netty程序，采用链式编程模式，串联Netty各个组件。
Netty高级进阶之基于Netty的HTTP服务器开发
远方的灯塔
05-04 1506
本通过实战演练，学习了如何基于Netty开发一个HTTP服务器。 Netty高级进阶之基于Netty的HTTP服务器开发 介绍 Netty的HTTP协议栈可靠性高，性能优异。相对于传统的Tomcat、Jetty等服务器，它更加轻量级和小巧，灵活性和定制型也更好。 功能需求 Netty服务器在8080端口监听 浏览器发出请求”http://localhost:8080“ 服务器回复消息给客户端”你好，我是Netty服务器“，并对特定请求资源进行过滤 服务端代码实现 NettyHttpServer

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值