Netty学习总结

最新推荐文章于 2022-08-09 17:51:57 发布
最新推荐文章于 2022-08-09 17:51:57 发布
阅读量227 收藏 1
点赞数
分类专栏： Java 文章标签： netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d578332749/article/details/100659353
版权

文章目录

概述

什么是Netty？

Netty是一个NIO客户端服务端框架，支持快速、简单地开发网络应用程序，可以迅速地构建起TCP和UDP服务程序。

为什么要使用Netty二不直接使用NIO？

以下摘自《Netty权威指南 第2版》

  1. NIO的类库和API繁杂，使用麻烦，需要熟练掌握Selector、ServerSocketChannel、SocketChannel、ByteBuffer等；
  2. 需要具备其它的额外技能做铺垫，例如熟悉Java多线程编程。这是因为NIO编程设计到Reactor模式，你必须对多线程和网络编程非常熟悉，才能编写出高质量的NIO程序；
  3. 可靠性能力补齐，工作量和难度都非常大。例如客户端面临重连、网络闪断、半包读写、失败缓存、网络拥塞和异常码流的处理等问题，NIO编程的特点是功能开发相对容易，但是可靠性能力补齐的工作量和难度都非常大；
  4. JDK NIO的bug，例如臭名昭著的epoll bug，它会导致Selector空轮询，最终导致CPU 100%。官方声称在JDK1.6版本的update8修复该问题，但是直到JDK 1.7版本该问题仍旧存在，只不过该bug发生概率降低了一些而已，它并没有得到根本性的解决。

由于上述原因，在大多数场景下，不建议直接使用JDK的NIO类库，除非你精通NIO编程或有特殊的需求。在绝大多数的业务场景中，我们可以使用NIO框架Netty来进行NIO编程，它既可以作为客户端也可以作为服务端，同时支持UDP和异步文件传输，功能非常强大。

API使用

使用Netty创建服务端程序

以下内容介绍了如何使用Netty提供的API构建一个基本的服务端程序。

一、主体代码

    private void bind(int port) {
        // 初始化两个线程租
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup childGroup = new NioEventLoopGroup();
        try {
            // ServerChannel的引导程序，为了使ServerChannel更加易用
            ServerBootstrap bootstrap = new ServerBootstrap();
            /* bossGroup与workerGroup是两个线程组，bossGroup用于接收客户端的请求，
                workerGroup用于处理接收到的SocketChannel的网络读写 */
            bootstrap.group(bossGroup, childGroup)
                    .channel(NioServerSocketChannel.class)// 设置需要启动的Channel实例
                    /* 设置NioServerSocketChannel的TCP参数，
                        backlog的解析请看这里 https://www.cnblogs.com/qiumingcheng/p/9492962.html */
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .childHandler(new ChildChannelHandler());// 设置处理接收到的请求的处理类
            ChannelFuture future = bootstrap.bind(port).sync();// 为ServerBootstrap绑定监听端口
            future.channel().closeFuture().sync();// 关闭NioServerSocketChannel
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放线程组
            bossGroup.shutdownGracefully();
            childGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        SimpleTimeServer server = new SimpleTimeServer();
        server.bind(8088);
    }

二、childHandler

ServerBootstrap的childHandler函数要求传入一个实现了io.netty.channel.ChannelHandler的实例，childHandler是提供给childGroup中的线程的时间回调，从名字也可以看出这一点，我们传入的是一个ChildChannelHandler实例，这是我们自己实现的一个类，它并不是一个直接处理SocketChannel的类，而是继承了ChannelInitializer，用来组织更多的实际的处理类。

ChildChannelHandler代码：

    /**
     * ServerBootstrap中的childGroup中接收到的ChildChannel的处理类，
     * 用于处理接收到的请求
     */
    private class ChildChannelHandler extends ChannelInitializer<SocketChannel> {

        @Override
        protected void initChannel(SocketChannel socketChannel) {
            /* 这里的SocketChannel是Netty提供的，pipeline是一个ChildHandler的list，
                即我们可以使用多个Handler对接收到的SocketChannel进行处理 */
            socketChannel.pipeline()
                    .addLast(new ActualHandler1(), new ActualHandler2());
        }
    }

三、ActualHandler

上面说到了，ChildChannelHandler其实只是一个用来组织实际处理类的聚合管理类，实际的处理类是代码中的ActualHandler1和ActualHandler2，我们看下一个ActualHandler应该怎样实现。

    private class ActualHandler extends ChannelHandlerAdapter {

        /**
         * 有新建连接创建时，会首先回调此函数
         *
         * @param ctx
         */
        @Override
        public void channelActive(ChannelHandlerContext ctx) {
            System.out.println("有新建连接创建");
        }

        /**
         * 读取接收到的ServerChannel中的数据
         *
         * @param ctx
         * @param msg
         */
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) {
            ByteBuf reqBuf = (ByteBuf) msg;
            byte[] bytes = new byte[reqBuf.readableBytes()];
            reqBuf.readBytes(bytes);
            String reqMsg = new String(bytes, StandardCharsets.UTF_8);
            System.out.println("接收到请求消息：" + reqMsg);
            ByteBuf respBuf = Unpooled.copiedBuffer("你好，我已经收到你的消息了".getBytes(StandardCharsets.UTF_8));
            ctx.write(respBuf);
        }

        /**
         * read完成后调用的函数，进行一些数据读取完毕后的操作
         *
         * @param ctx
         */
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) {
            System.out.println("读取完毕");
            ctx.flush();
        }

        /**
         * 出现异常时的回调函数
         *
         * @param ctx
         * @param cause
         */
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
            System.out.println("出异常了！");
            cause.printStackTrace();
            ctx.close();
        }
    }

