大家好，今天咱们聊一个Java后端领域里高频出现，但入门又容易被“底层细节”吓住的框架——Netty。很多新手听到Netty，第一反应就是“复杂、难学”，但其实Netty的出现不是凭空的，而是Java网络编程从BIO、NIO一步步迭代优化来的。

这篇博客就主打一个“通俗不烧脑+代码落地”，从最基础的BIO讲起，一步步拆解每代技术的痛点、迭代原因，搭配极简Java Demo演示，最后自然过渡到Netty，帮你不仅搞懂Netty是什么，更明白它为什么会出现、能解决什么核心问题，快速建立对Netty的完整认知（全程不深入复杂源码，只看核心逻辑）。

一、第一代：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的能力做了极致的封装和优化，让普通人也能轻松上手高性能网络编程。

后续我们再逐步深入Netty的核心组件（EventLoop、Channel、Pipeline等）和具体用法，今天先到这里，重点是搞懂“从BIO到Netty”的迭代逻辑，建立对Netty的完整认知。如果觉得这篇入门博客对你有帮助，欢迎点赞收藏，后续一起解锁Netty的更多知识点～