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区别，自行百度。
