實戰netty解決根據硬件廠商提供的手冊，完成數據的拆分接收並存庫（包含粘包、拆包解決方案）

Springboot+netty整合解決硬件廠商提供的手冊，完成數據拆分並存庫

在平時工作中，難免會有硬軟件交互的需求，比如人臉識別、RFID射頻接收等等，此時提供這些設備的廠家會給你提供一份文檔，裏面規定了數據包的一些長度以及規則，此時就需要你根據文檔來解析從硬件傳輸過來的數據，進行一些業務處理。

1、首先了解什麼是netty?

Netty是由JBOSS提供的一個java開源框架，現爲 Github上的獨立項目。Netty提供異步的、事件驅動的網絡應用程序框架和工具，用以快速開發高性能、高可靠性的網絡服務器和客戶端程序。

也就是說，Netty 是一個基於NIO的客戶、服務器端的編程框架，使用Netty 可以確保你快速和簡單的開發出一個網絡應用，例如實現了某種協議的客戶、服務端應用。Netty相當於簡化和流線化了網絡應用的編程開發過程，例如：基於TCP和UDP的socket服務開發。

“快速”和“簡單”並不用產生維護性或性能上的問題。Netty 是一個吸收了多種協議（包括FTP、SMTP、HTTP等各種二進制文本協議）的實現經驗，並經過相當精心設計的項目。最終，Netty 成功的找到了一種方式，在保證易於開發的同時還保證了其應用的性能，穩定性和伸縮性。 

2、什麼是TCP粘包、拆包

假設客戶端分別發送了兩個數據包，D1和D2給服務端，由於服務端一次讀取到的字節數是不確定的，故可能存在以下情況：

• 服務端分別收到了D1和D2，沒有粘包和拆包
• 服務端一次性收到了D1和D2，稱爲TCP粘包
• 服務端兩次讀取到了兩個數據包，第一次讀到了D1的完整部分和D2的部分數據，第二次讀到了D2的剩餘部分。 這稱爲TCP拆包

服務端兩次讀取到兩個數據包，第一次是D1的部分，第二次是D1的剩餘部分和D2的完整部分

3、拆包、粘包原因

• 應用程序寫入的數據大於套接字緩衝區大小，這將會發生拆包。
• 應用程序寫入數據小於套接字緩衝區大小，網卡將應用多次寫入的數據發送到網絡上，這將會發生粘包。
• 進行mss（最大報文長度）大小的TCP分段，當TCP報文長度-TCP頭部長度>mss的時候將發生拆包。
• 接收方法不及時讀取套接字緩衝區數據，這將發生粘包。

接下來我們需要做的就是根據廠家提供的文檔，對發過來的數據進行接收，拆分，重組包，拿到一份完整的包。下圖是廠家提供的協議：

接下來對此圖進行分析，以此命令爲例：

                      46 4d 53   |          00 0e           |      FF FF    |   82 00 07 a1 10 e0 a1  |   23 a5      客戶端發過來總共有16Byte

                     起始標誌    |  本文件數據長度  | 讀卡器ID號  |    子文件。。。             |  校驗碼

圖中可以看出，該包的大概結構如下，該包由 起始標誌（3B），本文件數據長度(2B)，讀卡器ID號(2B)。。。子文件。。。校驗碼(2B)組成，由上命令可得知，客戶端不管發多少字節，我們知道16個字節是一整包（因爲TCP提供可靠的服務，也就是說，通過TCP連接傳輸的數據不會丟失，沒有重複，並且按順序到達，所以不用擔心數據會亂），Netty有自帶的封裝好的解碼類，也可以自己根據業務自定義解碼類，粘包，拆包的問題就這麼解決了，如果客戶端發送過來的數據大於16字節（粘包），程序會根據規定的長度，進行拆分，合成一個新包後，計數器清零，繼續等待，一直等到下次的包數據進來進行重組，反之拆包同理。B 代表的是 Byte。接下來，我們對接收到的一個整包進行處理，從圖中可以看出，本文件數據長度規定了包的總長度（不包括倆字節的校驗碼），以該命令爲例就是，

   包長=16-校驗碼（2B）=14B。

而我們需要拿到若干子文件的數據，所以需要包長減去固定的字節，找出若干子文件的長度，再根據文檔告知的子文件的數據結構進行拆分，取數據。

  若干子文件 = 14 - 起始標誌（3B）-本文件數據長度（2B）- 讀卡器ID號（2B）=7B。

同理，若干子文件又根據圖中提供的子文件命令的數據結構進行拆分。以下爲我測試代碼的結果（使用工具代替客戶端發送報文）：

1、正常收發包：

2、粘包

3、拆包

等待中。。。

此處進行存庫等業務操作：

服務端代碼：

package com.fre.nettyserversemo.res;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
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 org.springframework.stereotype.Component;

