Netty TCP通讯拆包、粘包处理

tcp是个流协议，所谓流，就是没有界限的一串数据。tcp底层并不了解上层业务的具体含义，它会根据tcp缓冲区的实际情况进行包的划分，所以在业务上认为，一个完整的包可能会被tcp拆分为多个包进行发送，也有可能把多个小的包封装成一个大的数据包发送。这就是所谓的tcp拆包/粘包问题。

拆包：通常是由于发送较大长度数的据超出了自定义长度，或者超出了相关网络传输协议的长度限制，发送的一包数据被拆分为多次发送。

粘包：由于前后包之间的发送间隔过短，造成接收端将多条数据当做同一包数据读取出来。例子如下，

channel.writeAndFlush(sMsg);
channel.writeAndFlush(sMsg);
channel.writeAndFlush(sMsg);

连续多个发送，其实是发送了多个包，对方应该把其看成是多个消息。但是因为发送的过快，对方几乎一定会把其当作一个包来处理。看成是发送了一条消息。这个就发生了粘包。

netty中解决方案：（注意事项请看文章最后）

1）LineBasedFrameDecoder行分割解码

SocketChannel.pipeline().addLast(new LineBasedFrameDecoder(1024);

SocketChannel.pipeline().addLast(new StringDecoder());

LineBaseFrameDecoder的工作原理是它依次遍历ByteBuf中的可读字节，判断看是否有"\n"或者"\r\n"，如果有，就以此位置为结束位置，从可读索引到结束位置区间的字节就组成了一行。它是以换行符为结束标志的解码器，支持携带结束符或者不携带结束符两种解码方式，同时支持配置单行的最大长度。如果连续取到最大长度后仍然没有发现换行符，就会抛出异常，同时忽略掉之前读到的异常码流。

StringDecoder的功能非常简单，就是将接受到的对象转换成字符串，然后继续调用后面的Handler。

LineBasedFrameDecoder+StringDecoder的组合就是按行切换的文本解码器，它被设计用来支持TCP的粘包和拆包。

 

2）DelimiterBasedFrameDecoder自定义分隔符

// 创建分隔符缓冲对象$_作为分割符
ByteBuf byteBuf = Unpooled.copiedBuffer("$_".getBytes());
/**
 * 第一个参数：单条消息的最大长度，当达到最大长度仍然找不到分隔符抛异常，防止由于异常码流缺失分隔符号导致的内存溢出
 * 第二个参数：分隔符缓冲对象
 */
socketChannel.pipeline().addLast(new DelimiterBasedFrameDecoder(1024,byteBuf));
socketChannel.pipeline().addLast(new StringDecoder());

DelimiterBasedFrameDecoder还可以设置对自定义分割付的处理，如下：

ByteBuf delemiter= Unpooled.buffer();
delemiter.writeBytes("$##$".getBytes());//自定义分隔符
socketChannel.pipeline().addLast(new DelimiterBasedFrameDecoder(65535, true, true,delemiter));

//netty实现
DelimiterBasedFrameDecoder(int maxFrameLength, boolean stripDelimiter, boolean failFast,ByteBuf delimiter)

maxLength：
表示一行最大的长度，如果超过这个长度依然没有检测到\n或者\r\n，将会抛出TooLongFrameException

failFast：
与maxLength联合使用，表示超过maxLength后，抛出TooLongFrameException的时机。如果为true，则超出maxLength后立即抛出TooLongFrameException，不继续进行解码；如果为false，则等到完整的消息被解码后，再抛出TooLongFrameException异常。

stripDelimiter：
解码后的消息是否去除分隔符。

delimiters：
分隔符。我们需要先将分割符，写入到ByteBuf中，然后当做参数传入。

需要注意的是，netty并没有提供一个DelimiterBasedFrameDecoder对应的编码器实现(笔者没有找到)，因此在发送端需要自行编码，添加分隔符。

 

3）FixedLengthFrameDecoder定长，即发送接受固定长度的包。感觉不大适合我的业务，暂时不考虑使用。

 

注意事项：

1、编码格式的设置

//字符串编解码器获取环境默认编码格式
pipeline.addLast(
    new StringDecoder(),
    new StringEncoder()
);

 //指定字符串编解码器编码格式为UTF-8
pipeline.addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));
pipeline.addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));

2、自定义分隔符和解码的添加顺序是，先添加自定义解码器，然后再添加StringDecoder，否则分割无效。

//先使用DelimiterBasedFrameDecoder解码，以自定义的字符作为分割符
socketChannel.pipeline().addLast(new DelimiterBasedFrameDecoder(65535, true, true,delemiter));
//解码为UTF-8字符串
socketChannel.pipeline().addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));

 

实际开发代码示例：

以下示例时结合业务需求写的，有些地方不需要，请自行删除，仅供参考。

package com.groot.CPMasterController.netty.tcp.server;

import com.groot.CPMasterController.netty.tcp.entity.TCPConst;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.util.concurrent.Future;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

/**
 * description:
 * author:groot
 * date: 2019-4-10 12:07
 **/
@Component
@PropertySource(value="classpath:config.properties")
@Slf4j
public class TcpServer {

    //boss事件轮询线程组
    //处理Accept连接事件的线程，这里线程数设置为1即可，netty处理链接事件默认为单线程，过度设置反而浪费cpu资源
    private EventLoopGroup boss = new NioEventLoopGroup(1);
    //worker事件轮询线程组
    //处理hadnler的工作线程，其实也就是处理IO读写 。线程数据默认为 CPU 核心数乘以2
    private EventLoopGroup worker = new NioEventLoopGroup();

    @Autowired
    TCPServerChannelInitializer TCPServerChannelInitializer;