解析：

ActualHandler就是真正用来处理接收到的SocketChannel的处理类，在这里我们可以进行消息的读写解码等等一些操作。

我们这里的ActualHandler继承了ChannelHandlerAdapter，ChannelHandlerAdapter继承了ChannelHandler，里面有很多各种各样的回调函数，可以根据自己的需求灵活选取。

使用Netty创建客户端程序

前面介绍了创建服务端程序的方法，客户端其实和服务端大同小异。

一、主体代码

    /**
     * 连接指定的远端服务，写法与Server端的bind类似
     *
     * @param host 远端服务ip
     * @param port 远端服务端口
     */
    public void connect(String host, int port) {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group).channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            ch.pipeline().addLast(new ActualHandler());
                        }
                    });
            // 发起异步连接操作
            ChannelFuture future = bootstrap.connect(host, port).sync();
            // 等待客户端链路关闭
            future.channel().closeFuture().sync();
        } catch (Throwable t) {
            t.printStackTrace();
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        new SimpleTimeClient().connect("localhost", 8088);
    }

二、handler

服务端设置的是childHandler，客户端需要设置handler，原理与服务端一致。

这里我们直接使用了匿名内部类来初始化ChannelInitializer实例。

三、ActualHandler

原理与服务端一致。

private class ActualHandler extends ChannelHandlerAdapter {
    /**
     * 当连接成功时，会回调此函数，我们可以在此函数中向服务端发送消息
     *
     * @param ctx
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
            byte[] reqMsg = "你好~".getBytes(StandardCharsets.UTF_8);
            ByteBuf buf = Unpooled.copiedBuffer(reqMsg);
            ctx.writeAndFlush(buf);
    }

    /**
     * 服务端回复消息时会回调此函数
     *
     * @param ctx
     * @param msg
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf buf = (ByteBuf) msg;
        byte[] bytes = new byte[buf.readableBytes()];
        buf.readBytes(bytes);
        String respMsg = new String(bytes, StandardCharsets.UTF_8);
        System.out.println("收到服务端的返回消息：" + respMsg);
        ctx.close();
    }

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

使用Netty解决粘包问题

在网络编程中，粘包问题是往往是无法回避的问题，通常我们处理粘包有以下几种方式：

  1. 使用特定标识字符作为结束符；
  2. 固定消息长度；
  3. 将消息分为消息头与消息体，在消息头中声明消息总长度；

以前我们需要手动实现拆包的代码，繁杂而枯燥，而Netty为我们提供了几种现成的拆包处理类，使用非常简便。

  1. LineBasedFrameDecoder；
  2. DelimiterBasedFrameDecoder；
  3. FixedLengthFrameDecoder，使用定长字节数作为消息长度进行拆包；

LineBasedFrameDecoder

LineBasedFrameDecoder使用换行符作为结束符进行拆包

使用方法：

  1. 在接收消息的一方的SocketChannel.pipeline中加入LineBasedFrameDecoder，构造器中参数为每行消息最大长度，如果达到最大长度仍未接收到换行符，则会抛出异常。

    socketChannel.pipeline().addLast(
    new LineBasedFrameDecoder(1024)
    , new StringDecoder()
    , new LineBasedTimeServerHandler());

    在LineBasedFrameDecoder后面我们还加入了StringDecoder，这个解码器很简单，就是将字节码转为字符串，这样我们收到的消息就不是ByteBuf，而直接是String了。

    @Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    String respMsg = (String) msg;// 接收到的直接是String
    System.out.println("当前的时间：" + respMsg);
    ctx.close();
}

  2. 在消息发送的地方加入换行符作为结尾

    byte[] msg = ("我是消息" + System.getProperty("line.separator"))
    .getBytes(StandardCharsets.UTF_8);

完成这两步，基于换行符拆包就搞定了，是不是炒鸡简单，节省了我们大量的拆包工作。

DelimiterBasedFrameDecoder

DelimiterBasedFrameDecoder允许我们使用指定字符作为结束符进行拆包，其实换行符就是一种特殊的指定字符，所以DelimiterBasedFrameDecoder的用法与LineBasedFrameDecoder的用法完全一致，只需要发送方将换行符变更为其它指定字符即可。

byte[] msg = ("我是消息" + "$")// 以$作为结束符
    .getBytes(StandardCharsets.UTF_8);

FixedLengthFrameDecoder

FixedLengthFrameDecoder可以让我们使用定长字节数来拆分消息。

  1. 消息接收方：

    socketChannel.pipeline()
    .addLast(
    new FixedLengthFrameDecoder(39)// frameLength是一个完整消息的byte数据长度
    , new StringDecoder()
    , new FixedLengthTimeServerHandler());

  2. 消息发送方只要按照约定的字节数长度来发送消息即可。

使用Netty编写的简单时间服务

下面的程序是基于Netty编写的简单的时间服务，有服务端和客户端程序，因为将最基础的基于字节数据的方式和三种解码器的方式都整合在了一起，所以代码比较长，建议将代码获取到IDE中进行阅读，代码中有必要的注释。

此程序存放于Gitee，仓库地址：https://gitee.com/imdongrui/study-repo.git

仓库中的ioserver和ioclient工程

服务端程序

package com.dongrui.study.ioserver.nettyserver;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.FixedLengthFrameDecoder;
import io.netty.handler.codec.LineBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;

import java.nio.charset.StandardCharsets;
import java.util.Date;

/**
 * 基于Netty实现的简单时间服务
 */
public class SimpleTimeServer {

