什么是NIO，什么是Netty

NIO与Netty的简介

NIO和Netty是两个常用的Java网络编程框架，它们都可以实现高性能、高并发、高可扩展的网络应用。本文将简单介绍它们的概念、特点和区别，并给出一些示例和插图。

NIO

NIO（New Input/Output）是Java 1.4引入的一套新的IO API，它提供了非阻塞式的、基于缓冲区的、面向通道的IO操作。NIO可以让程序员更灵活地控制数据的读写，提高了IO效率和吞吐量。

NIO主要包含以下几个核心组件：

• Channel（通道）：类似于传统IO中的流，但是可以双向读写，支持异步操作，可以从通道中读取数据到缓冲区，也可以从缓冲区写入数据到通道。
• Buffer（缓冲区）：是一个容器对象，用于存储数据，提供了一系列方法来操作数据。NIO中所有数据都是通过缓冲区进行传输的。
• Selector（选择器）：是一个多路复用器，可以同时监控多个通道的事件（如连接、读、写），并根据事件进行相应的处理。通过使用选择器，可以实现单线程或少量线程处理多个通道的模式，避免了线程上下文切换的开销。

下图展示了NIO的基本架构：

下面是一个使用NIO实现的简单的Echo服务器的示例代码：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

public class NIOServer {
    public static void main(String[] args) throws IOException {
        // 创建一个ServerSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 绑定端口
        serverSocketChannel.bind(new InetSocketAddress(8888));
        // 设置为非阻塞模式
        serverSocketChannel.configureBlocking(false);
        // 创建一个Selector
        Selector selector = Selector.open();
        // 将ServerSocketChannel注册到Selector，并监听ACCEPT事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        // 循环处理事件
        while (true) {
            // 阻塞等待事件发生
            int readyChannels = selector.select();
            if (readyChannels == 0) continue;
            // 获取发生事件的SelectionKey集合
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                // 处理ACCEPT事件
                if (key.isAcceptable()) {
                    // 获取客户端连接
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    // 设置为非阻塞模式
                    socketChannel.configureBlocking(false);
                    // 将SocketChannel注册到Selector，并监听READ事件，并附加一个缓冲区
                    socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                }
                // 处理READ事件
                if (key.isReadable()) {
                    // 获取SocketChannel和缓冲区
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = (ByteBuffer) key.attachment();
                    // 从通道读取数据到缓冲区
                    int len = socketChannel.read(buffer);
                    if (len > 0) {
                        // 切换缓冲区为读模式
                        buffer.flip();
                        // 打印收到的数据
                        System.out.println("Server received: " + new String(buffer.array(), 0, len));
                        // 将数据写回客户端
                        socketChannel.write(buffer);
                        // 清空缓冲区
                        buffer.clear();
                    } else if (len == -1) {
                        // 客户端断开连接，关闭通道
                        socketChannel.close();
                    }
                }
                // 移除已处理的SelectionKey
                iterator.remove();
            }
        }
    }
}

Netty

Netty是一个基于NIO的网络应用框架，它对NIO的API进行了封装和抽象，提供了更高层次的、更易用的、更灵活的网络编程接口。Netty可以帮助开发者快速地开发出高性能、高可靠性的网络应用，如RPC、IM、游戏、物联网等。

Netty主要包含以下几个核心组件：

• Channel（通道）：与NIO中的通道类似，但是提供了更多的操作，如读写、关闭、刷新等。
• ChannelHandler（通道处理器）：用于处理通道中的事件和数据，可以实现各种业务逻辑和协议编解码。
• ChannelPipeline（通道管道）：是一个包含多个ChannelHandler的链式结构，用于处理通道中的入站和出站事件和数据。
• EventLoop（事件循环）：是一个负责处理通道中的事件和任务的线程或线程组，一个EventLoop可以处理多个通道，一个通道只能绑定到一个EventLoop。
• Bootstrap（引导）：是一个用于配置和启动客户端或服务器端的辅助类，可以设置通道类型、事件循环、管道、选项等。

下图展示了Netty的基本架构：

下面是一个使用Netty实现的简单的Echo服务器的示例代码：

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class NettyServer {
    public static void main(String[] args) throws InterruptedException {
        // 创建两个EventLoopGroup，分别用于处理服务器端接受客户端连接的线程组和进行网络读写操作的线程组
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            // 创建一个ServerBootstrap
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            // 设置使用的EventLoopGroup
            serverBootstrap.group(bossGroup, workerGroup)
                    // 设置要被实例化的为NioServerSocketChannel类
                    .channel(NioServerSocketChannel.class)
                    // 设置NioServerSocketChannel的处理器
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            System.out.println("Server is ready...");
                        }
                    })
                    // 设置连入服务端的client的SocketChannel的处理器
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            // 添加一个简单的EchoServerHandler到管道中
                            ch.pipeline().addLast(new EchoServerHandler());
                        }
                    });
            // 绑定端口，并同步等待成功，即启动服务端
            ChannelFuture channelFuture = serverBootstrap.bind(8888).sync();
            // 监听服务端关闭，并阻塞等待
            channelFuture.channel().closeFuture().sync();
        } finally {
            // 优雅关闭两个EventLoopGroup对象
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    // 自定义一个EchoServerHandler类，继承自SimpleChannelInboundHandler类
    static class EchoServerHandler extends SimpleChannelInboundHandler<ByteBuf> {
    // 重写channelRead0方法，每当从客户端收到新的数据时，这个方法会在收到消息时被调用
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
            // 打印收到的数据
            System.out.println("Server received: " + msg.toString());
            // 将数据写回客户端
            ctx.writeAndFlush(msg);
        }

        // 重写exceptionCaught方法，发生异常时，打印异常，并关闭通道
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            cause.printStackTrace();
            ctx.close();
        }

        // 重写channelActive方法，通道激活时，打印客户端地址
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            System.out.println("Client connected: " + ctx.channel().remoteAddress());
        }

        // 重写channelInactive方法，通道失效时，打印客户端地址
        @Override
        public void channelInactive(ChannelHandlerContext ctx) throws Exception {
            System.out.println("Client disconnected: " + ctx.channel().remoteAddress());
        }
    }
}

NIO与Netty的区别

NIO和Netty都是基于非阻塞IO模型的网络编程框架，但是Netty相比NIO有以下几个优势：

• Netty提供了更高层次的抽象和封装，使得开发者可以更方便地使用NIO的功能，而不需要关心底层的细节。
• Netty提供了更丰富的功能和组件，如协议编解码、心跳检测、安全传输、零拷贝等，可以满足各种复杂的网络应用场景。
• Netty提供了更好的性能和稳定性，通过优化线程模型、缓冲区管理、资源回收等，可以减少资源消耗和内存泄漏，提高吞吐量和响应速度。

总之，Netty是一个基于NIO的高性能、高可靠性的网络应用框架，可以帮助开发者快速地开发出高质量的网络应用。

总结

本文简单介绍了NIO和Netty的概念、特点和区别，并给出了一些示例和插图。希望对你有所帮助。如果你想了解更多关于NIO和Netty的内容，可以参考以下资料：

• Java NIO Tutorial
• Netty User Guide
• Netty in Action