netty 学习笔记一：感受 IO编程 NIO编程 与 Netty 编程

代码和注释：https://github.com/christmad/code-share/tree/master/share-netty/src/main/java/code.share.netty

（1）IO编程模式

 IO server端代码：

public void IOserver() throws IOException {
        // IO模型-服务端监听端口
        ServerSocket server = new ServerSocket(8000);

        new Thread(() -> {
            while (true) {
                try {
                    // (1) 阻塞方式获取新连接
                    Socket socket = server.accept();

                    // (2) 将新连接绑定到一条新线程上去处理
                    new Thread(() -> {
                        try {
                            int len;
                            byte[] data = new byte[1024];
                            InputStream input = socket.getInputStream();
                            // (3) 按字节流方式读取数据
                            while ((len = input.read(data)) != -1) {
                                System.out.println(new String(data, 0, len));
                            }
                        } catch (IOException e) {
                        }
                    }).start();
                } catch (IOException ex) {
                }
            }
        }).start();
    }

由上我们可用看出 IO server端编码三要素：

　　1. 阻塞方式获取新连接

　　2. 将新连接绑定到一条新线程上处理

　　3. 按字节流方式读取数据

IO client端代码：

public void IOclient() {
        new Thread(() -> {
            try {
                // IO模型-客户端连接服务器
                Socket socket = new Socket("localhost", 8000);
                while (true) {
                    try {
                        // 每隔 2s 向服务器发送一条信息
                        socket.getOutputStream().write((new Date() + " : hello").getBytes());
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                    }
                }
            } catch (IOException e) {
            }

        }).start();

    }

（2）NIO编程模式

 NIO server端代码：

