永远少年1024

netty基本用法，拆包、粘包等常见解决方案，看本文即可，不做原理说明，只进行实战操作

netty的基本用法

完整的介绍了netty最基本的发送byte、string、byteBuf发送接收数据，以及拆包、粘包演示，拆包、粘包的解决方案。看netty的用法只看本篇足以，本篇只说用法，不讲底层原理。

详细demo的git地址

示例的通用代码

客户端

客户端

package com.example.netty.common.client;

import cn.hutool.core.util.ObjectUtil;
import com.example.netty.common.NettyThreadFactory;
import com.example.netty.common.utils.NettyConstants;
import com.example.netty.delimiter.client.DelimiterClientInitializer;
import com.example.netty.fixlength.client.FixLengthClientInitializer;
import com.example.netty.lengthfield.client.LengthFieldClientInitializer;
import com.example.netty.linebase.client.LineBaseClientInitializer;
import com.example.netty.nbcb.client.NormalNBCBClientInitializer;
import com.example.netty.normal.bytebuf.client.NormalByteBufClientInitializer;
import com.example.netty.normal.bytes.client.NormalByteClientInitializer;
import com.example.netty.normal.string.client.NormalStringClientInitializer;
import io.netty.bootstrap.Bootstrap;
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.NioSocketChannel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 15:39
 **/
@Component
public class NettyClient {

    private static final Logger logger = LoggerFactory.getLogger(NettyClient.class);
    private final EventLoopGroup group = new NioEventLoopGroup(new NettyThreadFactory("client"));
    private final Bootstrap bootstrap = new Bootstrap();
    private ChannelFuture channelFuture;

    @Async
    public void init(String type) {
        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .option(ChannelOption.TCP_NODELAY, true)
                .option(ChannelOption.SO_KEEPALIVE, true);

        if (NettyConstants.NORMAL_BYTE_BUF.equalsIgnoreCase(type)) {
            logger.debug("+++++++初始化normal byte buf client ChannelInitializer ++++++++++++");
            bootstrap.handler(new NormalByteBufClientInitializer());
        } else if (NettyConstants.NORMAL_BYTE.equalsIgnoreCase(type)) {
            logger.debug("+++++++初始化normal byte client ChannelInitializer ++++++++++++");
            bootstrap.handler(new NormalByteClientInitializer());
        } else if (NettyConstants.NORMAL_STRING.equalsIgnoreCase(type)) {
            logger.debug("+++++++初始化normal string client ChannelInitializer ++++++++++++");
            bootstrap.handler(new NormalStringClientInitializer());
        }else if (NettyConstants.NBCB.equalsIgnoreCase(type)) {
            logger.debug("+++++++初始化粘包、拆包 client ChannelInitializer ++++++++++++");
            bootstrap.handler(new NormalNBCBClientInitializer());
        }else if (NettyConstants.FIX_LENGTH.equalsIgnoreCase(type)) {
            logger.debug("+++++++初始化粘包、拆包 固定长度解决方案 client ChannelInitializer ++++++++++++");
            bootstrap.handler(new FixLengthClientInitializer());
        }else if (NettyConstants.LINE_BASE.equalsIgnoreCase(type)) {
            logger.debug("+++++++初始化粘包、拆包 通过在包尾添加回车换行符 \\r\\n 来区分整包消息解决方案 client ChannelInitializer ++++++++++++");
            bootstrap.handler(new LineBaseClientInitializer());
        }else if (NettyConstants.DELIMITER.equalsIgnoreCase(type)) {
            logger.debug("+++++++初始化粘包、拆包 特殊字符作为分隔符来区分整包消息解决方案 client ChannelInitializer ++++++++++++");
            bootstrap.handler(new DelimiterClientInitializer());
        }else if (NettyConstants.LENGTH_FIELD.equalsIgnoreCase(type)) {
            logger.debug("+++++++初始化粘包、拆包 指定长度来标识整包消息，通过在包头指定整包长度来约定包长。解决方案 client ChannelInitializer ++++++++++++");
            bootstrap.handler(new LengthFieldClientInitializer());
        }

    }


    public ChannelFuture connect(String host, int port) {
        doConnect(host, port);
        return this.channelFuture;
    }

    public void doConnect(String host, Integer port) {
        if (ObjectUtil.isEmpty(host) || ObjectUtil.isEmpty(port)) {
            throw new RuntimeException("IP host 为null");
        }
        try {
            ChannelFuture future = bootstrap.connect(host, port);
            //休眠1秒，保证通道建立成功
            Thread.sleep(100);
            channelFuture = future;
            logger.info("ChannelFuture 创建状态{}", channelFuture.isSuccess());
        } catch (Exception e) {
            logger.error("client start fail", e);
        }
    }

    public void disconnect(Channel channel) {
        if (ObjectUtil.isNotNull(channel)) {
            try {
                ChannelFuture channelFuture = channel.close();
                channel.disconnect();
            } catch (Exception e) {
                logger.error("关闭通道异常", e);
            }
        }
    }
}

客户端心跳监听

package com.example.netty.common.client;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:23
 **/
public class ClientHeartBeatServerHandler extends ChannelInboundHandlerAdapter {
    private static final Logger logger = LoggerFactory.getLogger(ClientHeartBeatServerHandler.class);

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent) evt;
            if (event.state().equals(IdleState.ALL_IDLE)) {
                logger.info("长时间没有进行过读写操作,发送查询状态的心跳");
                // 15 分钟没有进行读操作，给服务端发送心跳包
//                ctx.channel().writeAndFlush(BACK_FLOW_ORDER_QUERY_STATUS);
            } else if (event.state().equals(IdleState.READER_IDLE)) {
                logger.info("长时间没有进行过读操作");
            } else if (event.state().equals(IdleState.WRITER_IDLE)) {
                logger.info("长时间没有进行过写操作");
            }
        }
    }
}

服务端

package com.example.netty.common.server;

import com.example.netty.common.NettyThreadFactory;
import com.example.netty.common.utils.NettyConstants;
import com.example.netty.delimiter.server.DelimiterServerInitializer;
import com.example.netty.fixlength.server.FixLengthServerInitializer;
import com.example.netty.lengthfield.client.LengthFieldClientInitializer;
import com.example.netty.lengthfield.server.LengthFieldServerInitializer;
import com.example.netty.linebase.server.LineBaseServerInitializer;
import com.example.netty.nbcb.server.NormalNBCBServerInitializer;
import com.example.netty.normal.bytebuf.server.NormalByteBufServerInitializer;
import com.example.netty.normal.bytes.server.NormalByteServerInitializer;
import com.example.netty.normal.string.server.NormalStringServerInitializer;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.UnpooledByteBufAllocator;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.epoll.Epoll;
import io.netty.channel.epoll.EpollEventLoopGroup;
import io.netty.channel.epoll.EpollServerSocketChannel;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

/**
 * 启动主类
 *
 * @author xin
 * @version Created by xin on 2021/4/30 10:35 上午
 */
@Component
public class NettyServer {

    private static final Logger logger = LoggerFactory.getLogger(NettyServer.class);

    EventLoopGroup boss = null;
    EventLoopGroup worker = null;
    ChannelFuture channelFuture = null;

    @Async
    public void init(String host, int port, String type) {
        // 负责初始化netty服务器，并且开始监听端口的socket请求。
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        // 做是否支持epoll轮询判断以获取更高性能 任务调度框架
        // boss 端口监听线程组
        boss = Epoll.isAvailable() ? new EpollEventLoopGroup(2,
                new NettyThreadFactory("boss")) : new NioEventLoopGroup(2, new NettyThreadFactory("boss"));
        // worker 消息处理线程组
        worker = Epoll.isAvailable() ? new EpollEventLoopGroup(2,
                new NettyThreadFactory("worker")) : new NioEventLoopGroup(2, new NettyThreadFactory("worker"));

        serverBootstrap.group(boss, worker)
                .channel(Epoll.isAvailable() ? EpollServerSocketChannel.class : NioServerSocketChannel.class)
                .localAddress(host, port)
                // option 是针对于 boss 线程组
                // 连接保活，默认值为False。启用该功能时，TCP会主动探测空闲连接的有效性。可以将此功能视为TCP的心跳机制，需要注意的是：默认的心跳间隔是7200s即2小时。Netty默认关闭该功能。
                .option(ChannelOption.SO_KEEPALIVE, true)
                // 开启Nagle算法，（尽可能的发送大块数据避免网络中充斥着大量的小数据块）
                .option(ChannelOption.TCP_NODELAY, true)
                // ByteBuf 分配器
                .option(ChannelOption.ALLOCATOR, UnpooledByteBufAllocator.DEFAULT)
                .option(ChannelOption.ALLOCATOR, UnpooledByteBufAllocator.DEFAULT)
                .option(ChannelOption.SO_REUSEADDR, true);

        // 此处是为了演示用的，初始化不同的 childHandler
        if (NettyConstants.NORMAL_BYTE_BUF.equalsIgnoreCase(type)) {
            logger.debug("+++++++初始化normal byte buf server ChannelInitializer ++++++++++++");
            serverBootstrap.childHandler(new NormalByteBufServerInitializer());
        } else if (NettyConstants.NORMAL_BYTE.equalsIgnoreCase(type)) {
            logger.debug("+++++++初始化normal byte server ChannelInitializer ++++++++++++");
            serverBootstrap.childHandler(new NormalByteServerInitializer());
        } else if (NettyConstants.NORMAL_STRING.equalsIgnoreCase(type)) {
            logger.debug("+++++++初始化normal string server ChannelInitializer ++++++++++++");
            serverBootstrap.childHandler(new NormalStringServerInitializer());
        } else if (NettyConstants.NBCB.equalsIgnoreCase(type)) {
            logger.debug("+++++++初始化 粘包、拆包 server ChannelInitializer ++++++++++++");
            serverBootstrap.childHandler(new NormalNBCBServerInitializer());
        } else if (NettyConstants.FIX_LENGTH.equalsIgnoreCase(type)) {
            logger.debug("+++++++初始化 粘包、拆包 固定长度解决方案 server ChannelInitializer ++++++++++++");
            serverBootstrap.childHandler(new FixLengthServerInitializer());
        } else if (NettyConstants.LINE_BASE.equalsIgnoreCase(type)) {
            logger.debug("+++++++初始化 粘包、拆包 通过在包尾添加回车换行符 \\r\\n 来区分整包消息解决方案 server ChannelInitializer ++++++++++++");
            serverBootstrap.childHandler(new LineBaseServerInitializer());
        } else if (NettyConstants.DELIMITER.equalsIgnoreCase(type)) {
            logger.debug("+++++++初始化 粘包、拆包 特殊字符作为分隔符来区分整包消息解决方案 server ChannelInitializer ++++++++++++");
            serverBootstrap.childHandler(new DelimiterServerInitializer());
        }else if (NettyConstants.LENGTH_FIELD.equalsIgnoreCase(type)) {
            logger.debug("+++++++初始化粘包、拆包 指定长度来标识整包消息，通过在包头指定整包长度来约定包长。解决方案 client ChannelInitializer ++++++++++++");
            serverBootstrap.childHandler(new LengthFieldServerInitializer());
        }

        // childOption 是针对于 worker线程组
        // 连接保活，默认值为False。启用该功能时，TCP会主动探测空闲连接的有效性。可以将此功能视为TCP的心跳机制，需要注意的是：默认的心跳间隔是7200s即2小时。Netty默认关闭该功能。
        serverBootstrap.childOption(ChannelOption.SO_KEEPALIVE, true)
                // 开启Nagle算法，（尽可能的发送大块数据避免网络中充斥着大量的小数据块）
                // TCP参数，立即发送数据，默认值为Ture（Netty默认为True而操作系统默认为False）。该值设置Nagle算法的启用，改算法将小的碎片数据连接成更大的报文来最小化所发送的报文的数量，如果需要发送一些较小的报文，则需要禁用该算法。Netty默认禁用该算法，从而最小化报文传输延时
                .childOption(ChannelOption.TCP_NODELAY, true)
                // ByteBuf 分配器
                .childOption(ChannelOption.ALLOCATOR, UnpooledByteBufAllocator.DEFAULT)
                .childOption(ChannelOption.ALLOCATOR, UnpooledByteBufAllocator.DEFAULT)
                .childOption(ChannelOption.SO_REUSEADDR, true);

        // 负责绑定端口，当这个方法执行后，ServerBootstrap就可以接受指定端口上的socket连接了。一个ServerBootstrap可以绑定多个端口。
        try {
            channelFuture = serverBootstrap.bind().sync();
            logger.info("Netty 服务启动成功，端口：{}", channelFuture.channel().localAddress());
        } catch (Exception e) {
            logger.error("启动 Netty 服务时发生异常", e);
        }

        // 监听Channel关闭事件
        ChannelFuture closeFuture = channelFuture.channel().closeFuture();
        try {
            closeFuture.sync();
        } catch (InterruptedException e) {
            logger.error("关闭 Channel 发生异常", e);
        } finally {
            // 关闭线程组
            worker.shutdownGracefully();
            boss.shutdownGracefully();
        }
    }
}