    private int counter = 0;

    private String[] modes = {"simple", "lineBased", "delimiterBased", "fixedLength"};

    private String mode = modes[3];

    /**
     * 初始化ServerBootstrap，并绑定指定的端口
     *
     * @param port 需要监听的端口
     */
    private void bind(int port) {
        // 初始化两个线程租
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            // ServerChannel的引导程序，为了使ServerChannel更加易用
            ServerBootstrap bootstrap = new ServerBootstrap();
            /* bossGroup与workerGroup是两个线程组，bossGroup用于接收客户端的请求，
                workerGroup用于处理接收到的SocketChannel的网络读写 */
            bootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)// 设置需要启动的Channel实例
                    /* 设置NioServerSocketChannel的TCP参数，
                        backlog的解析请看这里 https://www.cnblogs.com/qiumingcheng/p/9492962.html */
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .childHandler(new ChildChannelHandler());// 设置处理接收到的请求的处理类
            ChannelFuture future = bootstrap.bind(port).sync();// 为ServerBootstrap绑定监听端口
            future.channel().closeFuture().sync();// 关闭NioServerSocketChannel
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放线程组
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    /**
     * ServerBootstrap中的childGroup中接收到的ChildChannel的处理类，
     * 用于处理接收到的请求
     */
    private class ChildChannelHandler extends ChannelInitializer<SocketChannel> {

