一、第一代：BIO（阻塞IO）——最简单，但痛点致命

1. 什么是BIO？

BIO（Blocking IO），也就是阻塞IO，是Java最基础、最原始的网络编程方式。它的核心特点是：一个连接对应一个线程，而且线程在等待客户端连接、等待数据读取/写入时，会一直阻塞，什么都不做。

举个通俗的例子：就像一个餐厅，每个服务员（线程）只负责一桌客人（客户端连接），客人不点单、不吃饭（不发数据），服务员就一直站在旁边等，啥也不干，不能去服务其他客人。

2. BIO极简Demo（Java代码）

下面是一个最简单的BIO服务器Demo，能接收客户端连接并读取消息，代码极简，重点看“阻塞”的体现：

import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; public class BioServer { public static void main(String[] args) throws IOException { // 1. 创建服务器Socket，绑定端口8888 ServerSocket serverSocket = new ServerSocket(8888); System.out.println("BIO服务器启动，等待客户端连接..."); while (true) { // 2. 阻塞等待客户端连接（关键：这里会一直等，直到有客户端连进来） Socket clientSocket = serverSocket.accept(); System.out.println("有客户端连接：" + clientSocket.getInetAddress()); // 3. 每个客户端连接，开启一个新线程处理（一个连接一个线程） new Thread(() -> { try { // 4. 读取客户端发送的数据（关键：没有数据时，这里也会阻塞） byte[] buffer = new byte[1024]; int len = clientSocket.getInputStream().read(buffer); if (len > 0) { System.out.println("收到客户端消息：" + new String(buffer, 0, len)); } // 关闭连接 clientSocket.close(); } catch (IOException e) { e.printStackTrace(); } }).start(); } } }

客户端Demo（简单测试用）：

import java.io.IOException; import java.net.Socket; import java.io.OutputStream; public class BioClient { public static void main(String[] args) throws IOException { // 连接服务器 Socket socket = new Socket("127.0.0.1", 8888); // 发送消息 OutputStream outputStream = socket.getOutputStream(); outputStream.write("Hello BIO".getBytes()); // 关闭连接 outputStream.close(); socket.close(); } }

3. BIO的核心痛点（为什么要迭代？）

BIO的代码简单，容易理解，但在高并发场景下完全不堪一击，核心痛点有3个：

• 资源浪费严重：一个连接一个线程，假设同时有1000个客户端连接，就需要1000个线程，线程的创建、销毁和切换成本极高，服务器内存会被快速耗尽；

• 阻塞导致效率极低：线程大部分时间都在“等待”（等连接、等数据），真正处理业务的时间很少，相当于“占着茅坑不拉屎”；

• 无法支撑高并发：面对万级、十万级的客户端连接，BIO会直接崩溃，根本无法应对（比如IM、游戏服务器等场景）。

正是这些痛点，催生了第二代网络编程技术——NIO。

二、第二代：NIO（非阻塞IO）——解决阻塞痛点，但使用复杂

1. 什么是NIO？

NIO（Non-Blocking IO），非阻塞IO，是Java 1.4引入的，核心目标是解决BIO的阻塞和资源浪费问题。它的核心特点是：一个线程可以管理多个客户端连接，线程不会一直阻塞，没有连接/数据时，会去处理其他任务，大大提升了资源利用率。

还是用餐厅的例子：一个服务员（线程）可以负责多桌客人（客户端连接），客人不点单时，服务员不会一直等，而是去服务其他客人；只有客人点单（有数据）时，服务员才过来处理。

NIO的核心三组件（不用记细节，知道作用即可）：

• Channel（通道）：相当于BIO的Socket，是数据传输的通道，支持非阻塞；

• Buffer（缓冲区）：数据的容器，读取/写入数据都必须通过缓冲区；

• Selector（选择器）：核心组件，一个Selector可以监听多个Channel的事件（连接、读、写），线程通过Selector判断哪个Channel有事件，再去处理。

2. NIO极简Demo（Java代码）

下面是NIO服务器Demo，重点看“一个线程管理多个连接”和“非阻塞”的体现（省略复杂异常处理，聚焦核心逻辑）：

import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.util.Iterator; public class NioServer { public static void main(String[] args) throws IOException { // 1. 创建Selector（选择器） Selector selector = Selector.open(); // 2. 创建服务器通道，绑定端口，设置为非阻塞 ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); serverSocketChannel.bind(new InetSocketAddress(8888)); serverSocketChannel.configureBlocking(false); // 3. 将服务器通道注册到Selector，监听“连接事件” serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); System.out.println("NIO服务器启动，等待客户端连接..."); while (true) { // 4. 阻塞等待事件（也可以设置超时时间，非永久阻塞） selector.select(); // 5. 获取所有有事件的通道（连接、读、写） Iterator<SelectionKey> iterator = selector.selectedKeys().iterator(); while (iterator.hasNext()) { SelectionKey key = iterator.next(); // 移除已处理的事件，避免重复处理 iterator.remove(); // 6. 处理连接事件（有客户端连接） if (key.isAcceptable()) { ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel(); // 接受客户端连接，设置为非阻塞 SocketChannel clientChannel = serverChannel.accept(); clientChannel.configureBlocking(false); // 将客户端通道注册到Selector，监听“读事件” clientChannel.register(selector, SelectionKey.OP_READ); System.out.println("有客户端连接：" + clientChannel.getInetAddress()); } // 7. 处理读事件（客户端发送数据） else if (key.isReadable()) { SocketChannel clientChannel = (SocketChannel) key.channel(); // 读取数据到缓冲区 ByteBuffer buffer = ByteBuffer.allocate(1024); int len = clientChannel.read(buffer); if (len > 0) { buffer.flip(); // 切换为读模式 System.out.println("收到客户端消息：" + new String(buffer.array(), 0, len)); } // 关闭通道 clientChannel.close(); } } } } }

客户端可以复用上面的BIO客户端Demo，发送消息即可测试。

3. NIO解决了BIO的痛点，但又带来了新问题

优势很明显：一个线程可以管理多个连接，不用创建大量线程，资源利用率大幅提升，能支撑更高的并发（万级连接），解决了BIO的阻塞和资源浪费问题。

但NIO的缺点也很突出，这也是它没有被广泛直接使用的原因：

• API复杂难用：NIO的三组件（Channel、Buffer、Selector）用法繁琐，还要处理缓冲区的flip()、rewind()等操作，容易出错；

• 存在原生BUG：比如著名的“NIO空轮询”问题（Selector.select()会一直返回0，导致线程空转，消耗CPU）；

• 需要自己处理很多细节：比如粘包拆包、断线重连、心跳检测等，这些都需要开发者自己实现，开发成本高、容易出问题；

• 多线程安全问题：Buffer是非线程安全的，多线程操作时需要自己加锁，增加了开发难度。

简单说：NIO解决了“能不能用”的问题（高并发场景），但没解决“好不好用”的问题。于是，Netty应运而生。

三、第三代：Netty——基于NIO，封装优化，开箱即用

1. Netty的核心定位：对NIO的“封装和优化”

一句话总结：Netty是一个基于Java NIO的、异步事件驱动的高性能网络通信框架，本质上就是对Java原生NIO的“二次封装”，解决了NIO的所有痛点，让我们能轻松上手高性能网络编程，不用再关注底层复杂细节。

还是用餐厅的例子：Netty相当于一个“专业的餐厅管理系统”，它帮你培训服务员（优化线程模型）、处理客人排队（解决空轮询）、准备好所有餐具（封装API），你只需要负责接待客人、提供菜品（编写业务逻辑），不用再管其他杂事。

2. Netty极简Demo（Java代码）

对比NIO的复杂代码，Netty的Demo非常简洁，不用自己处理Selector、Buffer的复杂操作，聚焦业务逻辑即可（需要先导入Netty依赖，Maven依赖如下）：

<!-- Netty核心依赖 --> <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.90.Final</version> </dependency>

Netty服务器Demo：

import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; import io.netty.handler.codec.string.StringDecoder; import io.netty.handler.codec.string.StringEncoder; public class NettyServer { public static void main(String[] args) throws InterruptedException { // 1. 创建事件循环组（相当于NIO的Selector，Netty已封装好） EventLoopGroup bossGroup = new NioEventLoopGroup(1); // 处理连接事件 EventLoopGroup workerGroup = new NioEventLoopGroup(); // 处理读写事件 try { // 2. 启动器（Netty入口，封装了NIO的复杂操作） ServerBootstrap bootstrap = new ServerBootstrap(); bootstrap.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) // 设置服务器通道类型 .childHandler(new ChannelInitializer<SocketChannel>() { // 3. 配置通道处理器（处理业务逻辑） @Override protected void initChannel(SocketChannel ch) throws Exception { // 字符串编解码器（Netty内置，不用自己处理粘包拆包基础逻辑） ch.pipeline().addLast(new StringDecoder()); ch.pipeline().addLast(new StringEncoder()); // 自定义业务处理器（处理客户端消息） ch.pipeline().addLast(new MyServerHandler()); } }); System.out.println("Netty服务器启动，等待客户端连接..."); // 4. 绑定端口，启动服务器（非阻塞） ChannelFuture future = bootstrap.bind(8888).sync(); // 5. 等待服务器关闭 future.channel().closeFuture().sync(); } finally { // 关闭事件循环组，释放资源 bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); } } // 自定义业务处理器（处理客户端消息） static class MyServerHandler extends io.netty.channel.ChannelInboundHandlerAdapter { // 当收到客户端消息时触发 @Override public void channelRead(io.netty.channel.ChannelHandlerContext ctx, Object msg) throws Exception { String message = (String) msg; System.out.println("收到客户端消息：" + message); // 回复客户端消息 ctx.writeAndFlush("已收到你的消息：" + message); } } }

Netty客户端Demo：

import io.netty.bootstrap.Bootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioSocketChannel; import io.netty.handler.codec.string.StringDecoder; import io.netty.handler.codec.string.StringEncoder; import java.util.Scanner; public class NettyClient { public static void main(String[] args) throws InterruptedException { // 1. 创建事件循环组 EventLoopGroup group = new NioEventLoopGroup(); try { // 2. 启动器 Bootstrap bootstrap = new Bootstrap(); bootstrap.group(group) .channel(NioSocketChannel.class) .handler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) throws Exception { ch.pipeline().addLast(new StringDecoder()); ch.pipeline().addLast(new StringEncoder()); ch.pipeline().addLast(new MyClientHandler()); } }); // 3. 连接服务器 ChannelFuture future = bootstrap.connect("127.0.0.1", 8888).sync(); // 4. 发送消息（从控制台输入） Scanner scanner = new Scanner(System.in); while (scanner.hasNextLine()) { String message = scanner.nextLine(); future.channel().writeAndFlush(message); } // 5. 等待连接关闭 future.channel().closeFuture().sync(); } finally { group.shutdownGracefully(); } } // 客户端处理器（接收服务器回复） static class MyClientHandler extends io.netty.channel.ChannelInboundHandlerAdapter { @Override public void channelRead(io.netty.channel.ChannelHandlerContext ctx, Object msg) throws Exception { String message = (String) msg; System.out.println("收到服务器回复：" + message); } } }

3. Netty解决了NIO的所有痛点，还带来了额外优势

Netty的核心价值，就是“解决问题+提升体验”，具体来说：

• 简化开发：封装了NIO的复杂API，提供了简洁易用的接口（比如Bootstrap启动器、Handler处理器），不用再手写Selector、Buffer的复杂逻辑；

• 修复原生BUG：解决了NIO的空轮询问题，底层优化了线程模型，提升了稳定性；

• 内置解决方案：自带粘包拆包、编解码、断线重连、心跳检测等功能，不用开发者自己实现，降低开发成本；

• 高性能：采用Reactor线程模型、内存池、零拷贝等技术，比原生NIO性能更好，能轻松支撑万级、十万级并发连接；

• 线程安全：内置线程安全机制，开发者不用自己处理多线程锁的问题。

四、总结：从BIO到Netty的迭代逻辑（核心必记）

整个Java网络编程的迭代，本质上就是“解决痛点、提升效率、降低门槛”的过程，用一张表就能看明白：

看到这里，你应该能明白：Netty不是凭空出现的，它是Java网络编程迭代的必然结果。它没有发明新的技术，而是把NIO的能力做了极致的封装和优化，让普通人也能轻松上手高性能网络编程。