服务端心跳

package com.example.netty.common.server;

import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.net.SocketAddress;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:23
 **/
public class ServerHeartBeatServerHandler extends ChannelInboundHandlerAdapter {
    private static final Logger logger = LoggerFactory.getLogger(ServerHeartBeatServerHandler.class);
    private static final int MIN_LOSS_CONNECT_COUNT = 12;
    private int lossConnectCount = 0;

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        logger.debug("已经5秒未收到客户端的消息了！");
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent) evt;
            if (event.state() == IdleState.READER_IDLE) {
                lossConnectCount++;
                if (lossConnectCount > MIN_LOSS_CONNECT_COUNT) {
                    logger.debug("这个不活跃通道！");
                    // 如果有需要可以关闭不活跃的通道
                    final SocketAddress socketAddress = ctx.channel().remoteAddress();
                    ctx.channel().close().addListener((ChannelFutureListener) future -> {
                        if (future.isSuccess()) {
                            logger.info("close idle connect:" + socketAddress + " for " + event.state() + " done");
                        } else {
                            logger.info("close idle connect:" + socketAddress + " for " + event.state() + " fail");
                        }
                    });
                }
            }
        } else {
            super.userEventTriggered(ctx, evt);
        }
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        lossConnectCount = 0;
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }
}

连接监听

package com.example.netty.common.server;

import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:21
 **/
@ChannelHandler.Sharable
public class ConnectionCountHandler extends ChannelInboundHandlerAdapter {

    private static final Logger logger = LoggerFactory.getLogger(ConnectionCountHandler.class);

    /**
     * 每次过来一个新连接就对连接数加一
     *
     * @param ctx ChannelHandlerContext
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        logger.debug("有新的链接加入：{}", ctx.channel().id().asLongText());
        super.channelActive(ctx);
    }

    /**
     * 断开的时候减一
     *
     * @param ctx ChannelHandlerContext
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        logger.debug("有连接断开：{}", ctx.channel().id().asLongText());
        super.channelInactive(ctx);
    }
}

测试

package com.example.netty.controller;

import cn.hutool.core.util.ByteUtil;
import com.example.netty.common.client.NettyClient;
import com.example.netty.common.utils.ByteUtils;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.List;

/**
 * 
 *
 * @author xin
 * @version 2023/11/1 17:02
 **/
@RestController
public class TestClientController {
    private static final Logger logger = LoggerFactory.getLogger(TestClientController.class);
    private final NettyClient nettyClient;

    public TestClientController(NettyClient nettyClient) {
        this.nettyClient = nettyClient;
    }

    public static void main(String[] args) {
        System.out.println("ABCDE一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;".getBytes(StandardCharsets.UTF_8).length);
    }

    @GetMapping("/app/netty/normal/byteBuf")
    public String testNormalByteBuf() throws InterruptedException {
        logger.debug("发送正常情况下的 normal byte buf 模式");
        ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
        for (int i = 0; i < 10; i++) {
            String msg = "一岁一枯荣,野火烧不尽;";
            ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer();
            buffer.writeBytes(msg.getBytes(StandardCharsets.UTF_8));
            // 此处采用byte模式
            channelFuture.channel().writeAndFlush(buffer);
            Thread.sleep(1000);
        }
        nettyClient.disconnect(channelFuture.channel());
        return "normal byte buf 发送成功";
    }

    @GetMapping("/app/netty/normal/byte")
    public String testNormalByte() throws InterruptedException {
        logger.debug("发送正常情况下的 normal byte 模式");
        ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
        for (int i = 0; i < 10; i++) {
            String msg = "一岁一枯荣,野火烧不尽;";
            channelFuture.channel().writeAndFlush(msg.getBytes(StandardCharsets.UTF_8));
            Thread.sleep(1000);
        }
        nettyClient.disconnect(channelFuture.channel());
        return "normal byte 发送成功";
    }

    @GetMapping("/app/netty/normal/string")
    public String testNormalString() throws InterruptedException {
        logger.debug("发送正常情况下的  string 模式");
        ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
        for (int i = 0; i < 10; i++) {
            String msg = "一岁一枯荣,野火烧不尽;";
            channelFuture.channel().writeAndFlush(msg);
            Thread.sleep(1000);
        }
        nettyClient.disconnect(channelFuture.channel());
        return "string 发送成功";
    }

    @GetMapping("/app/netty/normal/nbcb")
    public String testNb() throws InterruptedException {
        logger.debug("验证粘包、拆包现象，客户端给服务端发送产生拆包、服务端给客户端发送产生 粘包");
        ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
        StringBuilder msg = new StringBuilder("一岁一枯荣,野火烧不尽;");
        for (int i = 0; i < 10; i++) {
            msg.append(msg);
        }
        msg.append("end");
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer();
        buffer.writeBytes(msg.toString().getBytes(StandardCharsets.UTF_8));
        channelFuture.channel().writeAndFlush(buffer);
        Thread.sleep(1000);
        nettyClient.disconnect(channelFuture.channel());
        return "string 发送成功";
    }

    @GetMapping("/app/netty/fixLength")
    public String testFixLength() throws InterruptedException {
        ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
        // 此处是字节长度为 64,如果不够  64 则本次发送的消息收不到会暂存到缓存中，等凑够 64 才会监听到消息
        // 固定长度，如果长度不够且需要收到消息，通过补空格实现
        // 固定长度，如果 超过 64则只会 收 64 长度的数据，剩余的不够64 的暂存到缓存中，等凑够64 才会监听到消息
        // 建议 发送的消息为 设置长度 64 的倍数，否则会将字节截断产生乱码

        String s = "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;";
        channelFuture.channel().writeAndFlush(s);
        Thread.sleep(1000);
        nettyClient.disconnect(channelFuture.channel());
        return "发送成功";
    }

    @GetMapping("/app/netty/lineBase")
    public String testLineBase() throws InterruptedException {
        ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
        String s = "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;" +
                "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;\r\n";
        channelFuture.channel().writeAndFlush(s);
        Thread.sleep(1000);
        nettyClient.disconnect(channelFuture.channel());
        return "发送成功";
    }

    @GetMapping("/app/netty/delimiter")
    public String testDelimiter() throws InterruptedException {
        ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
        String s = "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;" +
                "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;78B987";
        channelFuture.channel().writeAndFlush(s);
        Thread.sleep(1000);
        nettyClient.disconnect(channelFuture.channel());
        return "发送成功";
    }

    @GetMapping("/app/netty/lengthField")
    public String testLengthField() throws InterruptedException {
        ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);

        for (int i = 0; i < 150; i++) {
            //长度 64
            byte[] sendMsgBytes = ("一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;[" + i + "]").getBytes(StandardCharsets.UTF_8);
            //长度 5
            byte[] headerBytes = "ABCDE".getBytes(StandardCharsets.UTF_8);

            int bodyLength = sendMsgBytes.length + headerBytes.length;
            byte[] bytes = {};
            //长度 5
            bytes = ByteUtils.append(bytes, headerBytes);
            //长度 4
            bytes = ByteUtils.append(bytes, ByteUtil.intToBytes(bodyLength));
            //长度 64
            bytes = ByteUtils.append(bytes, sendMsgBytes);
            channelFuture.channel().writeAndFlush(bytes);
            Thread.sleep(1000);
        }


        nettyClient.disconnect(channelFuture.channel());
        return "发送成功";
    }
}

###
GET http://localhost:8080/app/netty/normal/byteBuf

### 2 以字节发送、以字节接收，必须加 byte 解码器和编码器
GET http://localhost:8080/app/netty/normal/byte

### 3 以字符串发送、以字符串接收，必须加 string 解码器和编码器
GET http://localhost:8080/app/netty/normal/string

### 4 验证 粘包、拆包
GET http://localhost:8080/app/netty/normal/nbcb


### 5 验证 粘包、拆包 固定长度解决方案
GET http://localhost:8080/app/netty/fixLength

### 6 验证 粘包、拆包 通过在包尾添加回车换行符 \r\n 来区分整包消息
GET http://localhost:8080/app/netty/lineBase0

### 7
GET http://localhost:8080/app/netty/lineBase1

### 8
GET http://localhost:8080/app/netty/lineBase2


### 9 验证 粘包、拆包  特殊字符作为分隔符来区分整包消息；
GET http://localhost:8080/app/netty/delimiter0

### 10 验证 粘包、拆包  特殊字符作为分隔符来区分整包消息；
GET http://localhost:8080/app/netty/delimiter1

### 11 验证 粘包、拆包  特殊字符作为分隔符来区分整包消息；
GET http://localhost:8080/app/netty/delimiter2


### 12 验证 粘包、拆包 固定长度解决方案
GET http://localhost:8080/app/netty/fixLength0

### 13 验证 粘包、拆包 固定长度解决方案
GET http://localhost:8080/app/netty/fixLength1

### 14 验证 粘包、拆包 固定长度解决方案
GET http://localhost:8080/app/netty/fixLength2

### 15 验证 粘包、拆包  特殊字符作为分隔符来区分整包消息；
GET http://localhost:8080/app/netty/lengthField0

启动

package com.example.netty;

import com.example.netty.common.client.NettyClient;
import com.example.netty.common.server.NettyServer;
import com.example.netty.common.utils.NettyConstants;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.event.ApplicationStartedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.EnableAsync;

import javax.annotation.Resource;

@SpringBootApplication
@EnableAsync
public class NettyDemoApplication {

    @Resource
    private NettyServer nettyServer;
    @Resource
    private NettyClient nettyClient;

    public static void main(String[] args) {
        SpringApplication.run(NettyDemoApplication.class, args);
        System.out.println("+++++服务启动成功+++++");
    }

    @EventListener(ApplicationStartedEvent.class)
    public void init() {
        // 测试 normal byteBuf 包
        String type = NettyConstants.NORMAL_BYTE_BUF;
        // 测试 byte 包
//        String type = NettyConstants.NORMAL_BYTE;
        // 测试String 包
//        String type = NettyConstants.NORMAL_STRING;
        // 演示 拆包和粘包
//        String type = NettyConstants.NBCB;
        // 粘包和拆包固定长度解决方案
//        String type = NettyConstants.FIX_LENGTH;
        // 拆包、粘包 结尾\r\n 来区分整包解决方案
//        String type = NettyConstants.LINE_BASE;
        // 拆包、粘包 特殊字符结尾来区分整包解决方案
//        String type = NettyConstants.DELIMITER;
        // 头部设置 整包的长度来进行整包区分，每个包的长度放在头部
//        String type = NettyConstants.LENGTH_FIELD;
        nettyServer.init("127.0.0.1", 9000, type);
        nettyClient.init(type);
    }
}

