实战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