netty 入门列子

TCP 粘包、半读、拆包

TCP 以流的方式进行数据传输，上层应用协议为了对消息进行区分，会有4种方式

1. 消息固定长度：累计读取的长度总和定长 LEN 的报文后，就认为读取到了一个完整消息：将计数器位置，重新开始读取下一个数据报
2. 回车换行符作为消息结束：一例如 FTP 协议，这种方式在文本协议中应用比较广泛
3. 特殊的分隔符作为消息结束标志：回车缓存之类的
4. 在消息头中定义长度字段来表示消息总长度

LineBasedFrameDecoder ： 回车换行

DelimiterBasedFrameDecoder: 自动完成以分隔符做结束标志的消息解码

FixedLengthFrameDecoder: 自动完成对定长消息的解码，解决TCP

Netty 入门列子

简单列子

        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>5.0.0.Alpha2</version>
        </dependency>

客户端

package demo_01;public class TimeClient {

    public void connect(int port , String host) throws InterruptedException {
        //配置客户端 NIO 线程组
        NioEventLoopGroup group = new NioEventLoopGroup();

        try {
            Bootstrap b = new Bootstrap();
            /*
            开始配置客户端链接
             */
            b.group(group)
                    .channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY,true)
                    .handler(new ChannelInitializer<SocketChannel>(){
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(new TimeClientHandler());
                        }
                    });
            //异步链接操作
            ChannelFuture f = b.connect(host, port).sync();
            //等待客户端关闭
            f.channel().closeFuture().sync();
        } finally {
            // 释放NIO 线程组
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        int port = 8081;
        if (args != null && args.length > 0) {
            try {
                port = Integer.valueOf(args[0]);
            }catch (NumberFormatException e) {}
        }
        new TimeClient().connect(port,"127.0.0.1");
    }
}

public class TimeClientHandler extends ChannelHandlerAdapter {

    private static final Logger logger = Logger.getLogger(TimeClientHandler.class.getName());

    private final ByteBuf firstMessage;

    public TimeClientHandler() {
        byte[] req = "QUERY TIME ORDER".getBytes();
        firstMessage = Unpooled.buffer(req.length);
        firstMessage.writeBytes(req);
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(firstMessage);
    }

    // 处理服务端 返回的消息
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        byte[] req = new byte[buf.readableBytes()];
        buf.readBytes(req);
        String body = new String(req, "UTF-8");
        System.out.println("Now is:"+ body);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        // 释放资源
        logger.warning("来自下游的异常 ："+ cause.getMessage());
        ctx.close();
    }
}

服务端

public class TimeService {

    public void bing(int port) throws Exception {
        //配置服务端 NIO
        /*
        NioEventLoopGroup 是一个线程组，
         */
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            /*
            ServerBootstrap 启动 nio 服务
             */
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .childHandler(new ChildChannelHandler());
            //绑定端口，同步等待成功
            ChannelFuture f = b.bind(port).sync();
            //等待服务端监听端口关闭 设置阻塞， main 会等待 io 结束
            f.channel().closeFuture().sync();
        }finally {
            //优雅的退出，释放线程池资源
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    private class ChildChannelHandler extends ChannelInitializer<SocketChannel>{
        @Override
        protected void initChannel(SocketChannel socketChannel) throws Exception {
            socketChannel.pipeline().addLast(new TimeServerHandler());
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8081;
        if (args != null && args.length > 0) {
            try {
                port = Integer.valueOf(args[0]);
            } catch (NumberFormatException e) {

            }
        }
        new TimeService().bing(port);
    }
}

public class TimeServerHandler extends ChannelHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        /*
         msg 转换成 ByteBuf 是byteBuffer 的加强类
         */
        ByteBuf buf = (ByteBuf) msg;
        /*
        获取缓冲区的可读字节
         */
        byte[] req = new byte[buf.readableBytes()];
        buf.readBytes(req);
        String body = new String(req, StandardCharsets.UTF_8);
        System.out.println(" time server 接收订单 "+ body);
        String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body)? new Date(System.currentTimeMillis()).toString()
                : "BAD ORDER";
        ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
        ctx.write(resp);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        /*
        flush 将消息发送队列中的消息写入 SocketChannel 中发送给对方。
        从性能角度考虑，为了防止平凡地唤醒Selector 进行消息发送，Netty的 write 方法并不直将消息写入 SocketChannel中，
        调用write 方法知识把待发消息放到缓冲数组中，在通过调用flush方法，将发送缓冲区中的消息写入SocketChannel
         */
        ctx.flush();
    }

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

结果

底部