ByteBuf

netty最基本的用法，不设置decoder、encoder等，默认采用byteBuf 的方式进行发送和接收；

注意：如果发送方的编码格式和接收方的编码格式不一致，会导致接收不到消息，且不会报错

客户端

初始化handler 和Decoder、Encoder的配置，采用的是责任链模式

package com.example.netty.normal.bytebuf.client;

import com.example.netty.common.client.ClientHeartBeatServerHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:06
 **/
@SuppressWarnings("all")
public class NormalByteBufClientInitializer extends ChannelInitializer<SocketChannel> {

    private static final String DECODER = "decoder";
    private static final String ENCODER = "encoder";
    /**
     * 为读超时时间（即多长时间没有接受到客户端发送数据）
     */
    private final long readerIdleTime = 0;
    /**
     * 为写超时时间（即多长时间没有向客户端发送数据）
     */
    private final long writerIdleTime = 0;
    /**
     * 所有类型（读或写）的超时时间
     */
    private final long allIdleTime = 0;

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline().addLast(new ClientHeartBeatServerHandler())
                .addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.SECONDS))
                .addLast(new NormalByteBufClientHandler())
        ;
    }
}

服务端

package com.example.netty.normal.bytebuf.server;

import com.example.netty.common.server.ConnectionCountHandler;
import com.example.netty.common.server.ServerHeartBeatServerHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:04
 **/
@SuppressWarnings("all")
public class NormalByteBufServerInitializer extends ChannelInitializer<SocketChannel> {
    private static final String ENCODER = "encoder";
    private static final String DECODER = "decoder";

    /**
     * 为读超时时间（即多长时间没有接受到客户端发送数据）
     */
    private final long readerIdleTime = 0;
    /**
     * 为写超时时间（即多长时间没有向客户端发送数据）
     */
    private final long writerIdleTime = 0;
    /**
     * 所有类型（读或写）的超时时间
     */
    private final long allIdleTime = 0;

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline().addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.SECONDS))
                .addLast(new NormalByteBufServerHandler())
                .addLast(new ConnectionCountHandler())
                .addLast(new ServerHeartBeatServerHandler())
        ;

    }
}

测试1

@GetMapping("/app/netty/normal/byteBuf")
public String testNormalByteBuf() throws InterruptedException {
    logger.debug("发送正常情况下的 normal byte buf 模式");
    ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
    for (int i = 0; i < 10; i++) {
        String msg = "一岁一枯荣,野火烧不尽;";
        // 此处采用的是 byte形式进行发送消息，但是 initChannel没有配置 decoder 和encoder的转译，因此服务端收不到消息
        channelFuture.channel().writeAndFlush(msg.getBytes(StandardCharsets.UTF_8));
        Thread.sleep(1000);
    }
    nettyClient.disconnect(channelFuture.channel());
    return "normal byte buf 发送成功";
}

输出

只有创建连接的日志没有收到客户端消息的日志

测试2

@GetMapping("/app/netty/normal/byteBuf")
public String testNormalByteBuf() throws InterruptedException {
    logger.debug("发送正常情况下的 normal byte buf 模式");
    ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
    for (int i = 0; i < 10; i++) {
        String msg = "一岁一枯荣,野火烧不尽;";
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer();
        buffer.writeBytes(msg.getBytes(StandardCharsets.UTF_8));
        // 此处采用byte模式
        channelFuture.channel().writeAndFlush(buffer);
        Thread.sleep(1000);
    }
    nettyClient.disconnect(channelFuture.channel());
    return "normal byte buf 发送成功";
}

输出

Byte 模式

客户端

客户端配置

package com.example.netty.normal.bytes.client;

import com.example.netty.common.client.ClientHeartBeatServerHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.bytes.ByteArrayDecoder;
import io.netty.handler.codec.bytes.ByteArrayEncoder;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:06
 **/
@SuppressWarnings("all")
public class NormalByteClientInitializer extends ChannelInitializer<SocketChannel> {

    /**
     * 为读超时时间（即多长时间没有接受到客户端发送数据）
     */
    private final long readerIdleTime = 0;
    /**
     * 为写超时时间（即多长时间没有向客户端发送数据）
     */
    private final long writerIdleTime = 0;
    /**
     * 所有类型（读或写）的超时时间
     */
    private final long allIdleTime = 0;
    private static final String DECODER = "decoder";
    private static final String ENCODER = "encoder";
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline().addLast(new ClientHeartBeatServerHandler())
                // 心跳监听配置
                .addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.SECONDS))
                // 客户端向服务端发送消息时 采用 byte 编码方式，对应 NormalByteServerInitializer 中的decoder
                // TestClientController.testNormalByte 中发送时需要 以 字节方式进行发送
                .addLast(ENCODER, new ByteArrayEncoder())
                // 服务端向客户端发送消息，采用byte 编码方式，对应NormalByteServerInitializer 中的encoder
                // 需要对应 NormalByteServerHandler.channelRead  ctx.channel().writeAndFlush(serverMsg.getBytes(StandardCharsets.UTF_8));
                .addLast(DECODER, new ByteArrayDecoder())
                // 用于监听消息、处理消息，如果 DECODER 设置的是字节，则channelRead 收到的msg 是字节
                .addLast(new NormalByteClientHandler())
        ;
    }
}

客户端handler

package com.example.netty.normal.bytes.client;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.charset.StandardCharsets;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:41
 **/
public class NormalByteClientHandler extends ChannelInboundHandlerAdapter {
    private static final Logger logger = LoggerFactory.getLogger(NormalByteClientHandler.class);

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.info("接收到服务端的响应:{} ", ctx.channel().id().asLongText());
        String body = new String((byte[]) msg, StandardCharsets.UTF_8);
        System.out.println("-----client start------| " + body + " | ------client end------");
    }
}

服务端

服务端配置

package com.example.netty.normal.bytes.server;

import com.example.netty.common.server.ConnectionCountHandler;
import com.example.netty.common.server.ServerHeartBeatServerHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.bytes.ByteArrayDecoder;
import io.netty.handler.codec.bytes.ByteArrayEncoder;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:04
 **/
@SuppressWarnings("all")
public class NormalByteServerInitializer extends ChannelInitializer<SocketChannel> {
    private static final String ENCODER = "encoder";
    private static final String DECODER = "decoder";

    /**
     * 为读超时时间（即多长时间没有接受到客户端发送数据）
     */
    private final long readerIdleTime = 0;
    /**
     * 为写超时时间（即多长时间没有向客户端发送数据）
     */
    private final long writerIdleTime = 0;
    /**
     * 所有类型（读或写）的超时时间
     */
    private final long allIdleTime = 0;

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline().addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.SECONDS))
                // 服务端向客户端发送消息，采用byte 编码方式，对应 NormalByteClientInitializer 中的decoder 
                // 需要对应 NormalByteServerHandler.channelRead  ctx.channel().writeAndFlush(serverMsg.getBytes(StandardCharsets.UTF_8));
                .addLast(ENCODER, new ByteArrayEncoder())
                // 客户端向服务端发送消息时 采用 byte 编码方式，对应 NormalByteClientInitializer 中的 encoder
                // TestClientController.testNormalByte 中发送时需要 以 字节方式进行发送
                .addLast(DECODER, new ByteArrayDecoder())
                // 监听消息，并接收消息，此处配置的是 字节，因此收到的消息 是字节，强转位 字节
                .addLast(new NormalByteServerHandler())
                // 监听 客户端连接
                .addLast(new ConnectionCountHandler())
                // 监听客户端心跳
                .addLast(new ServerHeartBeatServerHandler())
        ;

    }
}

服务端handler

package com.example.netty.normal.bytes.server;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.charset.StandardCharsets;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:39
 **/
public class NormalByteServerHandler extends ChannelInboundHandlerAdapter {

    private static final Logger logger = LoggerFactory.getLogger(NormalByteServerHandler.class);


    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.debug("收到客户端消息");
        try {
            // 因为TestClientController.testNormalByte 中发送时以字节发送
            // 对应NormalByteServerInitializer 的decoder ByteArrayDecoder 此类将 byteBuf 处理为了 bytes
            // NormalByteClientInitializer encoder 
            // 因此此处可以强转为 byte 
            String body = new String((byte[]) msg, StandardCharsets.UTF_8);
            System.out.println("-----server start------| " + body + " | ------server end------");

            //发送给客户端
            String serverMsg = "++++++++我是服务端给客户端的消息+++++++";
            // 此处需要对应 NormalByteServerInitializer 中的encoder 模式
            // 以及 NormalByteClientInitializer 中的decoder 模式，如果不匹配则客户端收不到消息
            // 因为 encoder 与 decoder 配置的是 ByteArrayDecoder、ByteArrayEncoder 因此此处只能发送字节
            ctx.channel().writeAndFlush(serverMsg.getBytes(StandardCharsets.UTF_8));
        } catch (Exception e) {
            logger.error("接收数据异常", e);
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

测试

@GetMapping("/app/netty/normal/byte")
public String testNormalByte() throws InterruptedException {
    logger.debug("发送正常情况下的 normal byte 模式");
    ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
    for (int i = 0; i < 10; i++) {
        String msg = "一岁一枯荣,野火烧不尽;";
        // 此处发送 字节还是字符串 需要对应 NormalByteClientInitializer 里面的encoder 配置
        // 以及NormalByteServerInitializer  decoder 设置，如果不是 字节方式，则服务端收不到消息
        channelFuture.channel().writeAndFlush(msg.getBytes(StandardCharsets.UTF_8));
        Thread.sleep(1000);
    }
    nettyClient.disconnect(channelFuture.channel());
    return "normal byte 发送成功";
}

执行 TestClientController.http

### 2 以字节发送、以字节接收，必须加 byte 解码器和编码器
GET http://localhost:8080/app/netty/normal/byte

输出

String 模式

客户端发送的方式以及 initChannel 中的encoder 必须与服务端的initChannel的decoder 以及接收方式匹配，如果匹配不上则有可能收不到消息；

客户端

客户端配置

package com.example.netty.normal.string.client;

import com.example.netty.common.client.ClientHeartBeatServerHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.bytes.ByteArrayDecoder;
import io.netty.handler.codec.bytes.ByteArrayEncoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:06
 **/
@SuppressWarnings("all")
public class NormalStringClientInitializer extends ChannelInitializer<SocketChannel> {

    /**
     * 为读超时时间（即多长时间没有接受到客户端发送数据）
     */
    private final long readerIdleTime = 0;
    /**
     * 为写超时时间（即多长时间没有向客户端发送数据）
     */
    private final long writerIdleTime = 0;
    /**
     * 所有类型（读或写）的超时时间
     */
    private final long allIdleTime = 0;
    private static final String DECODER = "decoder";
    private static final String ENCODER = "encoder";
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        // 心跳监听配置
        ch.pipeline().addLast(new ClientHeartBeatServerHandler())
                // 心跳监听配置
                .addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.SECONDS))
                // 客户端向服务端发送消息时 采用 字符串 编码方式，对应 NormalStringServerInitializer 中的decoder
                // TestClientController.testNormalString 中发送时需要 以字符串方式进行发送
                // NormalStringServerHandler.channelRead 以字符串方式进行接收
                .addLast(ENCODER, new StringEncoder())
                // 服务端向客户端发送消息，采用字符串编码方式，对应 NormalStringServerInitializer 中的encoder
                // 需要对应 NormalStringServerHandler.channelRead  ctx.channel().writeAndFlush(serverMsg);
                // NormalStringClientHandler.channelRead 通过字符串接收
                .addLast(DECODER, new StringDecoder())
                // 用于监听消息、处理消息，如果 DECODER 设置的是字节，则channelRead 收到的msg 是字符串
                .addLast(new NormalStringClientHandler())