@Component
public class FreServer {
    public void run(int port) throws Exception{
        //配置服務端的NIO線程組
        //此處new了倆個NioEventLoopGroup，NioEventLoopGroup包含了一組NIO線程，專門用於網絡事件的處理，
        //實際上他們就是Reactor線程組，
        //這裏創建倆個的原因是一個用於服務端接受客戶端的連接，另一個用於進行SocketChannel的網絡讀寫
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup(256);
        try {
            //Netty用於啓動NIO服務端的輔助啓動類，目的是降低服務端的開發複雜度
            ServerBootstrap b = new ServerBootstrap();
            //將倆個線程組當做 參數傳遞到ServerBootstrap中
            b.group(bossGroup, workerGroup)
                    //接着設置創建的channel爲NioServerSocketChannel
                    .channel(NioServerSocketChannel.class)
                    //碼流日誌打印
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) {
                            //日誌
                            ch.pipeline().addLast("LoggingHandler", new LoggingHandler(LogLevel.INFO));
                            //自定義解碼器
                            ch.pipeline().addLast("FreDecoder", new FreDecoder());
                            //將讀出的返回至定義的對象
                            ch.pipeline().addLast("CommandHandler", new CommandHandler());
                        }
                    });
            //服務啓動輔助類配置完成之後，調用它的bind方法綁定監聽端口，隨後調用它的同步阻塞方法sync等待綁定完成
            //完成之後，netty會返回一個ChannelFuture，主要用於異步操作的通知回調
            ChannelFuture f = b.bind(port).sync();
            //使用該方法進行阻塞，等待服務端鏈路關閉後main函數才退出
            f.channel().closeFuture().sync();
        } finally {
            //調用NIO線程組的shutdownGracefully進行優雅退出，它會釋放跟相關聯的資源，釋放線程池資源
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }

    }
}

自定義解碼器文件：

package com.fre.nettyserversemo.res;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ReplayingDecoder;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

import static com.fre.nettyserversemo.res.FreDecoderState.*;

/**
 * 核心解碼文件
 */

@Slf4j
@Component
public class FreDecoder extends ReplayingDecoder<FreDecoderState> {

    public FreDecoder() {
        super(FreDecoderState.READ_FLAG);
    }

    final static int BEGIN_FLAG_LENGTH = 3;
    final static int FLEX_HEAD_LENGTH = 7;
    final static int FLEX_SUB_HEAD_LENGTH = 3;
    final static int END_FLAG_LENGTH = 2;

    private String flag;
    private int length = 0;
    private int cardNo = 0;
    private ByteBuf dataBuf = Unpooled.directBuffer(512);

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
        switch (state()) {
            case READ_FLAG:
                flag = in.readCharSequence(BEGIN_FLAG_LENGTH, Charset.forName("UTF-8")).toString();
                checkpoint(READ_LENGTH);
                break;

            case READ_LENGTH:
                length = in.readUnsignedShort();
                checkpoint(READ_CARDNO);
                break;

            case READ_CARDNO:
                cardNo = in.readUnsignedShort();
                checkpoint(READ_CONTENT);
                break;

            case READ_CONTENT:
                byte[] tempBytes = new byte[length - FLEX_HEAD_LENGTH];
                in.readBytes(tempBytes);
                dataBuf.clear();
                dataBuf.writeBytes(tempBytes);

                checkpoint(READ_END);
                break;


            case READ_END:
                byte[] endFlag = new byte[END_FLAG_LENGTH];
                in.readBytes(endFlag);
                checkpoint(READ_FLAG);

                List<SubCommand> subCommands = new ArrayList<>();
                while (dataBuf.isReadable()) {
                    SubCommand subCommand = new SubCommand();
                    //讀取子文件類型
                    short type = dataBuf.readUnsignedByte();
                    //讀取子文件長度
                    int length = dataBuf.readUnsignedShort();
                    //減去文件頭部3字節
                    int dataLength = length - FLEX_SUB_HEAD_LENGTH;

                    //讀取子文件數據
                    byte[] data = new byte[dataLength];
                    dataBuf.readBytes(data);

                    subCommand.setType(type);
                    subCommand.setLength(length);
                    subCommand.setData(data);
                    subCommands.add(subCommand);
                }

                //封裝一個完整的消息
                Command command = new Command(flag, length, cardNo, subCommands, endFlag);
                out.add(command);

                this.clearResource();
                break;
            default:
                ctx.channel().close();
                throw new Error("Shouldn't reach here.");
        }
    }

    private void clearResource() {
        this.flag = null;
        this.length = 0;
        this.cardNo = 0;
        this.dataBuf.clear();
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        this.clearResource();
        super.channelInactive(ctx);
    }
}

Springboot整合netty:

1、pom文件引入netty包：

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

2、啓動類注入服務端server，並實現CommandLineRunner接口，複寫其方法：

import com.fre.nettyserversemo.res.FreServer;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import javax.annotation.Resource;

@SpringBootApplication
public class NettyserversemoApplication implements CommandLineRunner {
	@Resource
	private FreServer freServer;
	public static void main(String[] args) {
		SpringApplication.run(NettyserversemoApplication.class, args);
	}

	@Override
	public void run(String... args) throws Exception {
		freServer.run(7788);
	}
}

注：注入使用@Resource,具體跟@autowride區別，自行百度。

 

此處只提供思路，源碼請跳鏈接：

https://download.csdn.net/download/weixin_38545056/12269041