┌────────────────────────────────────────────────────────────────────┐
│                  Java 网络编程演进线                                  │
│                                                                    │
│  BIO ──────────────►  NIO ──────────────►  Netty                  │
│  (阻塞IO)              (非阻塞IO)            (基于NIO的框架)          │
│                                                                    │
│  每连接一线程            Channel+Buffer         boss/worker线程组     │
│  实现简单               +Selector多路复用        Pipeline流水线        │
│  线程爆炸扛不住          能扛高并发              异步非阻塞回调          │
│  只适合连接少            编程复杂易出错           高性能零拷贝            │
│  │                     │                      │                    │
│  └─ 缺点逼出 NIO        └─ 复杂逼出 Netty       └─ 今天的主角          │
└────────────────────────────────────────────────────────────────────┘

三个必须理解的核心差异：
  ① 阻塞 vs 非阻塞         —— 一个线程能不能同时"看管"很多连接
  ② 线程模型               —— 一个连接一个线程？还是一个线程很多连接？
  ③ 开发体验               —— 手写 NIO 的坑，Netty 帮你填平

  客户端(打电话的人)                    服务端(接电话的人)
      │                                      │
      │  1. 拨号(new Socket)                 │
      │ ────────────────────────────────────►│  ServerSocket.accept()
      │         3. 建立连接(三次握手)         │      等待电话进来(阻塞)
      │                                      │
      │  2. 说话(输出流.write)               │
      │ ────────────────────────────────────►│  4. 听(输入流.read)
      │         5. 回话                        │
      │ ◄────────────────────────────────────│
      │  6. 挂电话(close)                     │

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class BioDemo1 {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(9000);
        System.out.println("服务端启动，端口 9000");
        while (true) {
            // ★ 阻塞点1：accept() 会一直停在这里，直到有客户端连进来
            Socket socket = serverSocket.accept();
            System.out.println("收到一个连接: " + socket.getRemoteSocketAddress());

            // 读取客户端发来的数据
            BufferedReader reader = new BufferedReader(
                    new InputStreamReader(socket.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println("收到数据: " + line);
            }
        }
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class BioServerThreadPool {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(9000);
        System.out.println("BIO 服务端启动，端口 9000");

        // 固定线程池：线程数是有限的，防止连接无限涨
        ExecutorService pool = Executors.newFixedThreadPool(20);

        while (true) {
            // 主线程只做一件事：接电话
            Socket socket = serverSocket.accept();
            System.out.println("收到连接: " + socket.getRemoteSocketAddress());
            // 把连接丢给一个工作线程去处理，主线程立刻回去继续 accept
            pool.execute(() -> handle(socket));
        }
    }

    private static void handle(Socket socket) {
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(socket.getInputStream()))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(Thread.currentThread().getName() + " 收到: " + line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

                    ┌─────────────────────────────┐
  客户端A ──连接──►  │                             │
                    │        ServerSocket         │
  客户端B ──连接──►  │        (main 线程 accept)    │
                    │                             │
  客户端C ──连接──►  └───────────┬─────────────────┘
                                │ 每来一个连接，从线程池取一个线程
        ┌───────────┬───────────┼───────────┬──────────────┐
        ▼           ▼           ▼           ▼              ▼
   线程1(伺候A)  线程2(伺候B)  线程3(伺候C)  ...          线程20
   read()阻塞     read()阻塞    read()阻塞

BIO：  线程A ──死等──► 连接1            （一个线程只能等一个）
      线程B ──死等──► 连接2
      线程C ──死等──► 连接3

NIO：  一个线程 ──► 名册Selector ──► 连接1 有数据? 没有
                                   连接2 有数据? 有！→ 处理
                                   连接3 有数据? 没有
                    （一圈问完再问下一圈）

   SocketChannel1 ──┐
   SocketChannel2 ──┼──► 注册到 Selector  ──►  线程.select() 阻塞等待事件
   ServerSocketCh. ─┘        │                        │
                             │                        ▼
                             │                有事件发生的通道集合
                             └───►  遍历处理，数据放 Buffer 里读写

   position    limit     capacity
      │         │           │
      ▼         ▼           ▼
   ┌─────────────────────────────────┐
   │  0  1  2  3  4  5  6 ...  n-1  │
   └─────────────────────────────────┘

ByteBuffer buffer = ByteBuffer.allocate(1024);

// ── 写模式（默认）────────────────────────────
buffer.put("hello".getBytes());
// position 现在指向 5，表示已写入 5 个字节

// ── 切换读模式：必须 flip() ──────────────────
buffer.flip();
// 作用 = limit = position(5) ; position = 0
// 即"把已写入的内容锁死，从头部开始读"

// ── 读模式 ──────────────────────────────────
byte[] b = new byte[buffer.limit()];
buffer.get(b);          // 读到 limit=5 为止
System.out.println(new String(b));  // hello

// ── 读完想再写：clear() 或 compact() ─────────
buffer.clear();         // 全部重置，position=0, limit=capacity

ServerSocketChannel server = ServerSocketChannel.open();
server.bind(new InetSocketAddress(9000));
server.configureBlocking(false);  // ★ 非阻塞模式：accept 不阻塞

SelectionKey.OP_ACCEPT   // 有新的连接可以被 accept（只用于 ServerSocketChannel）
SelectionKey.OP_CONNECT  // 连接建立成功（客户端用）
SelectionKey.OP_READ     // 通道有数据可读
SelectionKey.OP_WRITE    // 通道可以写数据了

1. 打开 Selector
2. 把 ServerSocketChannel 注册进去，监听 OP_ACCEPT
3. 死循环：
   a. selector.select()          阻塞，直到有事件发生
   b. 取出所有"有事件"的 key：selectedKeys()
   c. 遍历每个 key：
      - 是 ACCEPT 事件 → accept 新连接，把新 SocketChannel 注册进去监听 OP_READ
      - 是 READ 事件   → 从通道读到 Buffer 里，处理数据
   d. 处理完必须手动删除这个 key（selectedKeys 不会自动清理）

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.nio.charset.Charset;
import java.util.Iterator;

public class NioServer {
    public static void main(String[] args) throws Exception {
        // 1. 打开服务端通道，绑定端口，设为非阻塞
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.bind(new InetSocketAddress(9000));
        serverChannel.configureBlocking(false);

        // 2. 打开选择器，把服务端通道注册进去，监听"有新连接"事件
        Selector selector = Selector.open();
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("NIO 服务端启动，端口 9000");

        ByteBuffer buffer = ByteBuffer.allocate(1024);

        while (true) {
            // 3. 阻塞等待事件（任何通道有事件就醒）
            selector.select();

            // 4. 取出所有有事件的 key
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            while (it.hasNext()) {
                SelectionKey key = it.next();
                it.remove();   // ★ 必须手动移除，否则会重复处理

                if (key.isAcceptable()) {
                    // ── 有新的连接进来 ──
                    SocketChannel client = serverChannel.accept();
                    client.configureBlocking(false);
                    // 把新连接也注册到 selector，监听"可读"事件
                    client.register(selector, SelectionKey.OP_READ);
                    System.out.println("新连接: " + client.getRemoteAddress());

                } else if (key.isReadable()) {
                    // ── 某个连接有数据可读 ──
                    SocketChannel client = (SocketChannel) key.channel();
                    buffer.clear();               // 清空，准备写入
                    int len = client.read(buffer); // 读到 buffer，len 是字节数
                    if (len == -1) {
                        // -1 表示对方关闭了连接
                        client.close();
                        System.out.println("连接关闭");
                    } else if (len > 0) {
                        buffer.flip();  // ★ 写→读 必须 flip
                        String msg = Charset.forName("UTF-8")
                                .decode(buffer).toString();
                        System.out.println("收到: " + msg);
                    }
                }
            }
        }
    }
}

                    ┌───────────────────────────────┐
  客户端A ──┐       │                               │
  客户端B ──┼─注册─►│        Selector(名册)          │
  客户端C ──┘       │     监听所有通道的事件          │
                    └───────────────┬───────────────┘
                                    │  select() 阻塞等待
                                    ▼
                          ┌──────────────────┐
                          │  一个线程(worker)  │
                          └──────────────────┘
                                    │  谁有事件处理谁
                     ┌──────────────┼──────────────┐
                     ▼              ▼              ▼
                处理A的数据      accept新连接C    处理B的数据

理想情况：            |   HELLO   |   WORLD   |

粘包(一次收到两条)：    |   HELLOWORLD   |        ← 分不清边界
半包(一条被拆两半)：    |   HEL  |   LOWORLD   |  ← 一条不完整

0─────2─────3─────4─────────────────16─────────────20
│魔数  │版本 │类型 │  设备ID(12字节)  │   体长度     │  JSON体
│DCDC  │01  │ 02  │  RBT-0001      │   0000002C  │  {...}
└──2B──┴─1B─┴─1B──┴────12B─────────┴────4B───────┴──44B─┘
                                    ↑
                            长度字段：偏移16，占4字节

// 参数：(maxFrameLength, lengthFieldOffset, lengthFieldLength, lengthAdjustment, initialBytesToStrip)
new LengthFieldBasedFrameDecoder(65535, 16, 4, 0, 0)
//        │                      │     │  │  │  │
//        │                      │     │  │  │  └─ 切完包后要不要去掉头部(0=保留完整报文)
//        │                      │     │  │  └──── 读完长度后额外偏移(0=不偏移)
//        │                      │     │  └─────── 长度字段占 4 字节
//        │                      │     └────────── 长度字段从偏移 16 处开始
//        │                      └──────────────── 报文最大长度
//        └─────────────────────────────────────── 字节流解码器，自动按长度切出一条条完整报文

┌─────────────────────────────────────────────────────┐
│                 你的业务代码 (Handler)                 │
├─────────────────────────────────────────────────────┤
│          ChannelPipeline（流水线/处理器链）             │
├─────────────────────────────────────────────────────┤
│   Channel / ByteBuf / Future / Promise 等抽象         │
├─────────────────────────────────────────────────────┤
│          NIO 底层（Selector / EventLoop）             │
├─────────────────────────────────────────────────────┤
│           操作系统 Socket / TCP                      │
└─────────────────────────────────────────────────────┘

EventLoopGroup bossGroup   = new NioEventLoopGroup(1);  // boss 组：1 个线程
EventLoopGroup workerGroup = new NioEventLoopGroup(4);  // worker 组：4 个线程

                         boss 组（1 个线程，只接电话）
                     ┌──────────────────────────┐
   客户端A ──┐        │  EventLoop(boss)          │
   客户端B ──┼──────► │  accept 新连接            │
   客户端C ──┘        └───────────┬──────────────┘
                                  │ 把连接"分派"下去
         ┌────────────────────────┼────────────────────────┐
         ▼                        ▼                        ▼
   ┌─────────────┐         ┌─────────────┐         ┌─────────────┐
   │worker线程1   │         │worker线程2   │         │worker线程3   │
   │负责连接A,C    │         │负责连接B     │         │负责连接D,E    │
   │读/写/业务     │         │读/写/业务    │         │读/写/业务     │
   └─────────────┘         └─────────────┘         └─────────────┘

   EventLoop(worker)                                  业务线程池
   ┌───────────────┐    提交任务(异步)      ┌──────────────────┐
   │ 读到一条报文   │ ────────────────────► │  线程1: 写InfluxDB │
   │ 解析出DeviceMsg│                       │  线程2: 发MQ      │
   │ 立刻去处理下一个│                       │  线程3: 更新MySQL  │
   └───────────────┘                       └──────────────────┘

  入站方向(网络→应用)                   出站方向(应用→网络)
  数据流入                             数据流出
        │                                 │
        ▼                                 ▼
┌───────────────────────────────────────────────┐
│ ChannelPipeline                              │
│                                               │
│  ┌─────────────────────────────────────────┐  │
│  │  Handler1(解码器)  Handler2(鉴权)       │  │
│  │  Handler3(心跳)    Handler4(业务处理)    │  │
│  └─────────────────────────────────────────┘  │
│       ▲                                   │   │
│       └── 入站方向 ──► (从左到右) ──►        │  │
│       (从右到左) ◄── 出站方向 ◄──            │  │
└───────────────────────────────────────────────┘

public class MyHandler extends SimpleChannelInboundHandler<String> {
    @Override
    public void channelRegistered(ChannelHandlerContext ctx)   {} // 连接注册到 EventLoop
    @Override
    public void channelActive(ChannelHandlerContext ctx)       {} // 连接建立成功
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) {} // ★ 收到完整一条消息(核心)
    @Override
    public void channelInactive(ChannelHandlerContext ctx)     {} // 连接断开
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {} // 异常
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt)    {} // 用户/空闲事件(心跳超时)
}

// 异步发起绑定，不阻塞主线程
ChannelFuture future = b.bind(9000);
System.out.println("绑定命令已发出，继续往下执行...");  // 这行会立刻执行

// 方式一：阻塞等待结果（把异步转同步，初学者常用）
future.sync();

// 方式二：加监听器，完成后回调（真正的异步风格）
future.addListener((ChannelFutureListener) f -> {
    if (f.isSuccess()) {
        System.out.println("绑定成功！");
    } else {
        System.out.println("绑定失败: " + f.cause());
    }
});

import io.netty.bootstrap.ServerBootstrap;
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.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class NettyEchoServer {
    public static void main(String[] args) throws Exception {
        // ── 1. 两个线程组 ──────────────────────────
        // boss：1 个线程，只负责 accept 新连接
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        // worker：默认 CPU 核数*2 个线程，负责连接的 IO 读写
        EventLoopGroup workerGroup = new NioEventLoopGroup(4);

        try {
            // ── 2. ServerBootstrap：服务端启动引导器 ──
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)           // 指定两组线程
             .channel(NioServerSocketChannel.class)   // 底层用 NIO
             .option(ChannelOption.SO_BACKLOG, 1024)  // 连接等待队列长度
             .childOption(ChannelOption.TCP_NODELAY, true) // 禁用 Nagle 算法，降低延迟
             .childHandler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 protected void initChannel(SocketChannel ch) {
                     // ── 3. 给每个连接装一条流水线(Pipeline) ──
                     ch.pipeline().addLast(
                         new StringDecoder(),          // 入站：字节 → 字符串
                         new StringEncoder(),          // 出站：字符串 → 字节
                         new EchoHandler()             // 业务处理
                     );
                 }
             });

            // ── 4. 异步绑定端口，sync 等待成功 ──
            ChannelFuture f = b.bind(9000).sync();
            System.out.println("Netty Echo 服务端启动，端口 9000");

            // ── 5. 阻塞等待，让服务一直运行，直到被关闭 ──
            f.channel().closeFuture().sync();
        } finally {
            // ── 6. 优雅关闭：先停 worker 再停 boss ──
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

    // 业务处理器：收到消息就原样回写
    static class EchoHandler extends SimpleChannelInboundHandler<String> {
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, String msg) {
            System.out.println(Thread.currentThread().getName() + " 收到: " + msg);
            ctx.writeAndFlush(msg);   // 异步回写，不用管底层
        }

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