    @Value("${netty.tcp.server.port}")
    private Integer port;

    //与客户端建立连接后得到的通道对象
    private Channel channel;

    /**
     * @Author groot
     * @Date 2019/4/13 12:46
     * @Param
     * @return
     * @Description 存储所有client的channel
     **/

//    public static Map clientTotalMap = new ConcurrentHashMap();

    /**
     * @Author groot
     * @Date 2019/4/13 12:46
     * @Param key 链接身份，Value channel队列
     * @return
     * @Description 分类型存储业务所需channel
     **/
    public static Map> clientTypeMap = new ConcurrentHashMap<>();

    /**
     * @Author groot
     * @Date 2019/4/13 12:46
     * @Param []
     * @return io.netty.channel.ChannelFuture
     * @Description 开启Netty tcp server服务
     **/

    public void start() {
        try {
            //启动类
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(boss, worker)//组配置，初始化ServerBootstrap的线程组
                    .channel(NioServerSocketChannel.class)///构造channel通道工厂//bossGroup的通道，只是负责连接
                    .childHandler(TCPServerChannelInitializer)//设置通道处理者ChannelHandler////workerGroup的处理器
                    .option(ChannelOption.SO_BACKLOG, 1024)//socket参数，当服务器请求处理程全满时，用于临时存放已完成三次握手请求的队列的最大长度。如果未设置或所设置的值小于1，Java将使用默认值50。
                    .childOption(ChannelOption.SO_KEEPALIVE, true)//启用心跳保活机制，tcp，默认2小时发一次心跳
                    .childOption(ChannelOption.TCP_NODELAY, true)//2019年4月15日新增 TCP无延迟
                    .handler(new LoggingHandler(LogLevel.INFO));//2019年4月15日新增  日志级别info
            //Future：异步任务的生命周期，可用来获取任务结果
//        ChannelFuture channelFuture1 = serverBootstrap.bind(port).syncUninterruptibly();//绑定端口，开启监听，同步等待
            ChannelFuture channelFuture = serverBootstrap.bind(port).sync();//绑定端口，开启监听，同步等待
            if (channelFuture != null && channelFuture.isSuccess()) {
                channel = channelFuture.channel();//获取通道
                log.info("Netty tcp server start success, port = {}", port);
            } else {
                log.error("Netty tcp server start fail");
            }
            channelFuture.channel().closeFuture().sync();// 监听服务器关闭监听
        } catch (InterruptedException e) {
            log.error("Netty tcp server start Exception e:"+e);
        }finally {
            boss.shutdownGracefully(); //关闭EventLoopGroup，释放掉所有资源包括创建的线程
            worker.shutdownGracefully();
        }

    }

    /**
     * @Author groot
     * @Date 2019/4/13 12:46
     * @Param []
     * @return void
     * @Description 停止Netty tcp server服务
     **/
    @PreDestroy
    public void destroy() {
        if (channel != null) {
            channel.close();
        }
        try {
            Future future = worker.shutdownGracefully().await();
            if (!future.isSuccess()) {
                log.error("netty tcp workerGroup shutdown fail, {}", future.cause());
            }
            Future future1 = boss.shutdownGracefully().await();
            if (!future1.isSuccess()) {
                log.error("netty tcp bossGroup shutdown fail, {}", future1.cause());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("Netty tcp server shutdown success");
    }


    /**
     * @Author groot
     * @Date 2019/5/8 14:34
     * @Param [identity, msg] 链接身份，消息
     * @return void
     * @Description 通过
     **/
    public static void sendMsg(String identity,String msg) {
        send(identity, msg,true);
    }

    /**
     * @Author groot
     * @Date 2019/5/8 14:34
     * @Param [identity, msg] 链接身份，消息
     * @return void
     * @Description 通过
     **/
    public static void sendHeart(String identity,String msg) {
        send(identity, msg,false);
    }


    /**
     * @Author groot
     * @Date 2019/5/17 15:38
     * @Param [identity, msg,endFlag] endFlag是否添加结束符
     * @return void
     * @Description 发送
     **/
    public static void send(String identity, String msg,boolean endFlag) {
        //log.info("sendMsg to:{},msg:{}",identity,msg);
        if(StringUtils.isEmpty(identity) || StringUtils.isEmpty(msg))return;
        StringBuffer sMsg = new StringBuffer(msg);
        if(endFlag){
            sMsg.append(TCPConst.MARK_END);//拼接消息截止符
        }
        Set channels = TcpServer.clientTypeMap.get(identity);
        if(channels!=null && !channels.isEmpty()){//如果有client链接
            //遍历发送消息
            for (Channel channel:channels){
                channel.writeAndFlush(sMsg).syncUninterruptibly();
            }
        }
    }

    // 这个注解表示在spring boot依赖注入完成后执行一次该方法，但对方法有很严格的要求
    @PostConstruct()
    public void init() {
        //需要开启一个新的线程来执行netty server 服务器
        new Thread(new Runnable() {
            public void run() {
                start();
            }
        }).start();

    }

}

 

package com.groot.CPMasterController.netty.tcp.server;

import com.alibaba.fastjson.JSON;
import com.groot.CPMasterController.common.utils.TimeUtil;
import com.groot.CPMasterController.control.service.ipml.GameControlService;
import com.groot.CPMasterController.netty.tcp.entity.TCPConst;
import com.groot.CPMasterController.netty.websocket.WebSocketServer;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.net.SocketAddress;
import java.util.*;

/**
 * description:
 * author:groot
 * date: 2019-4-10 15:49
 **/
@Component
@ChannelHandler.Sharable
@Slf4j
public class TCPServerChannelHandler extends SimpleChannelInboundHandler