        @Override
        protected void initChannel(SocketChannel socketChannel) {
            /* 这里的SocketChannel是Netty提供的，pipeline是一个ChildHandler的list，
                即我们可以使用多个Handler对接收到的SocketChannel进行处理 */
            switch (mode) {
                case "simple":
                    socketChannel.pipeline()
                            .addLast(new SimpleTimeServerHandler());
                    break;
                case "lineBased":
                    socketChannel.pipeline()
                            // 使用LineBasedFrameDecoder可以以换行符为结束标识对消息进行拆分，构造器中参数为每行消息最大长度，如果达到最大长度仍未接收到换行符，则会抛出异常
                            .addLast(new LineBasedFrameDecoder(1024))
                            // StringDecoder可以将消息转码为String
                            .addLast(new StringDecoder())
                            .addLast(new LineBasedTimeServerHandler());
                    break;
                case "delimiterBased":
                    socketChannel.pipeline()
                            // 使用DelimiterBasedFrameDecoder可以以指定标识为结束标识对消息进行拆分
                            .addLast(new DelimiterBasedFrameDecoder(1024, Unpooled.copiedBuffer("$".getBytes(StandardCharsets.UTF_8))))
                            // StringDecoder可以将消息转码为String
                            .addLast(new StringDecoder())
                            .addLast(new DelimiterBasedTimeServerHandler());
                    break;
                case "fixedLength":
                    socketChannel.pipeline()
                            // frameLength是一个完整消息的byte数据长度
                            .addLast(new FixedLengthFrameDecoder(39))
                            .addLast(new StringDecoder())
                            .addLast(new FixedLengthTimeServerHandler());
                    break;
            }
        }
    }

    /**
     * 实际处理时间服务的Handler，不对消息进行行处理，即未解决粘包问题
     */
    private class SimpleTimeServerHandler extends ChannelHandlerAdapter {

        /**
         * 有新建连接创建时，会首先回调此函数
         *
         * @param ctx
         */
        @Override
        public void channelActive(ChannelHandlerContext ctx) {
            System.out.println("有新建连接创建");
        }

        /**
         * 读取接收到的ServerChannel中的数据
         *
         * @param ctx
         * @param msg
         */
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) {
            // 不使用LineBasedFrameDecoder和StringDecoder处理粘包时的写法，接收到的msg是ByteBuf
            ByteBuf reqBuf = (ByteBuf) msg;
            byte[] bytes = new byte[reqBuf.readableBytes()];
            reqBuf.readBytes(bytes);
            String reqMsg = new String(bytes, StandardCharsets.UTF_8);
            System.out.println("counter: " + ++counter);
            System.out.println("接收到请求消息：" + reqMsg);
            ByteBuf respBuf = Unpooled.copiedBuffer((new Date().getTime() + "").getBytes(StandardCharsets.UTF_8));
            ctx.write(respBuf);
        }

        /**
         * read完成后调用的函数，进行一些数据读取完毕后的操作
         *
         * @param ctx
         */
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) {
            System.out.println("读取完毕");
            ctx.flush();
        }