        ;
    }
}

客户端Handler

package com.example.netty.normal.string.client;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.charset.StandardCharsets;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:41
 **/
public class NormalStringClientHandler extends ChannelInboundHandlerAdapter {
    private static final Logger logger = LoggerFactory.getLogger(NormalStringClientHandler.class);

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.info("接收到服务端的响应:{} ", ctx.channel().id().asLongText());
        // 服务端向客户端发送消息，采用字符串编码方式，对应 NormalStringServerInitializer 中的encoder
        // NormalStringClientInitializer 的decoder  StringDecoder 将字节转 字符串处理
        // 因此此处采用 字符串接收，
        String body = (String) msg;
        System.out.println("-----client start------| " + body + " | ------client end------");
    }
}

服务端

服务端配置

package com.example.netty.normal.string.server;

import com.example.netty.common.server.ConnectionCountHandler;
import com.example.netty.common.server.ServerHeartBeatServerHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.bytes.ByteArrayDecoder;
import io.netty.handler.codec.bytes.ByteArrayEncoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:04
 **/
@SuppressWarnings("all")
public class NormalStringServerInitializer extends ChannelInitializer<SocketChannel> {
    private static final String ENCODER = "encoder";
    private static final String DECODER = "decoder";

    /**
     * 为读超时时间（即多长时间没有接受到客户端发送数据）
     */
    private final long readerIdleTime = 0;
    /**
     * 为写超时时间（即多长时间没有向客户端发送数据）
     */
    private final long writerIdleTime = 0;
    /**
     * 所有类型（读或写）的超时时间
     */
    private final long allIdleTime = 0;

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        // 心跳
        ch.pipeline().addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.SECONDS))
                // 服务端向客户端发送消息，采用 字符串 编码方式，对应 NormalStringClientInitializer 中的decoder
                // 需要对应 NormalStringServerHandler.channelRead  ctx.channel().writeAndFlush(serverMsg);
                // NormalStringClientHandler.channelRead 通过字符串接收
                .addLast(ENCODER, new StringEncoder())
                // 客户端向服务端发送消息时 采用 字符串 编码方式，对应 NormalStringClientInitializer 中的 encoder
                // TestClientController.testNormalString 中发送时需要 以 字符串 方式进行发送
                // NormalStringServerHandler.channelRead 以字符串方式进行接收
                .addLast(DECODER, new StringDecoder())
                // 监听消息，并接收消息，此处配置的是 字节，因此收到的消息 是字节，强转位 字节

                .addLast(new NormalStringServerHandler())
                // 监听 客户端连接
                .addLast(new ConnectionCountHandler())
                // 监听客户端心跳
                .addLast(new ServerHeartBeatServerHandler())
        ;

    }
}

服务端Handler

package com.example.netty.normal.string.server;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.charset.StandardCharsets;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:39
 **/
public class NormalStringServerHandler extends ChannelInboundHandlerAdapter {

    private static final Logger logger = LoggerFactory.getLogger(NormalStringServerHandler.class);


    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.debug("收到客户端消息");
        try {
//          NormalStringClientInitializer 中的 encoder
//            NormalStringServerInitializer 中的 decoder   StringDecoder 将字节转成了 字符串，可看源码
//
            String body = (String) msg;
            System.out.println("-----server start------| " + body + " | ------server end------");

            //发送给客户端
//            服务端向客户端发送消息，采用 字符串 编码方式，对应 NormalStringServerInitializer 中的 encoder
//            NormalStringClientInitializer 中的decoder
            String serverMsg = "++++++++我是服务端给客户端的消息+++++++";
            ctx.channel().writeAndFlush(serverMsg);
        } catch (Exception e) {
            logger.error("接收数据异常", e);
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

测试

@GetMapping("/app/netty/normal/string")
public String testNormalString() throws InterruptedException {
    logger.debug("发送正常情况下的  string 模式");
    ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
    for (int i = 0; i < 10; i++) {
        String msg = "一岁一枯荣,野火烧不尽;";
        channelFuture.channel().writeAndFlush(msg);
        Thread.sleep(1000);
    }
    nettyClient.disconnect(channelFuture.channel());
    return "string 发送成功";
}

执行 TestClientController.http

### 3 以字符串发送、以字符串接收，必须加 string 解码器和编码器
GET http://localhost:8080/app/netty/normal/string

拆包、粘包复现

拆包、粘包测试客户端采用ByteBuf模式进行发送以及接收、服务端采用ByteBuf模式进行接收以及给客户端发送；

客户端

客户端配置

采用默认的byteBuf 模式，及没有配置任何编码器和解码器，默认采用byteBuf形式进行发送和接收

package com.example.netty.nbcb.client;

import com.example.netty.common.client.ClientHeartBeatServerHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:06
 **/
@SuppressWarnings("all")
public class NormalNBCBClientInitializer extends ChannelInitializer<SocketChannel> {

    private static final String DECODER = "decoder";
    private static final String ENCODER = "encoder";
    /**
     * 为读超时时间（即多长时间没有接受到客户端发送数据）
     */
    private final long readerIdleTime = 0;
    /**
     * 为写超时时间（即多长时间没有向客户端发送数据）
     */
    private final long writerIdleTime = 0;
    /**
     * 所有类型（读或写）的超时时间
     */
    private final long allIdleTime = 0;

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline().addLast(new ClientHeartBeatServerHandler())
                .addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.SECONDS))
                .addLast(new NormalNBCBClientHandler())
        ;
    }
}

客户端Handler

package com.example.netty.nbcb.client;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.charset.StandardCharsets;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:41
 **/
public class NormalNBCBClientHandler extends ChannelInboundHandlerAdapter {
    private static final Logger logger = LoggerFactory.getLogger(NormalNBCBClientHandler.class);

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.info("接收到服务端的响应");
        ByteBuf buf = (ByteBuf) msg;
        byte[] req = new byte[buf.readableBytes()];
        buf.readBytes(req);
        String body = new String(req, StandardCharsets.UTF_8);
        System.out.println("-----client start------|\n " + body + " \n| ------client end------");
    }
}

服务端

服务端配置

package com.example.netty.nbcb.server;

import com.example.netty.common.server.ConnectionCountHandler;
import com.example.netty.common.server.ServerHeartBeatServerHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:04
 **/
@SuppressWarnings("all")
public class NormalNBCBServerInitializer extends ChannelInitializer<SocketChannel> {
    private static final String ENCODER = "encoder";
    private static final String DECODER = "decoder";

    /**
     * 为读超时时间（即多长时间没有接受到客户端发送数据）
     */
    private final long readerIdleTime = 0;
    /**
     * 为写超时时间（即多长时间没有向客户端发送数据）
     */
    private final long writerIdleTime = 0;
    /**
     * 所有类型（读或写）的超时时间
     */
    private final long allIdleTime = 0;

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline().addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.SECONDS))
                .addLast(new NormalNBCBServerHandler())
                .addLast(new ConnectionCountHandler())
                .addLast(new ServerHeartBeatServerHandler())
        ;

    }
}

服务端handler

package com.example.netty.nbcb.server;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.charset.StandardCharsets;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:39
 **/
public class NormalNBCBServerHandler extends ChannelInboundHandlerAdapter {

    private static final Logger logger = LoggerFactory.getLogger(NormalNBCBServerHandler.class);


    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.debug("收到客户端消息");
        try {
            ByteBuf buf = (ByteBuf) msg;
            byte[] req = new byte[buf.readableBytes()];
            buf.readBytes(req);
            String body = new String(req, StandardCharsets.UTF_8);
            System.out.println("-----start------|\n  " + body + " \n | ------end------");

            //发送给客户端
            for (int n = 0; n < 5; n++) {
                String serverMsg = "++++++++我是服务端给客户端的消息 【" + n + "】+++++++\n";
                // 初始化 容量，默认是1024
                ByteBuf serverBuffer = ctx.alloc().buffer(16);
                serverBuffer.writeBytes(serverMsg.getBytes(StandardCharsets.UTF_8));
                // 此处演示粘包现象，连续发送了多次，客户端将多次请求合并接收，可以看接收的序号
                ctx.channel().writeAndFlush(serverBuffer);
            }
        } catch (Exception e) {
            logger.error("接收数据异常", e);
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

测试

执行 TestClientController.http

### 4 验证 粘包、拆包
GET http://localhost:8080/app/netty/normal/nbcb

@GetMapping("/app/netty/normal/nbcb")
public String testNb() throws InterruptedException {
    logger.debug("验证粘包、拆包现象，客户端给服务端发送产生拆包、服务端给客户端发送产生 粘包");
    ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
    StringBuilder msg = new StringBuilder("一岁一枯荣,野火烧不尽;");
    for (int i = 0; i < 10; i++) {
        msg.append(msg);
    }
    msg.append("end");
    ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer();
    buffer.writeBytes(msg.toString().getBytes(StandardCharsets.UTF_8));
    // 演示拆包现象，此处 只发送了一次，客户端接收了多次
    channelFuture.channel().writeAndFlush(buffer);
    Thread.sleep(1000);
    nettyClient.disconnect(channelFuture.channel());
    return "string 发送成功";
}

输出

解决拆包粘包方案

处理 TCP 粘包的唯一方法就是制定应用层的数据通讯协议，通过协议来规范现有接收的数据是否满足消息数据的需要。

为了解决网络数据流的拆包粘包问题，Netty 为我们内置了如下的解码器：

ByteToMessageDecoder：如果想实现自己的半包解码器，实现该类；
MessageToMessageDecoder：一般作为二次解码器，当我们在 ByteToMessageDecoder 将一个 bytes 数组转换成一个 java 对象的时候，我们可能还需要将这个对象进行二次解码成其他对象，我们就可以继承这个类；
LineBasedFrameDecoder：通过在包尾添加回车换行符 \r\n 来区分整包消息；
StringDecoder：字符串解码器；
DelimiterBasedFrameDecoder：特殊字符作为分隔符来区分整包消息；
FixedLengthFrameDecoder：报文大小固定长度，不够空格补全；
ProtoBufVarint32FrameDecoder：通过 Protobuf 解码器来区分整包消息；
ProtobufDecoder： Protobuf 解码器；
LengthFieldBasedFrameDecoder：指定长度来标识整包消息，通过在包头指定整包长度来约定包长。

Netty 还内置了如下的编码器：

ProtobufEncoder：Protobuf 编码器；
MessageToByteEncoder：将 Java 对象编码成 ByteBuf；
MessageToMessageEncoder：如果不想将 Java 对象编码成 ByteBuf，而是自定义类就继承这个；
LengthFieldPrepender：LengthFieldPrepender 是一个非常实用的工具类，如果我们在发送消息的时候采用的是：消息长度字段+原始消息的形式，那么我们就可以使用 LengthFieldPrepender。这是因为 LengthFieldPrepender 可以将待发送消息的长度（二进制字节长度）写到 ByteBuf 的前两个字节。

以下通过代码来具体说明如何用，测试采用String编码、解码器：

LineBased

LineBasedFrameDecoder参数说明：

maxLength 一包的最大长度，如果包长大于这个最大长度则会抛出异常；
stripDelimiter 解码后的消息是否去除分隔符; 此处是通过 \n\r来进行区分，因此接收到消息后建议去掉分割符;
failFast为true，当frame长度超过maxFrameLength时立即报TooLongFrameException异常，为false，读取完整个帧再报异常;

客户端

客户端配置

package com.example.netty.linebase.client;

import com.example.netty.common.client.ClientHeartBeatServerHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.LineBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:06
 **/
@SuppressWarnings("all")
public class LineBaseClientInitializer extends ChannelInitializer<SocketChannel> {
    private static final String DECODER = "decoder";
    private static final String ENCODER = "encoder";

    /**
     * 为读超时时间（即多长时间没有接受到客户端发送数据）
     */
    private final long readerIdleTime = 0;
    /**
     * 为写超时时间（即多长时间没有向客户端发送数据）
     */
    private final long writerIdleTime = 0;
    /**
     * 所有类型（读或写）的超时时间
     */
    private final long allIdleTime = 0;

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline().addLast(new ClientHeartBeatServerHandler())
                .addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.SECONDS))
                // 优先判断最大长度
                // stripDelimiter:解码后的消息是否去除分隔符 此处是 通过 \n\r来进行区分，因此接收到消息后需要去掉分割符
                // failFast = false, 那么会等到解码出完整消息才会抛出 TooLongException。
//                Integer.MAX_VALUE 一包的最大长度，如果包长大于这个最大长度则会抛出异常
                .addLast(new LineBasedFrameDecoder(Integer.MAX_VALUE, true, false))
                .addLast(ENCODER, new StringEncoder())
                .addLast(DECODER, new StringDecoder())
                .addLast(new LineBaseClientHandler())

