Netty-LengthFieldBasedFrameDecoder-解决拆包粘包问题的解码器 ...

LengthFieldBasedFrameDecoder 的构造器参数

• maxFrameLength：指定解码器所能处理的数据包的最大长度，超过该长度则抛出 TooLongFrameException 异常；
  
• lengthFieldOffset：指定长度字段的起始位置；
  
• lengthFieldLength：指定长度字段的长度：目前支持1(byte)、2(short)、3(3个byte)、4(int)、8(Long)
  
• lengthAdjustment：指定长度字段所表示的消息长度值与实际长度值之间的差值，可以用于调整解码器的计算和提高灵活性。
  
• initialBytesToStrip：指定解码器在将数据包分离出来后，跳过的字节数，因为这些字节通常不属于消息体内容，而是协议头或其他控制信息。
  

LengthFieldBasedFrameDecoder测试Demo

有关使用方法和方式参考测试Demo即可。

1. package com.netty.framework.core.channel;
3. import io.netty.buffer.ByteBuf;
4. import io.netty.buffer.Unpooled;
5. import io.netty.channel.ChannelHandlerContext;
6. import io.netty.channel.ChannelInboundHandlerAdapter;
7. import io.netty.channel.embedded.EmbeddedChannel;
8. import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
9. import org.junit.Test;
10. import org.slf4j.Logger;
11. import org.slf4j.LoggerFactory;
13. import java.nio.charset.StandardCharsets;
15. /**
16. * @author 左半边是恶魔
17. * @date 2023/7/7
18. * @time 16:10
19. */
20. public class LengthFieldBasedFrameDecoderTest {
21.     private static final Logger LOGGER = LoggerFactory.getLogger(LengthFieldBasedFrameDecoderTest.class);
23.     // 用于输出内容
24.     private final ChannelInboundHandlerAdapter handlerAdapter = new ChannelInboundHandlerAdapter() {
25.         @Override
26.         public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
27.             LOGGER.debug("handlerAdapter-接收到信息：{}", msg);
28.             super.channelRead(ctx, msg);
29.         }
30.     };
32.     /**
33.      * 二进制数据结构
34.      * lengthFieldOffset   = 0
35.      * lengthFieldLength   = 4
36.      * lengthAdjustment    = 0
37.      * initialBytesToStrip = 0 (不跳过长度字段长度信息读取)
38.      * 编码前 (16 bytes)                     编码后 (16 bytes)
39.      * +------------+----------------+      +------------+----------------+
40.      * |   Length   | Actual Content |----->|   Length   | Actual Content |
41.      * | 0x0000000C | "Hello, World" |      | 0x0000000C | "Hello, World" |
42.      * +------------+----------------+      +------------+----------------+
43.      */
44.     @Test
45.     public void test00() {
46.         class LengthFieldDecoder extends LengthFieldBasedFrameDecoder {
47.             public LengthFieldDecoder() {
48.                 super(1024, 0, 4, 0, 0);
49.             }
51.             @Override
52.             protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
53.                 ByteBuf byteBuf = (ByteBuf) super.decode(ctx, in);
54.                 LOGGER.debug("长度读取前readerIndex={}", byteBuf.readerIndex());
56.                 // readInt会更新readerIndex值
57.                 int lengthField = byteBuf.readInt();
58.                 LOGGER.debug("长度字段[LengthField]的值={},即（Hello, World）的二进制长度。", lengthField);
59.                 LOGGER.debug("长度读取后readerIndex={}", byteBuf.readerIndex());
61.                 // toString方法根据readerIndex最新值开始解码
62.                 return byteBuf.toString(StandardCharsets.UTF_8);
63.             }
64.         }
66.         LengthFieldBasedFrameDecoder decoder = new LengthFieldDecoder();
67.         EmbeddedChannel channel = new EmbeddedChannel(decoder, handlerAdapter);
69.         byte[] bytes = "Hello, World".getBytes(StandardCharsets.UTF_8);
70.         ByteBuf byteBuf = Unpooled.buffer();
71.         byteBuf.writeInt(bytes.length);
72.         byteBuf.writeBytes(bytes);
74.         channel.writeInbound(byteBuf);
75.     }
78.     /**
79.      * 二进制数据结构
80.      * lengthFieldOffset   = 0
81.      * lengthFieldLength   = 4
82.      * lengthAdjustment    = 0
83.      * initialBytesToStrip = 4 (跳过长度字段长度信息读取)
84.      * 编码前 (16 bytes)                     编码后 (12 bytes)
85.      * +------------+----------------+      +--------+--------+
86.      * |   Length   | Actual Content |----->|  Actual Content |
87.      * | 0x0000000C | "Hello, World" |      |  "Hello, World" |
88.      * +------------+----------------+      +--------+--------+
89.      */
90.     @Test
91.     public void test01() {
92.         class LengthFieldDecoder extends LengthFieldBasedFrameDecoder {
93.             public LengthFieldDecoder() {
94.                 super(1024, 0, 4, 0, 4);
95.             }
97.             @Override
98.             protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
99.                 ByteBuf byteBuf = (ByteBuf) super.decode(ctx, in);
100.                 return byteBuf.toString(StandardCharsets.UTF_8);
101.             }
102.         }
104.         LengthFieldBasedFrameDecoder decoder = new LengthFieldDecoder();
105.         EmbeddedChannel channel = new EmbeddedChannel(decoder, handlerAdapter);
107.         byte[] bytes = "Hello, World".getBytes(StandardCharsets.UTF_8);
108.         ByteBuf byteBuf = Unpooled.buffer();
109.         byteBuf.writeInt(bytes.length);
110.         byteBuf.writeBytes(bytes);
112.         channel.writeInbound(byteBuf);
113.     }
115.     /**
116.      * 此处lengthField包含了消息头的长度，即：Length = lengthFieldLength + 消息字节长度(Hello, World的二进制长度)
117.      * lengthFieldOffset   =  0
118.      * lengthFieldLength   =  4
119.      * lengthAdjustment    = -4 (lengthField字段的长度)
120.      * initialBytesToStrip =  0
121.      * 编码前 (16 bytes)                     编码后 (16 bytes)
122.      * +------------+----------------+      +------------+----------------+
123.      * |   Length   | Actual Content |----->|   Length   | Actual Content |
124.      * | 0x0000000G | "Hello, World" |      | 0x0000000G | "Hello, World" |
125.      * +------------+----------------+      +------------+----------------+
126.      */
127.     @Test
128.     public void test02() {
129.         class LengthFieldDecoder extends LengthFieldBasedFrameDecoder {
130.             public LengthFieldDecoder() {
131.                 super(1024, 0, 4, -4, 0);
132.             }
134.             @Override
135.             protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
136.                 ByteBuf byteBuf = (ByteBuf) super.decode(ctx, in);
137.                 LOGGER.debug("长度读取前readerIndex={}", byteBuf.readerIndex());
139.                 // readInt会更新readerIndex值
140.                 int lengthField = byteBuf.readInt();
141.                 LOGGER.debug("长度字段[LengthField]的值={},即（Hello, World）的二进制长度。", lengthField);
142.                 LOGGER.debug("长度读取后readerIndex={}", byteBuf.readerIndex());
144.                 // toString方法根据readerIndex最新值开始解码
145.                 return byteBuf.toString(StandardCharsets.UTF_8);
146.             }
147.         }
149.         LengthFieldBasedFrameDecoder decoder = new LengthFieldDecoder();
150.         EmbeddedChannel channel = new EmbeddedChannel(decoder, handlerAdapter);
152.         byte[] bytes = "Hello, World".getBytes(StandardCharsets.UTF_8);
153.         ByteBuf byteBuf = Unpooled.buffer();
154.         // 4=int的字节长度
155.         byteBuf.writeInt(bytes.length + 4);
156.         byteBuf.writeBytes(bytes);
158.         channel.writeInbound(byteBuf);
159.     }
161.     /**
162.      * lengthField在中间位置
163.      * lengthFieldOffset   = 2 (= the length of Header 1)
164.      * lengthFieldLength   = 4
165.      * lengthAdjustment    = 0
166.      * initialBytesToStrip = 0
167.      * <p>
168.      * BEFORE DECODE (18 bytes)                      AFTER DECODE (18 bytes)
169.      * +----------+----------+----------------+      +----------+----------+----------------+
170.      * | Header 1 |  Length  | Actual Content |----->| Header 1 |  Length  | Actual Content |
171.      * |  0xCAFE  | 0x00000C | "Hello, World" |      |  0xCAFE  | 0x00000C | "Hello, World" |
172.      * +----------+----------+----------------+      +----------+----------+----------------+
173.      */
174.     @Test
175.     public void test03() {
176.         class LengthFieldDecoder extends LengthFieldBasedFrameDecoder {
177.             public LengthFieldDecoder() {
178.                 super(1024, 2, 4, 0, 0);
179.             }
181.             @Override
182.             protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
183.                 ByteBuf byteBuf = (ByteBuf) super.decode(ctx, in);
184.                 LOGGER.debug("长度读取前readerIndex={}", byteBuf.readerIndex());
186.                 // 读取header1
187.                 short header1 = byteBuf.readShort();
188.                 LOGGER.debug("header1={}", header1);
190.                 // readInt会更新readerIndex值
191.                 int lengthField = byteBuf.readInt();
192.                 LOGGER.debug("长度字段[LengthField]的值={},即（Hello, World）的二进制长度。", lengthField);
193.                 LOGGER.debug("长度读取后readerIndex={}", byteBuf.readerIndex());
195.                 // toString方法根据readerIndex最新值开始解码
196.                 return byteBuf.toString(StandardCharsets.UTF_8);
197.             }
198.         }
200.         LengthFieldBasedFrameDecoder decoder = new LengthFieldDecoder();
201.         EmbeddedChannel channel = new EmbeddedChannel(decoder, handlerAdapter);
203.         byte[] bytes = "Hello, World".getBytes(StandardCharsets.UTF_8);
204.         ByteBuf byteBuf = Unpooled.buffer();
205.         byteBuf.writeShort(99);
206.         byteBuf.writeInt(bytes.length);
207.         byteBuf.writeBytes(bytes);
209.         channel.writeInbound(byteBuf);
210.     }
212.     /**
213.      * lengthField在开始位置
214.      * lengthFieldOffset   = 0 (= the length of Header 1)
215.      * lengthFieldLength   = 4
216.      * lengthAdjustment    = 2
217.      * initialBytesToStrip = 0
218.      * BEFORE DECODE (18 bytes)                      AFTER DECODE (18 bytes)
219.      * +----------+----------+----------------+      +----------+----------+----------------+
220.      * |  Length  | Header 1 | Actual Content |----->|  Length  | Header 1 | Actual Content |
221.      * | 0x00000C |  0xCAFE  | "Hello, World" |      | 0x00000C |  0xCAFE  | "Hello, World" |
222.      * +----------+----------+----------------+      +----------+----------+----------------+
223.      */
224.     @Test
225.     public void test04() {
226.         class LengthFieldDecoder extends LengthFieldBasedFrameDecoder {
227.             public LengthFieldDecoder() {
228.                 super(1024, 0, 4, 2, 0);
229.             }
231.             @Override
232.             protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
233.                 ByteBuf byteBuf = (ByteBuf) super.decode(ctx, in);
234.                 LOGGER.debug("长度读取前readerIndex={}", byteBuf.readerIndex());
236.                 // readInt会更新readerIndex值
237.                 int lengthField = byteBuf.readInt();
238.                 LOGGER.debug("长度字段[LengthField]的值={},即（Hello, World）的二进制长度。", lengthField);
239.                 LOGGER.debug("长度读取后readerIndex={}", byteBuf.readerIndex());
241.                 // 读取header1
242.                 short header1 = byteBuf.readShort();
243.                 LOGGER.debug("header1={}", header1);
245.                 // toString方法根据readerIndex最新值开始解码
246.                 return byteBuf.toString(StandardCharsets.UTF_8);
247.             }
248.         }
250.         LengthFieldBasedFrameDecoder decoder = new LengthFieldDecoder();
251.         EmbeddedChannel channel = new EmbeddedChannel(decoder, handlerAdapter);
253.         byte[] bytes = "Hello, World".getBytes(StandardCharsets.UTF_8);
254.         ByteBuf byteBuf = Unpooled.buffer();
255.         byteBuf.writeInt(bytes.length);
256.         byteBuf.writeShort(99);
257.         byteBuf.writeBytes(bytes);
259.         channel.writeInbound(byteBuf);
260.     }
262.     /**
263.      * lengthFieldOffset   = 1 (= the length of HDR1)
264.      * lengthFieldLength   = 4
265.      * lengthAdjustment    = 1 (= the length of HDR2)
266.      * initialBytesToStrip = 5 (= the length of HDR1 + LEN)
267.      * BEFORE DECODE (18 bytes)                       AFTER DECODE (13 bytes)
268.      * +------+--------+------+----------------+      +------+----------------+
269.      * | HDR1 | Length | HDR2 | Actual Content |----->| HDR2 | Actual Content |
270.      * | 0xCA | 0x000C | 0xFE | "Hello, World" |      | 0xFE | "Hello, World" |
271.      * +------+--------+------+----------------+      +------+----------------+
272.      */
273.     @Test
274.     public void test05() {
275.         class LengthFieldDecoder extends LengthFieldBasedFrameDecoder {
276.             public LengthFieldDecoder() {
277.                 super(1024, 1, 4, 1, 5);
278.             }
280.             @Override
281.             protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
282.                 ByteBuf byteBuf = (ByteBuf) super.decode(ctx, in);
283.                 LOGGER.debug("长度读取前readerIndex={}", byteBuf.readerIndex());
285.                 // 读取header2
286.                 short header2 = byteBuf.readByte();
287.                 LOGGER.debug("header2={}", header2);
289.                 // toString方法根据readerIndex最新值开始解码
290.                 return byteBuf.toString(StandardCharsets.UTF_8);
291.             }
292.         }
294.         LengthFieldBasedFrameDecoder decoder = new LengthFieldDecoder();
295.         EmbeddedChannel channel = new EmbeddedChannel(decoder, handlerAdapter);
297.         byte[] bytes = "Hello, World".getBytes(StandardCharsets.UTF_8);
298.         ByteBuf byteBuf = Unpooled.buffer();
299.         byteBuf.writeByte(1);
300.         byteBuf.writeInt(bytes.length);
301.         byteBuf.writeByte(9);
302.         byteBuf.writeBytes(bytes);
304.         channel.writeInbound(byteBuf);
305.     }
308.     /**
309.      * lengthFieldOffset   =  1
310.      * lengthFieldLength   =  4 (整个消息的长度 = HDR1 + Length + HDR2 + Centent)
311.      * lengthAdjustment    = -5 (HDR1 + LEN的负值)
312.      * initialBytesToStrip =  5
313.      * BEFORE DECODE (18 bytes)                       AFTER DECODE (13 bytes)
314.      * +------+--------+------+----------------+      +------+----------------+
315.      * | HDR1 | Length | HDR2 | Actual Content |----->| HDR2 | Actual Content |
316.      * | 0xCA | 0x0010 | 0xFE | "Hello, World" |      | 0xFE | "Hello, World" |
317.      * +------+--------+------+----------------+      +------+----------------+
318.      */
319.     @Test
320.     public void test06() {
321.         class LengthFieldDecoder extends LengthFieldBasedFrameDecoder {
322.             public LengthFieldDecoder() {
323.                 super(1024, 1, 4, -5, 5);
324.             }
326.             @Override
327.             protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
328.                 ByteBuf byteBuf = (ByteBuf) super.decode(ctx, in);
329.                 LOGGER.debug("长度读取前readerIndex={}", byteBuf.readerIndex());
331.                 // 读取header2
332.                 short header2 = byteBuf.readByte();
333.                 LOGGER.debug("header2={}", header2);
335.                 // toString方法根据readerIndex最新值开始解码
336.                 return byteBuf.toString(StandardCharsets.UTF_8);
337.             }
338.         }
340.         LengthFieldBasedFrameDecoder decoder = new LengthFieldDecoder();
341.         EmbeddedChannel channel = new EmbeddedChannel(decoder, handlerAdapter);
343.         byte[] bytes = "Hello, World".getBytes(StandardCharsets.UTF_8);
344.         ByteBuf byteBuf = Unpooled.buffer();
345.         byteBuf.writeByte(1);
346.         byteBuf.writeInt(bytes.length + 6);
347.         byteBuf.writeByte(2);
348.         byteBuf.writeBytes(bytes);
350.         channel.writeInbound(byteBuf);
351.     }
352. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！