        /**
         * 出现异常时的回调函数
         *
         * @param ctx
         * @param cause
         */
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
            cause.printStackTrace();
            ctx.close();
        }

    }

    /**
     * 实际处理时间服务的Handler，对消息进行行处理以解决粘包问题
     */
    private class LineBasedTimeServerHandler extends ChannelHandlerAdapter {

        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            System.out.println("有新建连接");
        }

        /**
         * 读取接收到的ServerChannel中的数据
         *
         * @param ctx
         * @param msg
         */
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) {
            // 使用LineBasedFrameDecoder和StringDecoder处理粘包时的写法，接收到的msg是String
            String reqMsg = (String) msg;
            System.out.println("counter: " + ++counter);
            System.out.println("接收到请求消息：" + reqMsg);
            // 当服务端使用了LineBasedFrameDecoder，那么每条消息结尾需要加上line.separator，否则服务端消息读取无法完成
            ByteBuf respBuf = Unpooled.copiedBuffer((new Date().getTime() + System.getProperty("line.separator")).getBytes(StandardCharsets.UTF_8));
            ctx.write(respBuf);
        }

        /**
         * read完成后调用的函数，进行一些数据读取完毕后的操作
         *
         * @param ctx
         */
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) {
            System.out.println("读取完毕");
            ctx.flush();
        }

        /**
         * 出现异常时的回调函数
         *
         * @param ctx
         * @param cause
         */
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
            cause.printStackTrace();
            ctx.close();
        }

    }

    private class DelimiterBasedTimeServerHandler extends ChannelHandlerAdapter {
        /**
         * 读取接收到的ServerChannel中的数据
         *
         * @param ctx
         * @param msg
         */
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) {
            String reqMsg = (String) msg;
            System.out.println("counter: " + ++counter);
            System.out.println("接收到请求消息：" + reqMsg);
            ByteBuf respBuf = Unpooled.copiedBuffer((new Date().getTime() + "$").getBytes(StandardCharsets.UTF_8));
            ctx.write(respBuf);
        }

        /**
         * read完成后调用的函数，进行一些数据读取完毕后的操作
         *
         * @param ctx
         */
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) {
            System.out.println("读取完毕");
            ctx.flush();
        }

        /**
         * 出现异常时的回调函数
         *
         * @param ctx
         * @param cause
         */
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
            cause.printStackTrace();
            ctx.close();
        }
    }

    private class FixedLengthTimeServerHandler extends ChannelHandlerAdapter {
        /**
         * 读取接收到的ServerChannel中的数据
         *
         * @param ctx
         * @param msg
         */
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) {
            String reqMsg = (String) msg;
            System.out.println("counter: " + ++counter);
            System.out.println("接收到请求消息：" + reqMsg);
            ByteBuf respBuf = Unpooled.copiedBuffer((new Date().getTime() + "").getBytes(StandardCharsets.UTF_8));
            ctx.write(respBuf);
        }

        /**
         * read完成后调用的函数，进行一些数据读取完毕后的操作
         *
         * @param ctx
         */
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) {
            System.out.println("读取完毕");
            ctx.flush();
        }

        /**
         * 出现异常时的回调函数
         *
         * @param ctx
         * @param cause
         */
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
            cause.printStackTrace();
            ctx.close();
        }
    }

    public static void main(String[] args) {
        SimpleTimeServer server = new SimpleTimeServer();
        server.bind(8088);
    }
}

客户端程序

package com.dongrui.study.ioclient.nettyclient;

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.FixedLengthFrameDecoder;
import io.netty.handler.codec.LineBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;

import java.nio.charset.StandardCharsets;

public class SimpleTimeClient {

    private String[] modes = {"simple", "lineBased", "delimiterBased", "fixedLength"};

    private String mode = modes[3];