        ;
    }
}

客户端Handler

package com.example.netty.linebase.client;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:41
 **/
public class LineBaseClientHandler extends ChannelInboundHandlerAdapter {
    private static final Logger logger = LoggerFactory.getLogger(LineBaseClientHandler.class);

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.info("接收到服务端的响应");
        String body = (String) msg;
        System.out.println("-----client start------| \n " + body + " \n| ------client end------");
    }
}

服务端

服务端配置

package com.example.netty.linebase.server;

import com.example.netty.common.server.ConnectionCountHandler;
import com.example.netty.common.server.ServerHeartBeatServerHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.LineBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:04
 **/
@SuppressWarnings("all")
public class LineBaseServerInitializer extends ChannelInitializer<SocketChannel> {
    private static final String ENCODER = "encoder";
    private static final String DECODER = "decoder";

    /**
     * 如果failFast=true，当超过maxLength后会立刻抛出TooLongFrameException，不再进行解码；
     * 如果failFast=false，那么会等到解码出一个完整的消息后才会抛出TooLongFrameException
     */
    private final boolean failFast = false;
    /**
     * 为读超时时间（即多长时间没有接受到客户端发送数据）
     */
    private final long readerIdleTime = 0;
    /**
     * 为写超时时间（即多长时间没有向客户端发送数据）
     */
    private final long writerIdleTime = 0;
    /**
     * 所有类型（读或写）的超时时间
     */
    private final long allIdleTime = 0;

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline().addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.SECONDS))
                // 优先判断最大长度
                // stripDelimiter:解码后的消息是否去除分隔符,此处是 通过 \n\r来进行区分，因此接收到消息后需要去掉分割符
                // failFast = false, 那么会等到解码出完整消息才会抛出 TooLongException。
                .addLast(new LineBasedFrameDecoder(Integer.MAX_VALUE, true, failFast))
                .addLast(ENCODER, new StringEncoder())
                .addLast(DECODER, new StringDecoder())
                .addLast(new ConnectionCountHandler())
                .addLast(new LineBaseServerHandler())
                .addLast(new ServerHeartBeatServerHandler())

        ;

    }
}

服务端Handler

package com.example.netty.linebase.server;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.charset.StandardCharsets;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:39
 **/
public class LineBaseServerHandler extends ChannelInboundHandlerAdapter {

    private static final Logger logger = LoggerFactory.getLogger(LineBaseServerHandler.class);


    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.debug("收到客户端消息");
        try {
            String body = (String) msg;
            System.out.println("-----client start------| \n " + body + " \n| ------client end------");
            // 如果没有分割符 收不到消息；
            ctx.channel().writeAndFlush("我是服务端给客户端的消息;\r\n我是服务端给客户端的消息;\r\n");
        } catch (Exception e) {
            logger.error("接收数据异常", e);
        }
    }


    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

    public static void main(String[] args) {
        System.out.println("我是服务端给客户端的消息;".getBytes(StandardCharsets.UTF_8).length);
    }
}

测试0

执行 TestClientController.http

### 6 验证 粘包、拆包 通过在包尾添加回车换行符 \r\n 来区分整包消息
GET http://localhost:8080/app/netty/lineBase0

@GetMapping("/app/netty/lineBase0")
public String testLineBase0() throws InterruptedException {
    ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
    // 服务端收不到条消息， 因为没有监听到分割符，因此服务端收不到消息
    String s = "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;" +
            "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;";
    channelFuture.channel().writeAndFlush(s);
    Thread.sleep(1000);
    nettyClient.disconnect(channelFuture.channel());
    return "发送成功";
}

输出

测试1

执行 TestClientController.http

###
GET http://localhost:8080/app/netty/lineBase1

@GetMapping("/app/netty/lineBase1")
public String testLineBase1() throws InterruptedException {
    ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
    // 服务端收到一条消息
    String s = "发送一次，收到一次；一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;" +
            "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;\r\n";
    channelFuture.channel().writeAndFlush(s);
    Thread.sleep(1000);
    nettyClient.disconnect(channelFuture.channel());
    return "发送成功";
}

输出

测试2

执行 TestClientController.http

###
GET http://localhost:8080/app/netty/lineBase2

@GetMapping("/app/netty/lineBase2")
public String testLineBase2() throws InterruptedException {
    ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
    // 此处因为 有两个 分割符号 \r\n 因此服务端收到两条消息
    String s = "发送一次，收到两次；一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;\r\n" +
            "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;\r\n";
    channelFuture.channel().writeAndFlush(s);
    Thread.sleep(1000);
    nettyClient.disconnect(channelFuture.channel());
    return "发送成功";
}

输出

DelimiterBased

此解码器是LineBasedFrameDecoder 升级版。可以自定义进行整包分割的字符；

需要注意的是用来进行判断整包结尾的分割符务必不要和包体数据重复，否则容易将数据进行分割；

DelimiterBasedFrameDecoder参数说明：

maxLength 一包的最大长度，如果包长大于这个最大长度则会抛出异常；
stripDelimiter 解码后的消息是否去除分隔符;
failFast为true，当frame长度超过maxFrameLength时立即报TooLongFrameException异常，为false，读取完整个帧再报异常;
delimiter 自定义分割符，是byteBuf 类型的。

客户端

客户端配置

package com.example.netty.delimiter.client;

import com.example.netty.common.client.ClientHeartBeatServerHandler;
import com.example.netty.common.utils.NettyConstants;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.LineBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;

import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:06
 **/
@SuppressWarnings("all")
public class DelimiterClientInitializer extends ChannelInitializer<SocketChannel> {
    private static final String DECODER = "decoder";
    private static final String ENCODER = "encoder";
    private static final String PING = "ping";

    /**
     * 如果failFast=true，当超过maxLength后会立刻抛出TooLongFrameException，不再进行解码；
     * 如果failFast=false，那么会等到解码出一个完整的消息后才会抛出TooLongFrameException
     */
    private final boolean failFast = false;
    /**
     * 为读超时时间（即多长时间没有接受到客户端发送数据）
     */
    private final long readerIdleTime = 0;
    /**
     * 为写超时时间（即多长时间没有向客户端发送数据）
     */
    private final long writerIdleTime = 0;
    /**
     * 所有类型（读或写）的超时时间
     */
    private final long allIdleTime = 0;

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline().addLast(new ClientHeartBeatServerHandler())
                .addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.SECONDS))
                // 优先判断最大长度
                // stripDelimiter:解码后的消息是否去除分隔符 不去掉分割符
                // failFast = false, 那么会等到解码出完整消息才会抛出 TooLongException。
                // 此处采用  ; 进行分割  服务端给客户端发送消息，客户端收到消息根据 ; 字符判断是否为一包数据
                .addLast(new DelimiterBasedFrameDecoder(Integer.MAX_VALUE, false, false,
                        Unpooled.copiedBuffer(NettyConstants.DELIMITER_SPLIT_CLIENT.getBytes(StandardCharsets.UTF_8))))
                .addLast(ENCODER, new StringEncoder())
                .addLast(DECODER, new StringDecoder())
                .addLast(new DelimiterClientHandler())
        ;
    }
}

客户端Handler

package com.example.netty.delimiter.client;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:41
 **/
public class DelimiterClientHandler extends ChannelInboundHandlerAdapter {
    private static final Logger logger = LoggerFactory.getLogger(DelimiterClientHandler.class);

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.info("接收到服务端的响应");
        String body = (String) msg;
        System.out.println("-----client start------| \n " + body + " \n| ------client end------");
    }
}

服务端

服务端配置

package com.example.netty.delimiter.server;

import com.example.netty.common.server.ConnectionCountHandler;
import com.example.netty.common.server.ServerHeartBeatServerHandler;
import com.example.netty.common.utils.NettyConstants;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.LineBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;

import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:04
 **/
@SuppressWarnings("all")
public class DelimiterServerInitializer extends ChannelInitializer<SocketChannel> {
    private static final String ENCODER = "encoder";
    private static final String DECODER = "decoder";

    /**
     * 如果failFast=true，当超过maxLength后会立刻抛出TooLongFrameException，不再进行解码；
     * 如果failFast=false，那么会等到解码出一个完整的消息后才会抛出TooLongFrameException
     */
    private final boolean failFast = false;
    /**
     * 为读超时时间（即多长时间没有接受到客户端发送数据）
     */
    private final long readerIdleTime = 0;
    /**
     * 为写超时时间（即多长时间没有向客户端发送数据）
     */
    private final long writerIdleTime = 0;
    /**
     * 所有类型（读或写）的超时时间
     */
    private final long allIdleTime = 0;

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline().addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.SECONDS))
                // 优先判断最大长度
                // stripDelimiter:解码后的消息是否去除分隔符
                // failFast = false, 那么会等到解码出完整消息才会抛出 TooLongException。
                // 此处通过 78B987  来进行分割是否为一包数据，服务端收到客户端消息；需要注意的是  用来进行判断整包结尾的分割符 务必不要和包体 数据重复
                .addLast(new DelimiterBasedFrameDecoder(Integer.MAX_VALUE, true, failFast,
                        Unpooled.copiedBuffer(NettyConstants.DELIMITER_SPLIT_SERVER.getBytes(StandardCharsets.UTF_8))))
                .addLast(ENCODER, new StringEncoder())
                .addLast(DECODER, new StringDecoder())
                .addLast(new ConnectionCountHandler())
                .addLast(new DelimiterServerHandler())
                .addLast(new ServerHeartBeatServerHandler())

        ;

    }
}

服务端Handler

package com.example.netty.delimiter.server;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.charset.StandardCharsets;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:39
 **/
public class DelimiterServerHandler extends ChannelInboundHandlerAdapter {

    private static final Logger logger = LoggerFactory.getLogger(DelimiterServerHandler.class);


    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.debug("收到客户端消息");
        try {
            String body = (String) msg;
            System.out.println("-----client start------| \n " + body + " \n| ------client end------");
            // 如果没有分割符 收不到消息；
            ctx.channel().writeAndFlush("我是服务端给客户端的消息;我是服务端给客户端的消息;");
        } catch (Exception e) {
            logger.error("接收数据异常", e);
        }
    }


    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

    public static void main(String[] args) {
        System.out.println("我是服务端给客户端的消息;".getBytes(StandardCharsets.UTF_8).length);
    }
}