public void NIOserver() throws IOException {
        // throw ex
        // 创建 selector：NIO模型中通常会有两个线程，每个线程绑定一个轮询器 selector
        Selector serverSelector = Selector.open();      // serverSelector 负责轮询是否有新的连接
        Selector clientSelector = Selector.open();      // clientSelector 负责轮询连接是否有数据可读

        // 模拟服务端接收新连接，demo中只用一条线程去处理
        new Thread(() -> {
            try {
                // NIO服务端启动
                ServerSocketChannel listenerChannel = ServerSocketChannel.open();
                // 在 bind 的时候底层已经开始监听了，windows 1.8 JDK 默认实现 backlog=50，即最多允许50条全连接
                listenerChannel.socket().bind(new InetSocketAddress(8000));
                listenerChannel.configureBlocking(false);   // non-blocking

                // ServerSocketChannel#register 函数是将与操作系统交互（I/O）的工作交给持有 serverSelector，
                // 持有 serverSelector 对象的线程在 while 循环中处理新连接：Selector.select() 函数会获得操作系统层面做好三次握手的客户端连接，一次可获得批量
                //      实际开发中可能是多条线程来共同负责处理一大批连接，即 1个serverSelector、多个clientSelector。如果可以对同一个端口多次 bind 的话，有可能多个 serverSelector？
                // 注意：register 方法是来自 ServerSocketChannel，这个方法的作用是让 selector 获得 channel 的引用。
                //      操作系统底层处理的经过三次握手的连接应该是体现在 Channel 上，channel 负责存储网络数据，而 Selector 负责数据操作

                // SelectionKey.OP_ACCEPT 指明 serverSelector 要监听的是新连接
                listenerChannel.register(serverSelector, SelectionKey.OP_ACCEPT);

                while (true) {
                    // 整个 while 循环处理的是将 serverSelector#select 获取到的连接事件绑定到 clientSelector 上，由它来监听这些连接的 SelectionKey.OP_READ 事件

                    // 等待新连接，阻塞时间为 1ms
                    if (serverSelector.select(1) > 0) {
                        Set<SelectionKey> acceptIdSet = serverSelector.selectedKeys();
                        Iterator<SelectionKey> acceptIdItor = acceptIdSet.iterator();
                        while (acceptIdItor.hasNext()) {
                            SelectionKey key = acceptIdItor.next();

                            if (key.isAcceptable()) {
                                // 客户端连接经过三次握手进来后，我们需要处理客户端连接的事件：读或写
                                // 本例中模拟的是监听连接的可读事件——请求
                                try {
                                    // 通过 ServerSocketChannel#accept 函数获取 SocketChannel
                                    // 底层原理是客户端请求和上面绑定的 8000 端口连接，三次握手后，操作系统会启用另一个端口来标识这条连接，
                                    // 这条新连接在 NIO API 上反应出来就是一个 SocketChannel 对象，我们将这个对象注册到 clientSelector 以达到统一管理客户端连接读事件的目的
                                    SocketChannel clientChannel = ((ServerSocketChannel) key.channel()).accept();
                                    clientChannel.configureBlocking(false);
                                    // 调用 SocketChannel#register 函数，表示 clientSelector 将会关注 channel 的可读事件；一旦对应的 channel 标志位变化，就可以进行下一步操作
                                    clientChannel.register(clientSelector, SelectionKey.OP_READ);
                                } finally {
                                    // 只是在本轮的 Selector#selectedKeys 中移除了，可能是帮助清空此次 Selector#selectedKeys 产生的临时 Set<SelectionKey> 空间
                                    acceptIdItor.remove();
                                }
                            }

                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();

        // 在上面的代码中，我们只是把连接注册到 clientSelector 中并监听它们的读事件，下面则是批量处理读事件的代码
        new Thread(() -> {
            while (true) {
                try {
                    // 批量轮询有哪些连接有数据可读，阻塞时间为 1ms
                    if (clientSelector.select(1) > 0) {
                        Set<SelectionKey> readIdSet = clientSelector.selectedKeys();
                        Iterator<SelectionKey> readIdItor = readIdSet.iterator();
                        while (readIdItor.hasNext()) {
                            SelectionKey key = readIdItor.next();

                            if (key.isReadable()) {
                                try {
                                    SocketChannel clientChannel = (SocketChannel) key.channel();
                                    ByteBuffer buf = ByteBuffer.allocate(1024); // 申请 1KB 缓冲区
                                    // NIO 读面向 buf, 将 clientChannel 数据缓存到 buf 对象中
                                    clientChannel.read(buf);
                                    buf.flip();
                                    System.out.println(Charset.defaultCharset().newDecoder().decode(buf).toString());
                                } finally {
                                    readIdItor.remove();
                                    // 暂时不知道有什么用
                                    key.interestOps(SelectionKey.OP_READ);
                                }

                            }
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();


    }

由上我们可以看出 NIO server端编码概念比较多：

　　Channel、Selector、SelectionKey、select逻辑、register逻辑、ByteBuffer缓冲区读写逻辑......特别是 ByteBuffer 里面那一套 flip、capacity、reset、mark 等操作缓冲游标的方法，稍不注意就会出错。如果开发者都是基础比较过硬的，那么可以封装一套更易用的代码出来，毕竟 Java 作为一门业务语言的优势在于快速开发，而不是每一样都需要注重到底层。而前面说的一套好的封装，netty 已经帮我们做好了，接下来我们会介绍 netty编程模式。

NIO client端代码：太繁琐，直接看下面 netty 如何实现 server、client 端编码吧

（3）Netty编程模式

netty server端代码：

public void nettyServer() {
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        NioEventLoopGroup boss = new NioEventLoopGroup();
        NioEventLoopGroup worker = new NioEventLoopGroup();

        serverBootstrap
                .group(boss, worker)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<NioSocketChannel>() {
                    @Override
                    protected void initChannel(NioSocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new StringDecoder());
                        ch.pipeline().addLast(new SimpleChannelInboundHandler<String>() {

                            @Override
                            protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
                                System.out.println(msg);
                            }
                        });
                    }
                });

        // 定义一个自动寻找端口绑定的方法，在预设端口被占用时比较灵活
        // windows 上 1000 端口是可以直接绑定成功的，linux 上据说 0-1023 都不能绑定，是预留端口
        int port = 1000;
        bind(serverBootstrap, port);
    }

    private void bind(ServerBootstrap serverBootstrap, int port) {
        serverBootstrap.bind(port).addListener(future -> {
            if (future.isSuccess()) {
                System.out.println("监听端口绑定成功，port=" + port);
            } else {
                System.out.println("监听端口绑定失败，port=" + port);
                System.out.println("尝试下一个端口, next port= " + (port + 1));
                bind(serverBootstrap, port + 1);
            }
        });
    }

netty client端代码：

public void nettyClient() {
        Bootstrap bootstrap = new Bootstrap();
        NioEventLoopGroup worker = new NioEventLoopGroup();

        bootstrap
                .group(worker)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<Channel>() {
                    @Override
                    protected void initChannel(Channel ch) throws Exception {
                        ch.pipeline().addLast(new StringEncoder());
                    }
                });

        Channel channel = bootstrap.connect("localhost", 8000).channel();

        while (true) {
            channel.writeAndFlush(new Date() + " : hello");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
            }
        }
    }

经过本节介绍，应该可以看到 netty 的封装已经比原生API优雅了不止一点点，各种分布式框架的网络模块大量应用 netty 作为第三方网络包也验证了 netty 的封装在性能方面绝对可以榨干你的 CPU 。下一篇将会分析 netty编程 server端、client端的一些基本要素。链接如下：https://www.cnblogs.com/christmad/p/11625674.html