    /**
     * 连接指定的远端服务，写法与Server端的bind类似
     *
     * @param host 远端服务ip
     * @param port 远端服务端口
     */
    public void connect(String host, int port) {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group).channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            switch (mode) {
                                case "simple":
                                    ch.pipeline()
                                            .addLast(new SimpleTimeClientHandler());
                                    break;
                                case "lineBased":
                                    ch.pipeline()
                                            // 使用LineBasedFrameDecoder可以以换行符为结束标识对消息进行拆分，构造器中参数为每行消息最大长度，如果达到最大长度仍未接收到换行符，则会抛出异常
                                            .addLast(new LineBasedFrameDecoder(1024))
                                            // StringDecoder可以将消息转码为String
                                            .addLast(new StringDecoder())
                                            .addLast(new LineBasedTimeClientHandler());
                                    break;
                                case "delimiterBased":
                                    ch.pipeline()
                                            // 使用DelimiterBasedFrameDecoder可以以指定标识为结束标识对消息进行拆分
                                            .addLast(new DelimiterBasedFrameDecoder(1024, Unpooled.copiedBuffer("$".getBytes(StandardCharsets.UTF_8))))
                                            // StringDecoder可以将消息转码为String
                                            .addLast(new StringDecoder())
                                            .addLast(new DelimiterBasedTimeClientHandler());
                                    break;
                                case "fixedLength":
                                    ch.pipeline()
                                            .addLast(new FixedLengthFrameDecoder(13))
                                            .addLast(new StringDecoder())
                                            .addLast(new FixedLengthTimeClientHandler());
                                    break;
                            }
                        }
                    });
            // 发起异步连接操作
            ChannelFuture future = bootstrap.connect(host, port).sync();
            // 等待客户端链路关闭
            future.channel().closeFuture().sync();
        } catch (Throwable t) {
            t.printStackTrace();
            group.shutdownGracefully();
        }

    }

    private class SimpleTimeClientHandler extends ChannelHandlerAdapter {
        /**
         * 当连接成功时，会回调此函数，我们可以在此函数中向服务端发送消息
         *
         * @param ctx
         */
        @Override
        public void channelActive(ChannelHandlerContext ctx) {
            for (int i = 0; i < 100; i++) {
                byte[] reqMsg = ("快告诉我时间，不然干掉你！" + System.getProperty("line.separator")).getBytes(StandardCharsets.UTF_8);
                ByteBuf buf = Unpooled.copiedBuffer(reqMsg);
                ctx.writeAndFlush(buf);
            }
        }

        /**
         * 服务端回复消息时会回调此函数
         *
         * @param ctx
         * @param msg
         */
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) {
            ByteBuf buf = (ByteBuf) msg;
            byte[] bytes = new byte[buf.readableBytes()];
            buf.readBytes(bytes);
            String respMsg = new String(bytes, StandardCharsets.UTF_8);
            System.out.println("当前的时间：" + respMsg);
            ctx.close();
        }

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

    private class LineBasedTimeClientHandler extends ChannelHandlerAdapter {
        /**
         * 当连接成功时，会回调此函数，我们可以在此函数中向服务端发送消息
         *
         * @param ctx
         */
        @Override
        public void channelActive(ChannelHandlerContext ctx) {
            for (int i = 0; i < 100; i++) {
                // 当服务端使用了LineBasedFrameDecoder，那么每条消息结尾需要加上line.separator，否则服务端消息读取无法完成
                byte[] reqMsg = ("快告诉我时间，不然干掉你！" + System.getProperty("line.separator")).getBytes(StandardCharsets.UTF_8);
                ByteBuf buf = Unpooled.copiedBuffer(reqMsg);
                ctx.writeAndFlush(buf);
            }
        }

        /**
         * 服务端回复消息时会回调此函数
         *
         * @param ctx
         * @param msg
         */
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) {
            String respMsg = (String) msg;
            System.out.println("当前的时间：" + respMsg);
            ctx.close();
        }

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

    private class DelimiterBasedTimeClientHandler extends ChannelHandlerAdapter {
        /**
         * 当连接成功时，会回调此函数，我们可以在此函数中向服务端发送消息
         *
         * @param ctx
         */
        @Override
        public void channelActive(ChannelHandlerContext ctx) {
            for (int i = 0; i < 100; i++) {
                // 当服务端使用了LineBasedFrameDecoder，那么每条消息结尾需要加上line.separator，否则服务端消息读取无法完成
                byte[] reqMsg = ("快告诉我时间，不然干掉你！" + "$").getBytes(StandardCharsets.UTF_8);
                ByteBuf buf = Unpooled.copiedBuffer(reqMsg);
                ctx.writeAndFlush(buf);
            }
        }

        /**
         * 服务端回复消息时会回调此函数
         *
         * @param ctx
         * @param msg
         */
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) {
            String respMsg = (String) msg;
            System.out.println("当前的时间：" + respMsg);
            ctx.close();
        }

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

    private class FixedLengthTimeClientHandler extends ChannelHandlerAdapter {
        /**
         * 当连接成功时，会回调此函数，我们可以在此函数中向服务端发送消息
         *
         * @param ctx
         */
        @Override
        public void channelActive(ChannelHandlerContext ctx) {
            for (int i = 0; i < 100; i++) {
                // 当服务端使用了LineBasedFrameDecoder，那么每条消息结尾需要加上line.separator，否则服务端消息读取无法完成
                byte[] reqMsg = "快告诉我时间，不然干掉你！".getBytes(StandardCharsets.UTF_8);
                ByteBuf buf = Unpooled.copiedBuffer(reqMsg);
                ctx.writeAndFlush(buf);
            }
        }

        /**
         * 服务端回复消息时会回调此函数
         *
         * @param ctx
         * @param msg
         */
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) {
            String respMsg = (String) msg;
            System.out.println("当前的时间：" + respMsg);
            ctx.close();
        }

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

    public static void main(String[] args) {
        new SimpleTimeClient().connect("localhost", 8088);
    }
}
imdongrui
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
netty学习总结
Onepiece456的博客
12-27 341
一.netty基本概念： netty是一个异步的事件驱动的网络应用框架,支持快速地开发可维护的高性能的面向协议的服务器和客户端 1.可以作为一个rpc框架，2.作为一个长连接的服务器，3.作为一个http的服务器（类似于springmvc，struts2框架编写的web应用但是并没有实现一个servlet的规范） 二.基本使用: netty的一些基本代码实例，学习新技术需要成就感，因此要先...
Netty总结
不瘦十斤不换名字
10-27 233
a
Netty学习总结（一）
L2992786的博客
07-29 263
这里写自定义目录标题什么是NettyNetty的应用场景Netty的优点Netty的模型工作原理示意图及说明异步模型Netty的核心模块组件Bootstrap、ServerBootstrapFuture、ChannelFutureChannelSelectorChannelHandlerChannelPipeline 、PipelineChannelHandlerContextChannelOptionEventLoopGroupUnpooled图表Netty应用实例 什么是Netty Netty 是由 J
study_netty:netty代码学习总结
05-13
"study_netty:netty代码学习总结" 表明这是一个关于 Netty 框架的学习笔记或项目，可能包含作者对 Netty 源码的理解、使用经验和实践案例。描述中的 "netty代码学习总结" 进一步强调了这个项目是关于 Netty 代码的...
Netty学习笔记
01-20
Netty的总结 Netty定位: 1 .作为开源框架的底层框架(TCP通信) SpringBoot内置的容器（Tomcat/Jerry） Zookeper数据交换 Dubbo多协议RPC的支持 2、直接做服务器(消息推送服务，游戏后台) Netty如何确定要使用那些编码...
Netty全套学习资源（包括源码、笔记、学习文档等）
最新发布
04-19
学习笔记通常包含了作者在学习过程中的总结和实践经验，对于初学者来说极具参考价值。笔记可能涵盖 Netty 的安装配置、基本使用、线程模型、缓冲区操作、编解码器的实现以及异常处理等方面，帮助读者逐步建立起对 ...
Netty4.x学习总结
11-16
异步事件驱动的网络IO框架 Netty是什么，解决什么问题？ Netty 是一个利用 Java 的高级网络的能力，隐藏其背后的复杂性而提供一个灵活且易于使用的 API — 网络IO框架。
Netty学习路线总结
谷神通
11-09 3130
Netty学习路线总结 序 之前开过品味性能系列、Mysql学习系列，颇为曲高和寡。都是讲理论，很少有手把手深入浅出的文章。不过确实我就这脾气，文雅点的说法叫做“伪雅”，下里巴人叫做“装逼”。 学习资料 本篇文章，打算总结下学习过程，分析学习要点。 关于netty的资料颇多，学习起来未免杂乱。对于初学者麻烦点在于难以找到重点，再此则推荐一个学习路线。 Netty 实战(精髓) Ne...
2021大厂Java面试真题（Netty ）
ZJC'博客
01-23 442
2021大厂Java面试真题（Netty ） 1、为什么要用 Netty 呢？ 因为 Netty 具有下面这些优点，并且相比于直接使用 JDK 自带的 NIO 相关的 API 来说 更加易用。 统一的 API，支持多种传输类型，阻塞和非阻塞的。 简单而强大的线程模型。 自带编解码器解决 TCP 粘包/拆包问题。 自带各种协议栈。 真正的无连接数据包套接字支持。 比直接使用 Java 核心 API 有更高的吞吐量、更低的延迟、更低的资源消耗和更少的内存 复制。 安全性不错，有完
Netty学习知识点总结
Howinfun的博客
08-09 566
Netty知识点总结大全：包含I/O模型、Java NIO、Netty底层基础与原理
netty学习总结（一）
weixin_30391339的博客
05-20 81
netty是一个nio框架，将java的nio进行了一个封装，形成了一个高性能，高可用的网络编程框架，很多的框架都是基于netty的，所以学好netty是很有用的，而且netty本身的代码结构设计，以及一些思想都是十分优秀的，对我们的编程能起到一个很好的的帮助。 　　首先netty有几条主线分别是： 　　　　1.server端的启动 　　　　2.client端的启动 　　　　3.c...
netty框架学习总结（一）
qq_38597616的博客
09-20 133
netty概述 原始的NIO使用方式比较繁杂，针对功能不同有不同的使用类和方法(需要掌握selector、serversocketChannel、SocketChannel、ByteBuffer等)，与此同时需要考虑多线程情况和网络异常等因素，开发成本较大。jboss提供的netty可以帮助更快的开发一个网络应用，简化了原始nio处理的流程，是目前最流行的nio框架，很多框架的内部也有使用到netty，如dubbo。 ...
netty知识总结
u012391423的博客
07-26 867
目录 一、tcp & udp 二、tcp如何保证更可靠 1、确认应答和序列号 2、超时重传 3、流量控制 4、拥塞控制 三、滑动窗口 四、状态流转 五、粘包、拆包 MTU（Maximun Transmission Unit) MSS（Maximun Segment Size） 1、引起拆包、粘包的原因 2、tcp解决方案 3、netty解决方案 六、同步、异步、阻塞、非阻塞 七、网络IO模型 八、BIO、NIO、AIO 九、select 、poll 、
Netty通信
langxuanlovehai的专栏
05-21 1181
转自：http://www.paigu.com/a/396487/19195479.html Netty来袭——你不能不了解的企业高性能异步NIO通信首选... 微信原版阅读：1622014-06-12 博文视点Broadview 1．Netty是什么？ Netty是一个基于Java NIO类库的异步通信框架，它的架构特点是：异步
Netty入门与实战指南
该手册提供了Netty的基本概念和用法，帮助读者快速上手，并为进一步深入学习和应用Netty打下基础。 Netty的灵活性和性能使其在分布式系统、游戏服务器、RPC框架、Web应用等多个领域广泛应用。通过本手册，开发者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值