测试0

执行 TestClientController.http

#### 9 验证 粘包、拆包  特殊字符作为分隔符来区分整包消息；
GET http://localhost:8080/app/netty/delimiter0

客户端给服务端发送消息，没有分割符，服务端收不到消息，直到遇到分割符，服务端才监听到消息；

@GetMapping("/app/netty/delimiter0")
public String testDelimiter0() throws InterruptedException {
    ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
    // 没有分割符，服务端收不到消息
    String s = "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;" +
            "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;没有分割符";
    //本次发送没有分割符
    channelFuture.channel().writeAndFlush(s);
    Thread.sleep(1000);
    // 在发送一次
    channelFuture.channel().writeAndFlush("重新发送一次，发送分割符78B987");
    // 此处休眠 1 s 断开连接是为了收 服务端消息
    Thread.sleep(1000);
    nettyClient.disconnect(channelFuture.channel());
    return "发送成功";
}

服务端输出，服务端通过 78B987 分割符来进行区分整包消息；

客户端输出

测试1

执行 TestClientController.http

### 10 验证 粘包、拆包  特殊字符作为分隔符来区分整包消息；
GET http://localhost:8080/app/netty/delimiter1

@GetMapping("/app/netty/delimiter1")
public String testDelimiter1() throws InterruptedException {
    // 有一个分割符，服务端收到一条消息
    ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
    String s = "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;" +
            "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;78B987";
    channelFuture.channel().writeAndFlush(s);
    Thread.sleep(1000);
    nettyClient.disconnect(channelFuture.channel());
    return "发送成功";
}

输出，服务端输出一条数据，因为客户端发送的时候只有一个分割符，且收到的消息删除分割符

测试2

执行 TestClientController.http

### 11 验证 粘包、拆包  特殊字符作为分隔符来区分整包消息；
GET http://localhost:8080/app/netty/delimiter2

@GetMapping("/app/netty/delimiter2")
public String testDelimiter2() throws InterruptedException {
    // 有两个分割符，服务端收到两条消息
    ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
    String s = "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;78B987" +
            "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;78B987";
    channelFuture.channel().writeAndFlush(s);
    Thread.sleep(1000);
    nettyClient.disconnect(channelFuture.channel());
    return "发送成功";
}

输出，因为是两个分割符 78B987,客户端发送了一次，服务端接收了两次

FixedLength

FixedLengthFrameDecoder 固定长度，如果长度不够，则服务端收不到消息，如果需要能够收到消息，则需要通过手动补空格，将长度补齐；

如果一次发送的长度超过设置的长度，则需要是设置长度的倍数，否则，收到的数据会产生乱码；

一般使用此策略的场景是发送消息的长度是固定的，如果不固定，不建议使用。

客户端

客户端配置

package com.example.netty.fixlength.client;

import com.example.netty.common.client.ClientHeartBeatServerHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.FixedLengthFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:06
 **/
@SuppressWarnings("all")
public class FixLengthClientInitializer extends ChannelInitializer<SocketChannel> {
    private static final String DECODER = "decoder";
    private static final String ENCODER = "encoder";
    private static final String PING = "ping";

    /**
     * 为读超时时间（即多长时间没有接受到客户端发送数据）
     */
    private final long readerIdleTime = 0;
    /**
     * 为写超时时间（即多长时间没有向客户端发送数据）
     */
    private final long writerIdleTime = 0;
    /**
     * 所有类型（读或写）的超时时间
     */
    private final long allIdleTime = 0;

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline().addLast(new ClientHeartBeatServerHandler())
                .addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.SECONDS))
                // 固定 长度， 每一包消息长度必须是 37 字节，只有达到 37 时才会被接收
//                所有的消息，必须是 37 的倍数，不然会截断产生乱码
//                FixLengthServerHandler channelRead 给客户端发送消息
                .addLast(new FixedLengthFrameDecoder(37))
                .addLast(ENCODER, new StringEncoder())
                .addLast(DECODER, new StringDecoder())
                .addLast(new FixLengthClientHandler())
        ;
    }
}

客户端Handler

package com.example.netty.fixlength.client;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.charset.StandardCharsets;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:41
 **/
public class FixLengthClientHandler extends ChannelInboundHandlerAdapter {
    private static final Logger logger = LoggerFactory.getLogger(FixLengthClientHandler.class);

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.info("接收到服务端的响应");
        String body = (String) msg;
        System.out.println("-----client start------| \n " + body + " \n| ------client end------");
    }
}

服务端

服务端配置

package com.example.netty.fixlength.server;

import com.example.netty.common.server.ConnectionCountHandler;
import com.example.netty.common.server.ServerHeartBeatServerHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.FixedLengthFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:04
 **/
@SuppressWarnings("all")
public class FixLengthServerInitializer extends ChannelInitializer<SocketChannel> {
    private static final String ENCODER = "encoder";
    private static final String DECODER = "decoder";

    /**
     * 为读超时时间（即多长时间没有接受到客户端发送数据）
     */
    private final long readerIdleTime = 0;
    /**
     * 为写超时时间（即多长时间没有向客户端发送数据）
     */
    private final long writerIdleTime = 0;
    /**
     * 所有类型（读或写）的超时时间
     */
    private final long allIdleTime = 0;

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline().addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.SECONDS))
                // 固定 长度， 每一包消息长度必须是 64 字节，只有达到 64 时才会被接收
//                所有的消息，必须是 64 的倍数，不然会截断产生乱码，
//                发送的时候   TestClientController.testFixLength0  需要发送 32 字节
                .addLast(new FixedLengthFrameDecoder(32))
                .addLast(ENCODER, new StringEncoder())
                .addLast(DECODER, new StringDecoder())
                .addLast(new ConnectionCountHandler())
                .addLast(new FixLengthServerHandler())
                .addLast(new ServerHeartBeatServerHandler())

        ;

    }
}

服务端Handler

package com.example.netty.fixlength.server;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.charset.StandardCharsets;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:39
 **/
public class FixLengthServerHandler extends ChannelInboundHandlerAdapter {

    private static final Logger logger = LoggerFactory.getLogger(FixLengthServerHandler.class);


    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.debug("收到客户端消息");
        try {
            String body = (String) msg;
            System.out.println("-----server start------| \n " + body + " \n| ------server end------");
            // 此处  我是服务端给客户端的消息;  字节长度是 37； FixLengthClientInitializer FixedLengthFrameDecoder 配置的是 37,因此客户端收到 两条数据
            ctx.channel().writeAndFlush("我是服务端给客户端的消息;我是服务端给客户端的消息;");
        } catch (Exception e) {
            logger.error("接收数据异常", e);
        }
    }


    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

    public static void main(String[] args) {
        System.out.println("我是服务端给客户端的消息;".getBytes(StandardCharsets.UTF_8).length);
    }
}

测试0

执行 TestClientController.http

### 12 验证 粘包、拆包 固定长度解决方案
GET http://localhost:8080/app/netty/fixLength0

@GetMapping("/app/netty/fixLength0")
public String testFixLength0() throws InterruptedException {
    ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
    // 此处是字节长度为 32,如果不够  32 则本次发送的消息收不到会暂存到缓存中，等凑够 32 才会监听到消息
    // 固定长度，如果长度不够且需要收到消息，通过补空格实现
    // 固定长度，如果 超过 32 则只会 收 32 长度的数据，剩余的不够 32 的暂存到缓存中，等凑够 32 才会监听到消息
    // 建议 发送的消息为 设置长度 32 的倍数，否则会将字节截断产生乱码
    // 一个汉字 3 个字节，一个, ;一个字节
    String s = "一岁一枯荣,野火烧不尽;";
    channelFuture.channel().writeAndFlush(s);
    Thread.sleep(1000);
    nettyClient.disconnect(channelFuture.channel());
    return "发送成功";
}

服务端输出

客户端输出

测试1

执行 TestClientController.http

### 13 验证 粘包、拆包 固定长度解决方案
GET http://localhost:8080/app/netty/fixLength1

@GetMapping("/app/netty/fixLength1")
public String testFixLength1() throws InterruptedException {
    ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
    // 此处是字节长度为 32,如果不够  32 则本次发送的消息收不到会暂存到缓存中，等凑够 32 才会监听到消息
    // 固定长度，如果长度不够且需要收到消息，通过补空格实现
    // 固定长度，如果 超过 32 则只会 收 32 长度的数据，剩余的不够 32 的暂存到缓存中，等凑够 32 才会监听到消息
    // 建议 发送的消息为 设置长度 32 的倍数，否则会将字节截断产生乱码
    // 一个汉字 3 个字节，一个, ;一个字节
    // 服务端 只能收到 一岁一枯荣,野火烧不尽;
    // 一岁一枯 需要等下一次发送的时候 凑够 32 个字节才会收到
    String s = "一岁一枯荣,野火烧不尽;一岁一枯";
    channelFuture.channel().writeAndFlush(s);
    Thread.sleep(1000);
    s = "一岁一枯荣,野火烧不尽;一岁一枯";
    channelFuture.channel().writeAndFlush(s);
    Thread.sleep(1000);
    nettyClient.disconnect(channelFuture.channel());
    return "发送成功";
}

服务端输出

测试2

执行 TestClientController.http

### 14 验证 粘包、拆包 固定长度解决方案
GET http://localhost:8080/app/netty/fixLength2

@GetMapping("/app/netty/fixLength2")
public String testFixLength2() throws InterruptedException {
    ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
    // 此处是字节长度为 32,如果不够  32 则本次发送的消息收不到会暂存到缓存中，等凑够 32 才会监听到消息
    // 固定长度，如果长度不够且需要收到消息，通过补空格实现
    // 固定长度，如果 超过 32 则只会 收 32 长度的数据，剩余的不够 32 的暂存到缓存中，等凑够 32 才会监听到消息
    // 建议 发送的消息为 设置长度 32 的倍数，否则会将字节截断产生乱码
    // 一个汉字 3 个字节，一个, ;一个字节
    // 服务端 只能收到 一岁一枯荣,野火烧不尽; 服务端收到  4 条消息
    //
    String s = "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;";
    channelFuture.channel().writeAndFlush(s);
    Thread.sleep(1000);
    s = "一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;";
    channelFuture.channel().writeAndFlush(s);
    Thread.sleep(1000);
    nettyClient.disconnect(channelFuture.channel());
    return "发送成功";
}

LengthFieldBase

LengthFieldBasedFrameDecoder 指定长度来标识整包消息，通过在包头指定整包长度来约定包长;

一般在我们自定义TCP协议的时候可以在包头部分设置整包数据的长度，根据整包数据的长度来校验是否收取到完整的包，此解码器属于常用模式。

LengthFieldPrepender 设置此参数默认会给数据包的头部加上当前数据包的长度；

LengthFieldBasedFrameDecoder参数说明

lengthFieldOffset 从头部开始需要偏移多少个字节，才是表示长度的字节所在的起始位，如我们定义的TCP协议里面，长度所在位置是从头部开始的第5个字节，则此处偏移量是 5；
lengthFieldLength 表示整包数据长度在 TCP 协议里面占用几个字节，一般 int 型占 4 个字节，short 型占用两个字节；byte 型占用1 个字节，long 型占用8 个字节；

注意设置数据包整体长度的时候不应该包含 lengthFieldLength 的长度;
lengthAdjustment. 建议此值的设置 + lengthFieldOffset =0 ,如 lengthFieldOffset =5 则此处设置为 -5
initialBytesToStrip 表示需要忽略的字节，但是此值的设置依赖lengthAdjustment 的设置；当lengthFieldOffset+lengthAdjustment =0 时，此值设置的是几则解析数据的时候会跳过几个字节；
byteOrder 解析长度的时候采用大端模式还是小端模式，默认采用大端；
failFast为true，当frame长度超过maxFrameLength时立即报TooLongFrameException异常，为false，读取完整个帧再报异常;

客户端

客户端配置

package com.example.netty.lengthfield.client;

import com.example.netty.common.client.ClientHeartBeatServerHandler;
import com.example.netty.common.utils.NettyConstants;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.bytes.ByteArrayEncoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;

import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:06
 **/
@SuppressWarnings("all")
public class LengthFieldClientInitializer extends ChannelInitializer<SocketChannel> {
    private static final String DECODER = "decoder";
    private static final String ENCODER = "encoder";
    private static final String PING = "ping";
    /**
     * 长度字段偏移位置为0表示从包的第一个字节开始读取；
     */
    private final int lengthFieldOffset = 0;
    /**
     * 长度字段长为2，从包的开始位置往后2个字节的长度为长度字段；
     */
    private final int lengthFieldLength = 4;
    /**
     * 解析的时候无需跳过任何长度；
     */
    private final int lengthAdjustment = 0;
    /**
     * 无需去掉当前数据包的开头字节数, header + body
     */
    private final int initialBytesToStrip = 4;
    /**
     * 如果failFast=true，当超过maxLength后会立刻抛出TooLongFrameException，不再进行解码；
     * 如果failFast=false，那么会等到解码出一个完整的消息后才会抛出TooLongFrameException
     */
    private final boolean failFast = false;
    /**
     * 为读超时时间（即多长时间没有接受到客户端发送数据）
     */
    private final long readerIdleTime = 0;
    /**
     * 为写超时时间（即多长时间没有向客户端发送数据）
     */
    private final long writerIdleTime = 0;
    /**
     * 所有类型（读或写）的超时时间
     */
    private final long allIdleTime = 0;

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline().addLast(new ClientHeartBeatServerHandler())
                .addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.SECONDS))
                // 优先判断最大长度
                // stripDelimiter:解码后的消息是否去除分隔符 不去掉分割符
                // failFast = false, 那么会等到解码出完整消息才会抛出 TooLongException。
                // 对应的是server 的发送的配置，默认给前端添加了 4个字节作为长度，
                // 因此，长度起始位是 从0 开始，长度所占的字节是4个，解析的时候 需要 跳过 4个字节，将添加的长度去掉
                .addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4,false))
                .addLast(ENCODER, new ByteArrayEncoder())
                .addLast(DECODER, new StringDecoder())
                .addLast(new LengthFieldClientHandler())
        ;
    }
}

客户端Handler

package com.example.netty.lengthfield.client;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:41
 **/
public class LengthFieldClientHandler extends ChannelInboundHandlerAdapter {
    private static final Logger logger = LoggerFactory.getLogger(LengthFieldClientHandler.class);

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.info("接收到服务端的响应");
        String body = (String) msg;

        System.out.println("-----client start------| \n " + body + " \n| ------client end------");
    }
}

服务端

服务端配置

package com.example.netty.lengthfield.server;

import com.example.netty.common.server.ConnectionCountHandler;
import com.example.netty.common.server.ServerHeartBeatServerHandler;
import com.example.netty.common.utils.NettyConstants;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.codec.bytes.ByteArrayDecoder;
import io.netty.handler.codec.bytes.ByteArrayEncoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;

import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:04
 **/
@SuppressWarnings("all")
public class LengthFieldServerInitializer extends ChannelInitializer<SocketChannel> {
    private static final String ENCODER = "encoder";
    private static final String DECODER = "decoder";
    /**
     * 长度字段偏移位置为0表示从包的第一个字节开始读取；
     * 此处表示从头开始的第10个字节开始计算长度 长度域从第几个字节开始
     */
    private final int lengthFieldOffset = 5;
    /**
     * 长度字段长为4，从包的开始位置往后4个字节的长度为长度字段； 长度域占了几个字节
     */
    private final int lengthFieldLength = 4;
    /**
     * 解析时候跳过多少个长度；长度域的偏移补偿
     */
    private final int lengthAdjustment = -5;
    /**
     * 解码出一个数据包之后，跳过前面的几个字节
     */
    private final int initialBytesToStrip = 0;
    /**
     * 如果failFast=true，当超过maxLength后会立刻抛出TooLongFrameException，不再进行解码；
     * 如果failFast=false，那么会等到解码出一个完整的消息后才会抛出TooLongFrameException
     * 则表示读取到长度域，他的值的超过maxFrameLength，就抛出一个 TooLongFrameException，而为false表示只有当真正读取完长度域的值表示的字节之后，才会抛出 TooLongFrameException，默认情况下设置为true，建议不要修改，否则可能会造成内存溢出。
     */
    private final boolean failFast = false;
    /**
     * 为读超时时间（即多长时间没有接受到客户端发送数据）
     */
    private final long readerIdleTime = 0;
    /**
     * 为写超时时间（即多长时间没有向客户端发送数据）
     */
    private final long writerIdleTime = 0;
    /**
     * 所有类型（读或写）的超时时间
     */
    private final long allIdleTime = 0;

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline().addLast(new IdleStateHandler(readerIdleTime, writerIdleTime, allIdleTime, TimeUnit.SECONDS))
                // 优先判断最大长度
                // stripDelimiter:解码后的消息是否去除分隔符
                // failFast = false, 那么会等到解码出完整消息才会抛出 TooLongException。
//                ByteOrder.LITTLE_ENDIAN 解析长度的时候用小端
                .addLast(new LengthFieldBasedFrameDecoder(ByteOrder.LITTLE_ENDIAN, Integer.MAX_VALUE, lengthFieldOffset, lengthFieldLength, lengthAdjustment, initialBytesToStrip, failFast))
                // 给客户端发送的时候 会默认的给 头部加 4 个字节，加上 当前包的长度
                .addLast(new LengthFieldPrepender(4))
                .addLast(ENCODER, new StringEncoder())
                // 与发送端有关系
                // 接收端需要 转成何总格式，与 channelRead 相关，此处是将 ByteBuf 转成byte[]
                .addLast(DECODER, new ByteArrayDecoder())
                .addLast(new ConnectionCountHandler())
                .addLast(new LengthFieldServerHandler())
                .addLast(new ServerHeartBeatServerHandler())

        ;

    }
}

服务端Handler

package com.example.netty.lengthfield.server;

import cn.hutool.core.util.ByteUtil;
import com.example.netty.common.utils.ByteUtils;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;

/**
 * 
 *
 * @author xin
 * @version 2023/11/2 16:39
 **/
public class LengthFieldServerHandler extends ChannelInboundHandlerAdapter {

    private static final Logger logger = LoggerFactory.getLogger(LengthFieldServerHandler.class);


    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.debug("收到客户端消息");
        try {
//            ByteBuf buf = (ByteBuf) msg;
//            byte[] bytes = new byte[buf.readableBytes()];
//            buf.readBytes(bytes);
            byte[] bytes = (byte[]) msg;
            String body = new String(new byte[]{bytes[0], bytes[1], bytes[2], bytes[3], bytes[4]});
            body = body + ByteUtil.bytesToInt(new byte[]{bytes[5], bytes[6], bytes[7], bytes[8]});
            byte[] bodyBytes = new byte[bytes.length - 9];
            System.arraycopy(bytes, 9, bodyBytes, 0, bodyBytes.length);
            body = body + new String(bodyBytes);
            System.out.println("-----client start------| \n " + body + " \n| ------client end------");
            // 长度 5

            String sendMsg = "我是服务端给客户端的消息;";
            ctx.channel().writeAndFlush(sendMsg);
        } catch (Exception e) {
            logger.error("接收数据异常", e);
        }
    }


    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

测试

@GetMapping("/app/netty/lengthField0")
public String testLengthField0() throws InterruptedException {
    ChannelFuture channelFuture = nettyClient.connect("127.0.0.1", 9000);
    //长度 64
    byte[] sendMsgBytes = ("一岁一枯荣,野火烧不尽;一岁一枯荣,野火烧不尽;").getBytes(StandardCharsets.UTF_8);
    //长度 5
    byte[] headerBytes = "ABCDE".getBytes(StandardCharsets.UTF_8);

    int bodyLength = sendMsgBytes.length + headerBytes.length;
    byte[] bytes = {};
    //长度 5
    bytes = ByteUtils.append(bytes, headerBytes);
    //长度 4 ,设置总长度的时候 只进行 数据包长度的设置，不包含 当前长度域的长度
    bytes = ByteUtils.append(bytes, ByteUtil.intToBytes(bodyLength));
    //长度 64
    bytes = ByteUtils.append(bytes, sendMsgBytes);
    channelFuture.channel().writeAndFlush(bytes);
    Thread.sleep(1000);
    nettyClient.disconnect(channelFuture.channel());
    return "发送成功";
}

服务端输出

说明

客户端发送的时候，从第6个字节开始设置包体的长度，长度域所占字节为4，因此服务端接收时，LengthFieldBasedFrameDecoder 的配置如下：
- lengthFieldOffset = 5，头部偏移 5 个字节；
- lengthFieldLength = 4 ，长度域占用 4 个字节；
- lengthAdjustment = -5，偏移补偿设置为 -5；补偿头部的 5 个字节，这样解析的时候就会从第 0 个字节解析；此值建议按照相加等于0 来设置，如果不是这样，解析的数据会有问题。
- initialBytesToStrip = 0 ，跳过头部几个字节，此处没有跳过，因此输出的是完整的值

客户端输出

服务端给客户端发送消息

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.debug("收到客户端消息");
        try {
//            ByteBuf buf = (ByteBuf) msg;
//            byte[] bytes = new byte[buf.readableBytes()];
//            buf.readBytes(bytes);
            byte[] bytes = (byte[]) msg;
            String body = new String(new byte[]{bytes[0], bytes[1], bytes[2], bytes[3], bytes[4]});
            body = body + ByteUtil.bytesToInt(new byte[]{bytes[5], bytes[6], bytes[7], bytes[8]});
            byte[] bodyBytes = new byte[bytes.length - 9];
            System.arraycopy(bytes, 9, bodyBytes, 0, bodyBytes.length);
            body = body + new String(bodyBytes);
            System.out.println("-----client start------| \n " + body + " \n| ------client end------");
            // 长度 5

            // 服务端给客户端发送消息，以字符串 编码、解码方式
            String sendMsg = "我是服务端给客户端的消息;";
            ctx.channel().writeAndFlush(sendMsg);
        } catch (Exception e) {
            logger.error("接收数据异常", e);
        }
    }

服务端编码设置

客户端输出

说明

LengthFieldServerInitializer 设置 .addLast(new LengthFieldPrepender(4)) 表示在发送字符串时主动在头部加 4 个字节，表示当前数据包的长度；
LengthFieldClientInitializer 设置 LengthFieldBasedFrameDecoder 参数
- lengthFieldOffset = 0，默认在头部加长度，因此不需要偏移；
- lengthFieldLength = 4 ，长度域占用 4 个字节；
- lengthAdjustment = 0，此值建议按照 lengthFieldOffset+lengthAdjustment相加等于0 来设置，如果不是这样，解析的数据会有问题。
- initialBytesToStrip = 4 ，跳过头部几个字节，此处跳过长度字节

设置不跳过前4 个字节，直接打印输出，乱码：

解析显示长度

参考文档

https://www.cnblogs.com/rickiyang/p/12904552.html

https://www.cnblogs.com/caoweixiong/p/14666400.html

你可能感兴趣的:(java,java,netty)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
JAVA·一个简单的登录窗口 MortalTom java 开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
00. 这里整理了最全的爬虫框架（Java + Python）有一只柴犬爬虫系列爬虫 java python
目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
切换淘宝最新npm镜像源是 hai40587 npm 前端 node.js
切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java 开发语言
文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式 java
文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
rust的指针作为函数返回值是直接传递，还是先销毁后创建？ wudixiaotie 返回值
这是我自己想到的问题，结果去知呼提问，还没等别人回答，我自己就想到方法实验了。。 fn main() { let mut a = 34; println!("a's addr:{:p}", &a); let p = &mut a; println!("p's addr:{:p}", &a
java编程思想 -- 数据的初始化百合不是茶 java 数据的初始化
1.使用构造器确保数据初始化 /* *在ReckInitDemo类中创建Reck的对象 */ public class ReckInitDemo { public static void main(String[] args) { //创建Reck对象 new Reck(); } }
[航天与宇宙]为什么发射和回收航天器有档期 comsci
地球的大气层中有一个时空屏蔽层,这个层次会不定时的出现,如果该时空屏蔽层出现,那么将导致外层空间进入的任何物体被摧毁,而从地面发射到太空的飞船也将被摧毁... 所以,航天发射和飞船回收都需要等待这个时空屏蔽层消失之后,再进行 &
linux下批量替换文件内容商人shang linux 替换
1、网络上现成的资料　　格式: sed -i "s/查找字段/替换字段/g" `grep 查找字段 -rl 路径` 　　linux sed 批量替换多个文件中的字符串　　sed -i "s/oldstring/newstring/g" `grep oldstring -rl yourdir` 　　例如：替换/home下所有文件中的www.admi
网页在线天气预报 oloz 天气预报
网页在线调用天气预报 <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transit
SpringMVC和Struts2比较杨白白 springMVC
1. 入口 spring mvc的入口是servlet，而struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这样就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。参见：http://blog.csdn.net/zs15932616453/article/details/8832343 2
refuse copy, lazy girl! 小桔子 copy
妹妹坐船头啊啊啊啊！都打算一点点琢磨呢。文字编辑也写了基本功能了。。今天查资料，结果查到了人家写得完完整整的。我清楚的认识到： 1.那是我自己觉得写不出的高度 2.如果直接拿来用，很快就能解决问题 3.然后就是抄咩~~ 4.肿么可以这样子，都不想写了今儿个，留着作参考吧！拒绝大抄特抄，慢慢一点点写！
apache与php整合 aichenglong php apache web
一 apache web服务器 1 apeche web服务器的安装 1)下载Apache web服务器 2)配置域名(如果需要使用要在DNS上注册) 3)测试安装访问http://localhost/验证是否安装成功 2 apache管理 1)service.msc进行图形化管理 2)命令管理，配
Maven常用内置变量 AILIKES maven
Built-in properties ${basedir} represents the directory containing pom.xml ${version} equivalent to ${project.version} (deprecated: ${pom.version}) Pom/Project properties Al
java的类和对象百合不是茶 JAVA面向对象类对象
java中的类： java是面向对象的语言，解决问题的核心就是将问题看成是一个类，使用类来解决 java使用 class 类名来创建类，在Java中类名要求和构造方法，Java的文件名是一样的创建一个A类： class A{ } java中的类：将某两个事物有联系的属性包装在一个类中，再通
JS控制页面输入框为只读 bijian1013 JavaScript
在WEB应用开发当中，增、删除、改、查功能必不可少，为了减少以后维护的工作量，我们一般都只做一份页面，通过传入的参数控制其是新增、修改或者查看。而修改时需将待修改的信息从后台取到并显示出来，实际上就是查看的过程，唯一的区别是修改时，页面上所有的信息能修改，而查看页面上的信息不能修改。因此完全可以将其合并，但通过前端JS将查看页面的所有信息控制为只读，在信息量非常大时，就比较麻烦。
AngularJS与服务器交互 bijian1013 JavaScript AngularJS $http
对于AJAX应用（使用XMLHttpRequests）来说，向服务器发起请求的传统方式是：获取一个XMLHttpRequest对象的引用、发起请求、读取响应、检查状态码，最后处理服务端的响应。整个过程示例如下： var xmlhttp = new XMLHttpRequest(); xmlhttp.onreadystatechange
[Maven学习笔记八]Maven常用插件应用 bit1129 maven
常用插件及其用法位于：http://maven.apache.org/plugins/ 1. Jetty server plugin 2. Dependency copy plugin 3. Surefire Test plugin 4. Uber jar plugin 1. Jetty Pl
【Hive六】Hive用户自定义函数(UDF) bit1129 自定义函数
1. 什么是Hive UDF Hive是基于Hadoop中的MapReduce，提供HQL查询的数据仓库。Hive是一个很开放的系统，很多内容都支持用户定制，包括：文件格式：Text File，Sequence File 内存中的数据格式： Java Integer/String, Hadoop IntWritable/Text 用户提供的 map/reduce 脚本：不管什么
杀掉nginx进程后丢失nginx.pid，如何重新启动nginx ronin47 nginx 重启 pid丢失
nginx进程被意外关闭，使用nginx -s reload重启时报如下错误：nginx: [error] open() “/var/run/nginx.pid” failed (2: No such file or directory)这是因为nginx进程被杀死后pid丢失了，下一次再开启nginx -s reload时无法启动解决办法：nginx -s reload 只是用来告诉运行中的ng
UI设计中我们为什么需要设计动效 brotherlamp UI ui教程 ui视频 ui资料 ui自学
随着国际大品牌苹果和谷歌的引领，最近越来越多的国内公司开始关注动效设计了，越来越多的团队已经意识到动效在产品用户体验中的重要性了，更多的UI设计师们也开始投身动效设计领域。但是说到底，我们到底为什么需要动效设计？或者说我们到底需要什么样的动效？做动效设计也有段时间了，于是尝试用一些案例，从产品本身出发来说说我所思考的动效设计。一、加强体验舒适度嗯，就是让用户更加爽更加爽的用你的产品。
Spring中JdbcDaoSupport的DataSource注入问题 bylijinnan java spring
参考以下两篇文章： http://www.mkyong.com/spring/spring-jdbctemplate-jdbcdaosupport-examples/ http://stackoverflow.com/questions/4762229/spring-ldap-invoking-setter-methods-in-beans-configuration Sprin
数据库连接池的工作原理 chicony 数据库连接池
随着信息技术的高速发展与广泛应用，数据库技术在信息技术领域中的位置越来越重要，尤其是网络应用和电子商务的迅速发展，都需要数据库技术支持动态Web站点的运行，而传统的开发模式是：首先在主程序（如Servlet、Beans）中建立数据库连接；然后进行SQL操作，对数据库中的对象进行查询、修改和删除等操作；最后断开数据库连接。使用这种开发模式，对
java 关键字 CrazyMizzz java
关键字是事先定义的，有特别意义的标识符，有时又叫保留字。对于保留字，用户只能按照系统规定的方式使用，不能自行定义。 Java中的关键字按功能主要可以分为以下几类：（1）访问修饰符 public,private,protected p
Hive中的排序语法 daizj 排序 hive order by DISTRIBUTE BY sort by
Hive中的排序语法 2014.06.22 ORDER BY hive中的ORDER BY语句和关系数据库中的sql语法相似。他会对查询结果做全局排序，这意味着所有的数据会传送到一个Reduce任务上，这样会导致在大数量的情况下，花费大量时间。与数据库中 ORDER BY 的区别在于在hive.mapred.mode = strict模式下，必须指定 limit 否则执行会报错。
单态设计模式 dcj3sjt126com 设计模式
单例模式（Singleton）用于为一个类生成一个唯一的对象。最常用的地方是数据库连接。使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。 <?phpclass Example{ // 保存类实例在此属性中 private static&
svn locked dcj3sjt126com Lock
post-commit hook failed (exit code 1) with output: svn: E155004: Working copy 'D:\xx\xxx' locked svn: E200031: sqlite: attempt to write a readonly database svn: E200031: sqlite: attempt to write a
ARM寄存器学习 e200702084 数据结构 C++c C#F#
无论是学习哪一种处理器，首先需要明确的就是这种处理器的寄存器以及工作模式。 ARM有37个寄存器，其中31个通用寄存器，6个状态寄存器。 1、不分组寄存器（R0-R7）不分组也就是说说，在所有的处理器模式下指的都时同一物理寄存器。在异常中断造成处理器模式切换时，由于不同的处理器模式使用一个名字相同的物理寄存器，就是
常用编码资料 gengzg 编码
List<UserInfo> list=GetUserS.GetUserList(11); String json=JSON.toJSONString(list); HashMap<Object,Object> hs=new HashMap<Object, Object>(); for(int i=0;i<10;i++) {
进程 vs. 线程 hongtoushizi 线程 linux 进程
我们介绍了多进程和多线程，这是实现多任务最常用的两种方式。现在，我们来讨论一下这两种方式的优缺点。首先，要实现多任务，通常我们会设计Master-Worker模式，Master负责分配任务，Worker负责执行任务，因此，多任务环境下，通常是一个Master，多个Worker。如果用多进程实现Master-Worker，主进程就是Master，其他进程就是Worker。如果用多线程实现
Linux定时Job：crontab -e 与 /etc/crontab 的区别 Josh_Persistence linux crontab
一、linux中的crotab中的指定的时间只有5个部分：* * * * * 分别表示：分钟，小时，日，月，星期，具体说来：第一段代表分钟 0—59 第二段代表小时 0—23 第三段代表日期 1—31 第四段代表月份 1—12 第五段代表星期几，0代表星期日 0—6 如： */1 * * * * 每分钟执行一次。 *
KMP算法详解 hm4123660 数据结构 C++算法字符串 KMP
字符串模式匹配我们相信大家都有遇过，然而我们也习惯用简单匹配法（即Brute-Force算法)，其基本思路就是一个个逐一对比下去，这也是我们大家熟知的方法，然而这种算法的效率并不高，但利于理解。假设主串s="ababcabcacbab",模式串为t="
枚举类型的单例模式 zhb8015 单例模式
E.编写一个包含单个元素的枚举类型[极推荐]。代码如下： public enum MaYun {himself; //定义一个枚举的元素，就代表MaYun的一个实例private String anotherField;MaYun() {//MaYun诞生要做的事情//这个方法也可以去掉。将构造时候需要做的事情放在instance赋值的时候：/** himself = MaYun() {*
Kafka+Storm+HDFS ssydxa219 storm
cd /myhome/usr/stormbin/storm nimbus &bin/storm supervisor &bin/storm ui &Kafka+Storm+HDFS整合实践kafka_2.9.2-0.8.1.1.tgzapache-storm-0.9.2-incubating.tar.gzKafka安装配置我们使用3台机器搭建Kafk
Java获取本地服务器的IP 中华好儿孙 java Web 获取服务器ip地址
System.out.println("getRequestURL:"+request.getRequestURL()); System.out.println("getLocalAddr:"+request.getLocalAddr()); System.out.println("getLocalPort:&quo

netty基本用法， 拆包、粘包等常见解决方案，看本文即可，不做原理说明，只进行实战操作

netty的基本用法

示例的通用代码

客户端

服务端

测试

启动

ByteBuf

客户端

服务端

测试1

测试2

Byte 模式

客户端

服务端

测试

String 模式

客户端

服务端

测试

拆包、粘包复现

客户端

服务端

测试

解决拆包粘包方案

LineBased

客户端

服务端

测试0

测试1

测试2

DelimiterBased

客户端

服务端

测试0

测试1

测试2

FixedLength

客户端

服务端

测试0

测试1

测试2

LengthFieldBase

客户端

服务端

测试

参考文档

你可能感兴趣的:(java,java,netty)

netty基本用法，拆包、粘包等常见解决方案，看本文即可，不做原理说明，只进行实战操作