NIO 和 Netty 在 Spring Boot 中的集成与使用

阿乾之铭2025-01-23 12:56

Netty到底是个啥，有啥子作用

1. Netty 的本质：对 NIO 的封装

  • NIO 的原生问题：

    • Java 的 NIO 提供了非阻塞 I/O 和多路复用机制，但其使用较为复杂（如 Selector、Channel、Buffer 的配置和管理）。
    • 开发者需要自己处理线程模型、资源管理、协议解析等底层细节，代码冗长且容易出错。

  • Netty 的改进：

    • Netty 对 NIO 进行了高级封装，提供了更加易用的 API 和灵活的抽象层，例如：
      • Channel：封装网络连接。
      • Pipeline：处理器链，支持多种 Handler 对 I/O 事件的顺序处理。
      • EventLoopGroup：管理 I/O 线程，优化线程池模型。
      • 零拷贝 ：通过 FileRegion 等机制提升文件传输性能。
    • 通过这些封装，Netty 让开发者可以专注于业务逻辑，而无需过多关注底层实现。

2. Netty 的定位：搭建各种协议的网络框架

Netty 的核心价值在于它不是一个具体的协议实现，而是一个通用的网络框架，你可以用它来搭建支持任意协议的服务器或客户端：

  • HTTP/HTTPS ：Netty 提供了 HttpServerCodec、HttpObjectAggregator 等，简化 HTTP 服务器开发。
  • WebSocket ：通过 WebSocketServerProtocolHandler 支持 WebSocket 协议的握手和数据帧处理。
  • 自定义协议 ：可以使用 Netty 提供的 ByteBuf 和编解码器开发任意的私有协议。
  • 其他协议：支持基于 TCP、UDP 的多种网络协议（如 FTP、MQTT、RPC 框架等）。

因此，学习 Netty 的核心目标是：基于其框架搭建一个能够满足你业务需求的服务器或客户端，这既可能是基于已有协议（如 HTTP），也可能是自定义协议。

3. Netty 与 Spring 的关系：与 Tomcat 并列

Netty 和 Spring 中的 Tomcat、Jetty、Undertow 等容器确实属于同一层级的网络层组件，它们的关系可以这样理解：

  • Tomcat/Jetty/Undertow（传统 Servlet 容器）：

    • 专注于基于 Servlet API 的 HTTP 协议处理。
    • 与 Spring WebMVC、Spring Boot 配合紧密，默认用于运行 REST API 或 Web 应用。
    • 通常是阻塞 I/O 模型（Tomcat 提供了异步支持，但整体设计仍然偏向阻塞）。

  • Reactor Netty（Spring WebFlux 默认容器）：

    • Netty 的一个封装版本，专注于响应式编程模型，支持非阻塞、高并发 HTTP/WebSocket 服务。
    • 与 Spring WebFlux 配合，简化了直接使用 Netty 时的一些底层复杂性。
    • 你不需要自己搭建 ServerBootstrap，但可以通过 WebFlux 直接调用 Netty 的异步能力。

  • 原生 Netty：

    • 灵活且强大，可以搭建支持任意协议的高性能服务器或客户端。
    • 如果需要自定义协议（如 RPC、物联网通信协议）、或处理特殊场景（如 TCP 长连接、UDP 消息），原生 Netty 是理想选择。
    • 它可以与 Spring Boot 并行运行，比如 Spring Boot 提供 HTTP API，而 Netty 提供 WebSocket、TCP 或自定义协议服务。

4. 学习 Netty 的本质：搭建服务器（或客户端）

学习 Netty 的核心目标确实是"搭建一个服务器或客户端"。以下是几个关键点：

  • 事件驱动的 I/O 模型

    • 理解 Netty 的 Channel、EventLoop、Selector 是如何通过事件驱动模型处理网络 I/O 的。
    • 理解 ChannelPipeline 和 Handler 的作用，以及如何通过责任链处理 I/O 事件（如读、写、异常等）。

  • 线程模型的灵活性

    • 学习如何使用 EventLoopGroup 来管理线程池（如 bossGroup 处理连接，workerGroup 处理读写）。
    • 掌握 Netty 的多线程模型，避免传统阻塞 I/O 中的线程瓶颈。

  • 编解码与协议支持

    • 学习如何使用 Netty 提供的编解码器（如 ByteToMessageDecoder 和 MessageToByteEncoder）来解析和组装协议数据。
    • 通过 HttpServerCodec 等现成工具快速支持标准协议，也可以自己开发定制化的协议栈。

  • 高性能文件传输

    • 利用 Netty 的零拷贝（FileRegion）和分块传输（ChunkedWriteHandler）提升文件传输效率。
    • 在需要时手动控制传输细节，比如断点续传、多连接并行下载等。

  • 典型场景

    • 构建一个支持高并发的 WebSocket 服务器，用于聊天、通知推送等。
    • 构建基于 Netty 的 RPC 框架，支持分布式调用。
    • 使用 Netty 搭建高效的 TCP 或 UDP 服务（如物联网设备通信）。
    • 开发支持复杂协议（如 MQTT、FTP、SMTP 等）的服务器或客户端。

5. 是否每次都需要搭建一个服务器？

不一定完全是"搭建服务器"。Netty 本身既可以用来搭建服务器（ServerBootstrap），也可以用来构建客户端（Bootstrap），具体取决于你的应用场景：

  • 搭建服务器

    这是 Netty 的典型用途，例如构建 HTTP、WebSocket 或其他协议服务器。学习 Netty 的一个重要方向就是学会如何编写 ServerBootstrap 并配置它的 ChannelInitializer 和 Pipeline。

  • 构建客户端

    Netty 也可以用来构建高性能的网络客户端。例如：

    • RPC 调用中的客户端通信。
    • 基于 Netty 的 WebSocket 客户端（如 IM、实时通知客户端）。
    • 支持自定义协议的客户端程序。

一、NIO 的基础与在 Spring Boot 中的集成

1.1 NIO 是什么？为什么要有 NIO？

NIO 的背景

Java NIO（New Input/Output）是 Java 1.4 引入的一组新的 I/O 操作 API，旨在解决传统 BIO（Blocking I/O）在高并发场景下的性能瓶颈。BIO 的模型在处理大量并发连接时存在明显的性能问题，而 NIO 通过引入非阻塞 I/O 和多路复用技术，显著提升了 I/O 操作的效率。

BIO 的局限性：

  • 线程开销大：每个连接需要一个独立的线程进行处理，当连接数增加时，线程数量会急剧增加，导致系统资源消耗过大。

  • 阻塞操作：在 BIO 模型中，I/O 操作是阻塞的，即线程在执行读写操作时会一直等待，直到数据准备好或操作完成。这种阻塞会导致大量线程处于等待状态，浪费 CPU 资源。

  • 扩展性差：由于线程数量的限制，BIO 模型难以应对高并发的场景，尤其是在网络通信中，连接数可能达到数千甚至数万。

NIO 的特点与优势

  • 非阻塞 I/O ：NIO 的核心特性之一是非阻塞 I/O。通过 Selector 机制，NIO 可以实现事件驱动的 I/O 操作。一个线程可以管理多个通道（Channel），只有在通道上有事件（如数据可读、可写）发生时，线程才会进行处理，避免了线程的阻塞等待。

  • 多路复用 ：NIO 使用 Selector 实现多路复用，即一个线程可以同时监控多个通道的 I/O 事件。这种方式大大减少了线程的数量，降低了系统的资源消耗，同时提高了系统的并发处理能力。

  • 缓冲区模型 ：NIO 引入了 Buffer 作为数据读写的核心组件。与传统的流式 I/O 不同，NIO 使用缓冲区来批量处理数据，减少了频繁的系统调用，提高了 I/O 操作的效率。

1.2 NIO 的基础组件、它们之间的联系与工作流程

NIO 的核心组件包括 Channel（通道） 、Buffer（缓冲区） 和 Selector（选择器）。这些组件共同协作，实现了非阻塞 I/O 和多路复用机制。下面我们将详细讲解这些组件的作用、联系以及它们的工作流程。

1.2.1 Channel（通道）

Channel 是 NIO 中用于数据传输的抽象，类似于传统 I/O 中的流（Stream），但 Channel 是双向的，既可以读数据，也可以写数据。与传统的流相比，Channel 提供了更高的灵活性和性能。

1.2.1.1 对比传统流

  • 传统流 ：传统的 InputStream 和 OutputStream 是单向的，只能读或写。

  • Channel ：Channel 是双向的，既可以读数据，也可以写数据。例如，SocketChannel 可以同时进行读写操作。

1.2.1.2 常见类型

  • ServerSocketChannel ：用于监听 TCP 连接，类似于 ServerSocket。

  • SocketChannel ：用于 TCP 网络通信，类似于 Socket。

  • FileChannel：用于文件 I/O 操作，支持文件的读写和内存映射。

1.2.1.3 获取 Channel

  • 通过 open() 方法获取 Channel：

    java 复制代码 
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
SocketChannel socketChannel = SocketChannel.open();
FileChannel fileChannel = FileChannel.open(Paths.get("file.txt"), StandardOpenOption.READ);

  • 通过 RandomAccessFile 获取 Channel：

    java 复制代码 
    RandomAccessFile file = new RandomAccessFile("file.txt", "rw");
FileChannel fileChannel = file.getChannel();

1.2.2 Buffer（缓冲区）

Buffer 是 NIO 中用于存储数据的容器，所有的数据读写操作都是通过 Buffer 进行的。Buffer 提供了一种高效的方式来批量处理数据，避免了传统流式 I/O 的低效问题。

1.2.2.1 核心类：ByteBuffer

  • ByteBuffer 是最常用的缓冲区类型，用于存储字节数据。

  • 其他类型的 Buffer：

    • CharBuffer：存储字符数据。

    • IntBuffer：存储整数数据。

    • LongBuffer：存储长整数数据。

1.2.2.2 读写数据必须经过 Buffer

  • 写入数据：将数据写入 Buffer，然后通过 Channel 发送。

  • 读取数据：从 Channel 读取数据到 Buffer，然后从 Buffer 中读取数据。

1.2.2.3 核心方法

  • put()：将数据写入 Buffer。

  • get()：从 Buffer 中读取数据。

  • flip()：将 Buffer 从写模式切换到读模式。

  • clear()：清空 Buffer，准备重新写入数据。

  • rewind()：将 position 重置为 0，可以重新读取 Buffer 中的数据。

1.2.2.4 Buffer 的状态属性

  • capacity：缓冲区的容量，即可以存储的最大数据量。

  • position：当前读写的位置。

  • limit：缓冲区的限制位置，表示可以读写的数据范围。

  • mark：标记位置，用于临时记录 position。

1.2.3 Selector（选择器）

Selector 是 NIO 实现多路复用的核心组件，它可以监控多个 Channel 的 I/O 事件（如读、写、连接等）。通过 Selector，一个线程可以管理多个 Channel，从而减少线程数量，提高系统的并发处理能力。

1.2.3.1 基于操作系统的多路复用机制

  • Selector 底层依赖于操作系统的多路复用机制（如 Linux 的 epoll、Windows 的 IOCP）。

  • 通过 select() 方法，Selector 可以查询哪些 Channel 已经就绪（如可读、可写、可连接等）。

1.2.3.2 事件类型

  • OP_ACCEPT ：表示 Channel 可以接受新的连接（适用于 ServerSocketChannel）。

  • OP_READ：表示 Channel 有数据可读。

  • OP_WRITE：表示 Channel 可以写入数据。

  • OP_CONNECT：表示 Channel 已经成功连接。

1.2.3.3 注册 Channel 到 Selector

  • 通过 register() 方法将 Channel 注册到 Selector，并指定感兴趣的事件：

    java 复制代码 
    serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
socketChannel.register(selector, SelectionKey.OP_READ);

1.2.4 工作流程简述

NIO 的工作流程可以分为以下几个步骤：

1.2.4.1 初始化

打开 ServerSocketChannel，并配置为非阻塞模式：

java 复制代码 
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.bind(new InetSocketAddress(8080));
serverSocketChannel.configureBlocking(false);

打开 Selector：

java 复制代码 
Selector selector = Selector.open();

将 ServerSocketChannel 注册到 Selector，并指定感兴趣的事件（如 OP_ACCEPT）：

java 复制代码 
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

1.2.4.2 事件循环

调用 selector.select() 方法，阻塞等待事件发生，轮询就绪事件：

java 复制代码 
selector.select();

获取就绪的 SelectionKey 集合：

java 复制代码 
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> iter = selectedKeys.iterator();

1.2.4.3 事件处理

处理新连接（OP_ACCEPT）：

  • 调用 accept() 方法接受新连接，并注册到 Selector：

    java 复制代码 
    if (key.isAcceptable()) {
    SocketChannel socketChannel = serverSocketChannel.accept();
    socketChannel.configureBlocking(false);
    socketChannel.register(selector, SelectionKey.OP_READ);
}

处理读事件（OP_READ）：

  • 从 Channel 读取数据到 Buffer：

    java 复制代码 
    if (key.isReadable()) {
    SocketChannel socketChannel = (SocketChannel) key.channel();
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    int bytesRead = socketChannel.read(buffer);
    if (bytesRead > 0) {
        buffer.flip();
        // 处理读取的数据
    }
}

处理写事件（OP_WRITE）：

  • 将数据从 Buffer 写入 Channel：

    java 复制代码 
    if (key.isWritable()) {
    SocketChannel socketChannel = (SocketChannel) key.channel();
    ByteBuffer buffer = ByteBuffer.wrap("Hello, World!".getBytes());
    socketChannel.write(buffer);
}

1.2.4.4 Buffer 读写

  • 读操作：将数据从 Channel 读入 Buffer。

  • 写操作：将数据从 Buffer 写回 Channel。

1.2.5 组件之间的联系

  • Channel 与 Buffer：Channel 负责数据的传输，Buffer 负责数据的存储。所有的读写操作都必须通过 Buffer 进行。

  • Channel 与 Selector：Channel 注册到 Selector 后，Selector 可以监控 Channel 的 I/O 事件，并在事件发生时通知应用程序。

  • Selector 与 Buffer：Selector 负责管理多个 Channel 的事件，而 Buffer 负责存储这些事件中涉及的数据。

1.3 NIO 在 Spring Boot 中的集成与使用

在 Spring Boot 中集成 NIO 可以帮助我们构建高性能的网络服务和文件操作功能。下面我们将详细讲解如何在 Spring Boot 中编写简易的 NIO 服务，以及如何使用 NIO 进行文件操作，并结合实际项目场景进行代码实现和详细解释。

1.3.1 在 Spring Boot 中编写简易 NIO 服务

1.3.1.1 目标

  • 实现一个基于 NIO 的简易 Echo 服务器。

  • 将 NIO 服务集成到 Spring Boot 项目中。

  • 使用线程池管理 NIO 事件循环，避免阻塞 Spring Boot 主线程。

1.3.1.2 实现步骤

  • 创建 Spring Boot 项目：

    • 使用 Spring Initializr 创建一个 Spring Boot 项目，添加 spring-boot-starter-web 依赖。

  • 编写 NIO 服务：

    • 在 Spring Boot 中编写 NIO 服务，并将其作为一个 @Component 或 @Service 组件。

  • 启动 NIO 服务：

    • 在 Spring Boot 启动时初始化 NIO 服务。

  • 测试 NIO 服务：

    • 使用 Telnet 或 Netcat 工具测试 NIO 服务。

1.3.1.3 关键代码与详细解释

以下是一个完整的 Spring Boot 项目示例，展示了如何集成 NIO 服务。

1. Spring Boot 主类

java 复制代码 
@SpringBootApplication
public class NioSpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(NioSpringBootApplication.class, args);
    }
}
  • 说明：这是 Spring Boot 的启动类，用于启动应用程序。

2. NIO 服务组件

java 复制代码 
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
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;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Component
public class NioEchoServer {

    @PostConstruct
    public void start() throws IOException {
        // 1. 创建 ServerSocketChannel 并绑定端口
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(8080)); // 绑定到 8080 端口
        serverSocketChannel.configureBlocking(false); // 设置为非阻塞模式

        // 2. 创建 Selector
        Selector selector = Selector.open();

        // 3. 将 ServerSocketChannel 注册到 Selector，监听 OP_ACCEPT 事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        // 4. 使用线程池管理事件循环
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.submit(() -> {
            try {
                while (true) {
                    // 5. 阻塞等待事件发生
                    selector.select();

                    // 6. 获取就绪的事件集合
                    Set<SelectionKey> selectedKeys = selector.selectedKeys();
                    Iterator<SelectionKey> iter = selectedKeys.iterator();

                    while (iter.hasNext()) {
                        SelectionKey key = iter.next();

                        // 7. 处理新连接事件
                        if (key.isAcceptable()) {
                            handleAccept(serverSocketChannel, selector);
                        }

                        // 8. 处理读事件
                        if (key.isReadable()) {
                            handleRead(key);
                        }

                        // 9. 移除已处理的事件
                        iter.remove();
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
    }

    // 处理新连接事件
    private void handleAccept(ServerSocketChannel serverSocketChannel, Selector selector) throws IOException {
        SocketChannel socketChannel = serverSocketChannel.accept(); // 接受新连接
        socketChannel.configureBlocking(false); // 设置为非阻塞模式
        socketChannel.register(selector, SelectionKey.OP_READ); // 注册到 Selector，监听 OP_READ 事件
        System.out.println("New client connected: " + socketChannel.getRemoteAddress());
    }

    // 处理读事件
    private void handleRead(SelectionKey key) throws IOException {
        SocketChannel socketChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024); // 分配缓冲区

        // 读取数据
        int bytesRead = socketChannel.read(buffer);
        if (bytesRead > 0) {
            buffer.flip(); // 切换为读模式
            byte[] data = new byte[buffer.remaining()];
            buffer.get(data); // 将数据从缓冲区读取到字节数组
            String message = new String(data);
            System.out.println("Received: " + message);

            // 回显数据
            ByteBuffer responseBuffer = ByteBuffer.wrap(data);
            socketChannel.write(responseBuffer); // 将数据写回客户端
        } else if (bytesRead == -1) {
            // 客户端关闭连接
            System.out.println("Client disconnected: " + socketChannel.getRemoteAddress());
            socketChannel.close();
        }
    }
}

1.3.1.4 关键代码详解

  • ServerSocketChannel 的创建与配置：

    • ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();：创建一个 ServerSocketChannel。

    • serverSocketChannel.bind(new InetSocketAddress(8080));：绑定到 8080 端口。

    • serverSocketChannel.configureBlocking(false);：设置为非阻塞模式。

  • Selector 的创建与注册：

    • Selector selector = Selector.open();：创建一个 Selector。

    • serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);：将 ServerSocketChannel 注册到 Selector，监听 OP_ACCEPT 事件。

  • 事件循环：

    • selector.select();：阻塞等待事件发生。

    • Set<SelectionKey> selectedKeys = selector.selectedKeys();：获取就绪的事件集合。

    • Iterator<SelectionKey> iter = selectedKeys.iterator();：遍历事件集合。

  • 处理新连接事件：

    • SocketChannel socketChannel = serverSocketChannel.accept();：接受新连接。

    • socketChannel.configureBlocking(false);：设置为非阻塞模式。

    • socketChannel.register(selector, SelectionKey.OP_READ);：注册到 Selector，监听 OP_READ 事件。

  • 处理读事件：

    • ByteBuffer buffer = ByteBuffer.allocate(1024);：分配缓冲区。

    • int bytesRead = socketChannel.read(buffer);：读取数据到缓冲区。

    • buffer.flip();：切换为读模式。

    • socketChannel.write(responseBuffer);：将数据写回客户端。

  • 线程池管理：

    • ExecutorService executorService = Executors.newSingleThreadExecutor();：创建一个单线程的线程池。

    • executorService.submit(() -> { ... });：提交任务，避免阻塞 Spring Boot 主线程。

1.3.1.5 测试 NIO 服务

  1. 启动 Spring Boot 项目。

  2. 使用 Telnet 或 Netcat 连接到 NIO 服务器：

    java 复制代码 
    telnet localhost 8080

  3. 输入消息，服务器会将消息原样返回。

1.3.2 NIO 文件操作

1.3.2.1 目标

  • 使用 FileChannel 和 MappedByteBuffer 实现高效的文件读写。

  • 在 Spring Boot 中提供文件上传和下载接口。

1.3.2.2 实现步骤

  • 使用 FileChannel 读写文件：

    • 通过 FileChannel 实现文件的随机访问和直接写入。

  • 使用 MappedByteBuffer 提高读写效率：

    • 将文件映射到内存中，减少系统调用。

  • 在 Spring Boot 中提供文件上传和下载接口：

    • 使用 @RestController 实现文件上传和下载功能。

1.3.2.3 关键代码与详细解释

以下是一个完整的 Spring Boot 项目示例，展示了如何使用 NIO 进行文件操作。

1. 文件上传接口

java 复制代码 
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

@RestController
@RequestMapping("/file")
public class FileController {

    @PostMapping("/upload")
    public String uploadFile(@RequestParam("file") MultipartFile file) throws IOException {
        // 1. 获取文件路径
        String filePath = "uploads/" + file.getOriginalFilename();

        // 2. 使用 FileChannel 写入文件
        try (FileChannel fileChannel = FileChannel.open(Paths.get(filePath), StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
            ByteBuffer buffer = ByteBuffer.wrap(file.getBytes()); // 将文件内容写入缓冲区
            fileChannel.write(buffer); // 将缓冲区内容写入文件
        }

        return "File uploaded: " + file.getOriginalFilename();
    }
}

  • 说明：

    • MultipartFile file：接收上传的文件。

    • FileChannel.open()：打开文件通道。

    • ByteBuffer.wrap()：将文件内容包装到缓冲区。

    • fileChannel.write()：将缓冲区内容写入文件。

2. 文件下载接口

java 复制代码 
import org.springframework.core.io.FileSystemResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.nio.file.Paths;

@RestController
@RequestMapping("/file")
public class FileController {

    @GetMapping("/download")
    public ResponseEntity<Resource> downloadFile(@RequestParam String filename) {
        // 1. 获取文件路径
        String filePath = "uploads/" + filename;

        // 2. 创建 FileSystemResource
        FileSystemResource resource = new FileSystemResource(Paths.get(filePath));

        // 3. 返回文件内容
        return ResponseEntity.ok()
                .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + filename + "\"")
                .body(resource);
    }
}

  • 说明：

    • FileSystemResource：表示文件系统资源。

    • ResponseEntity：返回文件内容，并设置响应头。

3. 使用 MappedByteBuffer 提高读写效率

java 复制代码 
import java.io.IOException;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class FileService {

    public void readFileWithMappedBuffer(String filePath) throws IOException {
        try (FileChannel fileChannel = FileChannel.open(Paths.get(filePath), StandardOpenOption.READ)) {
            // 1. 将文件映射到内存
            MappedByteBuffer mappedBuffer = fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, fileChannel.size());

            // 2. 读取文件内容
            byte[] data = new byte[mappedBuffer.remaining()];
            mappedBuffer.get(data);
            System.out.println(new String(data));
        }
    }
}

  • 说明：

    • fileChannel.map()：将文件映射到内存中。

    • MappedByteBuffer：直接操作内存中的数据，提高读写效率。

2. Netty 基础

2.1 Netty 是什么？与 NIO 之间的联系

2.1.1 Netty 的定义

Netty 是一个基于 Java NIO 的异步事件驱动网络应用框架，专注于高性能和可扩展的网络通信应用开发。它封装了底层 NIO 的复杂性，使开发者无需直接处理 Selector、Channel、Buffer 等低级 API，从而简化网络通信的实现。

Netty 的应用场景广泛，适用于：

  • 实现自定义 TCP/UDP 协议服务；
  • 开发高性能的 HTTP 服务器和客户端；
  • 构建分布式系统的通信模块。

2.1.2 Netty 与 NIO 的关系

Netty 基于 NIO，继承了其核心特性，同时进一步简化和优化了编程模型，提供了更加易用且功能强大的 API。

NIO 特性 Netty 封装
Selector EventLoopGroup：管理多路复用的事件循环线程组
Channel Channel：扩展的网络通道接口，支持异步操作
Buffer ByteBuf ：替代 ByteBuffer，提供更高效和灵活的内存管理
I/O 事件处理 Pipeline 和 ChannelHandler：链式事件处理机制

2.1.3 Netty 的主要优点

  • 简洁性

    • 封装底层 API ：隐藏了复杂的 Selector 和 Channel 细节，开发者无需手动管理 I/O 事件。
    • 链式处理模型 ：通过 Pipeline 和 ChannelHandler 管理 I/O 数据流。

  • 可扩展性

    • 支持多种协议：内置 HTTP、WebSocket 等常用协议的编解码器。
    • 丰富的工具库：支持自定义协议解析和扩展。

  • 高性能

    • 线程模型优化 ：采用 EventLoopGroup 管理线程池，实现事件的高效分发。
    • 零拷贝 ：使用 ByteBuf 支持直接内存操作，避免数据在用户态与内核态之间多次复制。
    • 异步非阻塞：充分利用底层 NIO 的非阻塞特性，实现高效的 I/O 操作。

2.2 Netty 中的核心组件，以及它们之间的联系、工作流程

  1. 当服务端初始化时，需要创建并配置 EventLoopGroup（事件循环组） 、ServerBootstrap（服务端引导类） 等关键对象。
  2. 客户端或服务端底层通信的抽象是 Channel（通道） ；每个 Channel 上会挂载一个 ChannelPipeline（通道管线） ，其中包含多个 ChannelHandler（通道处理器） 对入站/出站数据进行处理。
  3. 数据的读写操作基于 ByteBuf（字节缓冲区） 提供更灵活高效的内存管理。
  4. 当服务器运行时，EventLoopGroup 中的线程会不断监听网络事件（连接、读、写等），并按顺序调用对应的 Handler 进行处理。
  5. 在关闭阶段，需要优雅地释放线程组和通道资源。

2.2.1 EventLoopGroup（事件循环组）

作用 ：管理线程池并负责处理 Channel 上的各种 I/O 事件，如 连接 、读写 等。

  • EventLoopGroup 的作用

    • 线程管理：为 Netty 提供线程池支持，使得多个连接可以在少量线程之间复用（非阻塞 I/O 的核心思想）。
    • 事件循环 ：每个 EventLoop 内部通常持有一个 Selector（在 NIO 模型下），不断轮询注册在此上的 Channel 事件（如可读、可写、连接就绪等）。
    • 调度任务 ：除了 I/O 事件外，EventLoopGroup 也可执行定时任务或用户自定义任务。

  • EventLoopGroup 的分类

    • Boss Group（老板线程组） ：主要负责处理客户端的连接请求（OP_ACCEPT）。
    • Worker Group（工人线程组） ：负责处理已经建立连接的读写操作（OP_READ / OP_WRITE）。
    • 不同的 EventLoopGroup 可以基于不同的实现，如 NioEventLoopGroup（基于 NIO），EpollEventLoopGroup（基于 epoll，仅在 Linux 上可用），等等。

  • EventLoopGroup 的工作流程

    • 初始化 ：创建 NioEventLoopGroup 或 EpollEventLoopGroup 时，会生成对应数量的 EventLoop 线程。
    • 事件循环 ：这些线程会在循环中不断调用 select() 或 poll() 方法检测 I/O 就绪事件，并回调相应的 Handler。
    • 任务执行 ：用户可以通过 EventLoop 提交一些定时或普通任务，这些任务会在事件循环线程中被执行。
    • 优雅关闭 ：在关闭阶段，调用 shutdownGracefully() 来结束事件循环并释放资源。

2.2.2 ServerBootstrap / Bootstrap（服务端引导类/客户端引导类）

作用：配置并启动 Netty 应用程序的核心入口。

  1. ServerBootstrap（服务端引导类）

用于 服务端 的配置与启动。例如：

java 复制代码 
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup) // 设置 Boss 和 Worker 线程组
         .channel(NioServerSocketChannel.class) // 设置服务端Channel类型
         .childHandler(new ChannelInitializer<SocketChannel>() {
             @Override
             protected void initChannel(SocketChannel ch) {
                 ch.pipeline().addLast(new MyHandler()); // 添加自定义Handler
             }
         });

主要功能：

  • 绑定端口 （bind(port)）并监听客户端连接；
  • 关联线程组 （group(...)）让 BossGroup 处理连接，WorkerGroup 处理读写；
  • 指定 Channel 类型 （如 NioServerSocketChannel）；
  • childHandler ：对每个新建的 SocketChannel 进行初始化（设置 pipeline、handler 等）。
  1. Bootstrap（客户端引导类）

用于 客户端 的配置与启动。例如：

java 复制代码 
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(eventLoopGroup) // 设置 EventLoopGroup
         .channel(NioSocketChannel.class) // 设置客户端 Channel类型
         .handler(new ChannelInitializer<SocketChannel>() {
             @Override
             protected void initChannel(SocketChannel ch) {
                 ch.pipeline().addLast(new MyHandler());
             }
         });

主要功能：

  • 通过 connect(host, port) 发起连接到服务端；
  • 与 ServerBootstrap 类似，也可配置线程组、选择 Channel 实现、指定初始化 pipeline 等。

2.2.3 Channel（通道）

作用 ：代表一个 网络连接 的抽象，封装了底层 读写操作 、远程信息 等。

  • Channel 的作用

    • 网络 I/O 操作 ：如 read()、write()、connect()、bind() 等；
    • 生命周期管理：包括活跃、非活跃、注册到 EventLoop、关闭等；
    • Pipeline 挂载 ：每个 Channel 都拥有一个 ChannelPipeline 来处理 I/O 事件。

  • Channel 的类型

    • NioServerSocketChannel：服务端监听套接字，基于 NIO。
    • NioSocketChannel：客户端或服务器端使用的普通 TCP 连接通道。
    • EmbeddedChannel：内嵌测试用的通道，主要用于单元测试。
    • EpollServerSocketChannel / EpollSocketChannel：在 Linux 上基于 epoll 实现。

  • Channel 的工作流程

    • 当服务端启动后，会创建一个 ServerSocketChannel 供 bossGroup 监听连接；
    • 客户端连接成功后，会对应创建一个 SocketChannel，注册到 workerGroup 中，用于读写数据；
    • 应用层可以通过 channel.writeAndFlush(msg) 向远端发送数据，也可以在入站事件中读取数据；
    • 当连接断开或调用关闭方法时，Channel 进入非活跃状态并最终释放资源。

2.2.4 ChannelPipeline & ChannelHandler（通道管线 & 通道处理器）

作用 ：构成对 I/O 事件进行处理的 责任链 机制。

  • ChannelPipeline（通道管线）

    • 中文名称：通道管线
    • 作用 ：维护一组 ChannelHandler 对象的有序列表，所有入站与出站事件都会依次经过这些 Handler。
    • 特点 ：双向链表结构，提供 addLast(), remove(), replace() 等方法。

  • ChannelHandler（通道处理器）

    • 中文名称：通道处理器
    • 作用 ：实际编写业务逻辑的地方；区分 入站 (Inbound) 和 出站 (Outbound) 两种处理器。
      • InboundHandler：处理读事件、连接事件、异常事件等入站操作；
      • OutboundHandler：处理写事件、刷新事件等出站操作。

Pipeline 的工作流程

  1. 入站数据 ：从 Channel 读取数据 -> 按顺序调用 InboundHandler（如解码器、业务处理等）。
  2. 出站数据 ：调用 write() -> 按逆序调用 OutboundHandler（如编码器、压缩等）-> 最终写到远端。
  3. Handler 调用 ：Netty 提供了 ChannelInboundHandlerAdapter、ChannelOutboundHandlerAdapter 等适配器供继承，开发者可重写想要的方法（如 channelRead, channelActive, write, flush 等）。

2.2.5 ByteBuf（字节缓冲区）

作用 ：在 Netty 中用于读写数据的 核心缓存 ，比 Java NIO 的 ByteBuffer 更高效灵活。

  • ByteBuf 的特点

    • 读写指针 ：不需要像 ByteBuffer 一样手动 flip()；ByteBuf 内部有 readerIndex、writerIndex 来标识读写位置。
    • 容量可扩展：可以自动扩容，无需手动分配过多内存。
    • 池化：Netty 提供了池化机制，减少内存分配与回收的开销。
    • 多种实现：如堆内存 (heap buffer) 与直接内存 (direct buffer)。

  • ByteBuf 的使用

    java 复制代码 
    ByteBuf buffer = Unpooled.buffer(1024);         // 创建一个 1024 字节的缓冲区
buffer.writeBytes("Hello, Netty!".getBytes());  // 写入数据
byte[] data = new byte[buffer.readableBytes()];
buffer.readBytes(data);                         // 读取数据
System.out.println(new String(data));
    • 写数据 ：buffer.writeBytes(...) 或 writeInt(), writeLong() 等；
    • 读数据 ：buffer.readBytes(...) 或 readInt(), readLong() 等；
    • 索引操作 ：getByte(int index) / setByte(int index) 等，不会移动 readerIndex / writerIndex。

2.2.6 Netty 工作流程

下面综合以上组件，介绍 Netty 典型的服务器工作流程，一般可分为 初始化 、启动 、事件处理 、关闭 四大阶段。

1. 初始化阶段

创建 EventLoopGroup（事件循环组）

java 复制代码 
EventLoopGroup bossGroup = new NioEventLoopGroup(1); 
EventLoopGroup workerGroup = new NioEventLoopGroup();
  • bossGroup 通常只需一个线程负责处理连接；
  • workerGroup 默认线程数为 CPU 核心数 * 2，处理实际的读写 I/O。

创建并配置 ServerBootstrap（服务端引导类）

java 复制代码 
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup) // 设置 EventLoopGroup
         .channel(NioServerSocketChannel.class) // 设置 Channel 类型
         .childHandler(new ChannelInitializer<SocketChannel>() { // 设置 ChannelHandler
             @Override
             protected void initChannel(SocketChannel ch) {
                 ch.pipeline().addLast(new MyHandler());
             }
         });
  • group(...)：将 Boss/Worker 线程组与引导类关联；
  • channel(...) ：指定服务端 Channel 实现类型（NIO / EPOLL等）；
  • childHandler(...) ：当新的客户端连接创建 SocketChannel 时，如何对 pipeline 进行初始化（添加业务 Handler）。
2. 启动阶段
java 复制代码 
ChannelFuture future = bootstrap.bind(8080).sync();
System.out.println("Netty Server started on port 8080");
  • 通过 bind(8080) 绑定端口，sync() 阻塞等待绑定完成；
  • 开始监听客户端连接请求：当客户端连接到 8080 端口时，bossGroup 会创建新的 SocketChannel 并交给 workerGroup 管理。
3. 事件处理阶段

在运行过程中，Netty 通过 事件循环 来处理 I/O 事件（连接事件、读事件、写事件、异常事件等）。

处理连接事件

java 复制代码 
public class MyHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        System.out.println("Client connected: " + ctx.channel().remoteAddress());
    }
}
  • 当 channelActive 被触发时，表示客户端连接建立成功。

处理读写事件

java 复制代码 
public class MyHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf buffer = (ByteBuf) msg;
        byte[] data = new byte[buffer.readableBytes()];
        buffer.readBytes(data);
        System.out.println("Received: " + new String(data));

        // 回显给客户端
        ctx.writeAndFlush(Unpooled.wrappedBuffer("Echo: ".getBytes(), data));
    }
}
  • 读事件 ：从 ByteBuf 中读取数据；
  • 写事件 ：使用 ctx.writeAndFlush(...) 将数据写回远端；
  • Echo：此例子直接回显客户端发送的数据。

Pipeline 的工作流程

  • 入站（Inbound）：如上 channelRead，会从 pipeline 的头部开始依次调用入站 Handler；
  • 出站（Outbound）：如 writeAndFlush，会反向调用出站 Handler，直至将数据写到网络中。
4. 关闭阶段

当服务器需要停止时，需要释放资源 、关闭 EventLoopGroup。

关闭服务器

java 复制代码 
future.channel().closeFuture().sync();
  • 等待服务器的 Channel 关闭事件完成后再继续执行。

释放资源

java 复制代码 
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
  • 优雅地关闭线程组，确保已处理完正在进行的 I/O 事件。

完整示例代码

以下是一个完整的 Netty 服务器示例，展示了 Netty 的工作流程：

java 复制代码 
java

复制

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 InterruptedException {
        // 1. 创建 EventLoopGroup
        EventLoopGroup bossGroup = new NioEventLoopGroup(1); // 负责接收连接
        EventLoopGroup workerGroup = new NioEventLoopGroup(); // 负责处理连接

        try {
            // 2. 创建 ServerBootstrap
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                     .channel(NioServerSocketChannel.class) // 设置 Channel 类型
                     .childHandler(new ChannelInitializer<SocketChannel>() { // 设置 ChannelHandler
                         @Override
                         protected void initChannel(SocketChannel ch) {
                             ChannelPipeline pipeline = ch.pipeline();
                             pipeline.addLast(new StringDecoder()); // 解码器
                             pipeline.addLast(new StringEncoder()); // 编码器
                             pipeline.addLast(new EchoServerHandler()); // 业务处理器
                         }
                     });

            // 3. 绑定端口并启动服务器
            ChannelFuture future = bootstrap.bind(8080).sync();
            System.out.println("Netty Echo Server started on port 8080");

            // 4. 等待服务器关闭
            future.channel().closeFuture().sync();
        } finally {
            // 5. 关闭 EventLoopGroup
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    // Echo 服务器处理器
    private static class EchoServerHandler extends SimpleChannelInboundHandler<String> {
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, String msg) {
            // 回显消息
            ctx.writeAndFlush("Echo: " + msg);
        }
    }
}

三、Spring Boot 集成 Netty

3.1 方式一：替换默认的 Servlet 容器

Spring Boot 默认使用 Tomcat 作为内嵌的 Servlet 容器。如果我们希望使用 Netty 作为服务器，可以通过以下步骤替换默认的 Tomcat。

3.1.1 移除 Tomcat 依赖

在 Spring Boot 项目中，默认引入了 spring-boot-starter-web，它依赖 Tomcat。为了替换 Tomcat，我们需要移除 Tomcat 依赖。

方法 1：排除 Tomcat 依赖

在 pom.xml 中排除 spring-boot-starter-tomcat：

XML 复制代码 
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

方法 2：使用 spring-boot-starter-webflux

  • spring-boot-starter-webflux 默认使用 Reactor Netty 作为服务器，无需手动排除 Tomcat：

    XML 复制代码 
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

3.1.2 添加 Netty 依赖

如果选择使用 spring-boot-starter-webflux，则无需手动添加 Netty 依赖，因为它已经包含了 Reactor Netty。

如果选择手动集成 Netty，可以添加以下依赖：

XML 复制代码 
<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.68.Final</version>
</dependency>

3.1.3 使用 Spring WebFlux (Reactor Netty) 启动 HTTP 服务器

Spring WebFlux 是 Spring 5 引入的响应式编程框架，默认使用 Reactor Netty 作为服务器。通过 WebFlux，我们可以轻松构建非阻塞的 HTTP/REST 服务。

1. 编写 @RestController

java 复制代码 
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public Mono<String> hello(@RequestParam String name) {
        return Mono.just("Hello, " + name + "!");
    }
}

2. 启动应用

  • Spring Boot 会自动使用 Reactor Netty 作为服务器。

  • 访问 http://localhost:8080/hello?name=World，将会返回 Hello, World!。

3. 函数式路由

  • 除了 @RestController，WebFlux 还支持函数式路由。
java 复制代码 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.ServerResponse;
import static org.springframework.web.reactive.function.server.RequestPredicates.GET;
import static org.springframework.web.reactive.function.server.RouterFunctions.route;

@Configuration
public class RouterConfig {

    @Bean
    public RouterFunction<ServerResponse> helloRoute() {
        return route(GET("/hello"), request -> {
            String name = request.queryParam("name").orElse("World");
            return ServerResponse.ok().bodyValue("Hello, " + name + "!");
        });
    }
}

3.1.4 适用场景

1. 不想直接维护 Netty 原生的 ServerBootstrap

  • 使用 Spring WebFlux 可以避免直接操作 Netty 的底层 API，简化开发。

2. 主要处理 HTTP/REST 请求，追求非阻塞高性能

  • WebFlux 提供了响应式编程模型，适合处理高并发的 HTTP/REST 请求。

3.2 方式二：单独运行 Netty 服务器（TCP/UDP/WebSocket）

在某些场景下，我们可能需要在 Spring Boot 应用中同时运行一个独立的 Netty 服务器，用于处理自定义协议（如 TCP、UDP、WebSocket 等）。这种方式可以保留 Spring Boot 默认的 Tomcat/Jetty 处理 HTTP 请求，同时利用 Netty 处理长连接或自定义协议。

3.2.1 与 Spring Boot 核心应用同处一个进程

在这种方式下，Netty 服务器与 Spring Boot 应用运行在同一个 JVM 进程中。我们可以将 Netty 服务器作为一个 Spring Bean 进行初始化，并通过 Spring 的依赖注入机制与其他组件（如 Service、Repository）交互。

1. 保留默认的 Tomcat/Jetty

  • Spring Boot 默认使用 Tomcat 或 Jetty 处理 HTTP 请求，这部分保持不变。

  • Netty 服务器用于处理自定义协议或长连接（如 WebSocket、TCP、UDP）。

2. 将 Netty Server 作为一个 Spring Bean

  • 在 @Configuration 类中初始化 Netty 服务器。
java 复制代码 
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
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 org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class NettyServerConfig {

    @Bean
    public EventLoopGroup bossGroup() {
        return new NioEventLoopGroup(1); // 负责接收连接
    }

    @Bean
    public EventLoopGroup workerGroup() {
        return new NioEventLoopGroup(); // 负责处理连接
    }

    @Bean
    public ServerBootstrap serverBootstrap() {
        ServerBootstrap bootstrap = new ServerBootstrap();
        bootstrap.group(bossGroup(), workerGroup())
                 .channel(NioServerSocketChannel.class)
                 .childHandler(new ChannelInitializer<SocketChannel>() {
                     @Override
                     protected void initChannel(SocketChannel ch) {
                         // 配置 ChannelPipeline
                         ch.pipeline().addLast(new MyHandler());
                     }
                 });
        return bootstrap;
    }
}

3.2.2 启动顺序

Netty 服务器的启动需要在 Spring Boot 应用完全初始化之后进行，以确保 Spring 的 Bean 已经准备好。

1. 在 SpringApplication.run() 之后启动

  • 使用 ApplicationRunner 或 CommandLineRunner 接口启动 Netty 服务器。
java 复制代码 
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;
import io.netty.channel.ChannelFuture;
import javax.annotation.Resource;

@Component
public class NettyServerRunner implements ApplicationRunner {

    @Resource
    private ServerBootstrap serverBootstrap;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        ChannelFuture future = serverBootstrap.bind(8081).sync();
        System.out.println("Netty Server started on port 8081");
        future.channel().closeFuture().sync();
    }
}

2. 确保 Spring Bean 已初始化

  • 在 Netty 的 Handler 中可以通过依赖注入使用 Spring 的 Bean。
java 复制代码 
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import org.springframework.stereotype.Component;

@Component
public class MyHandler extends SimpleChannelInboundHandler<String> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) {
        // 处理消息
        System.out.println("Received: " + msg);
        ctx.writeAndFlush("Echo: " + msg);
    }
}

3.2.3 适用场景

1. 聊天、游戏、物联网等长连接服务

  • Netty 非常适合处理长连接场景，如即时通讯、游戏服务器、物联网设备通信等。

2. 自定义 TCP/UDP/WebSocket 协议

  • 如果需要处理自定义协议，Netty 提供了灵活的 API 来实现协议编解码。

3.2.4 具体使用实例：简易聊天室

下面我们通过一个 简易聊天室 的实例，展示如何使用 Netty 实现 WebSocket 服务器，并与 Spring Boot 集成。

1. WebSocket 基础

  • WebSocket 是一种全双工通信协议，适用于即时消息、聊天室、推送通知等场景。

  • Netty 提供了对 WebSocket 的支持，可以通过 WebSocketServerProtocolHandler 快速实现 WebSocket 服务器。

2. Netty WebSocket Pipeline 配置

  • 配置 HttpServerCodec、HttpObjectAggregator 和 WebSocketServerProtocolHandler。
java 复制代码 
import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;

public class WebSocketServerInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) {
        ch.pipeline().addLast(new HttpServerCodec()); // HTTP 编解码器
        ch.pipeline().addLast(new HttpObjectAggregator(65536)); // 聚合 HTTP 请求
        ch.pipeline().addLast(new WebSocketServerProtocolHandler("/ws")); // WebSocket 协议处理器
        ch.pipeline().addLast(new ChatHandler()); // 自定义处理器
    }
}

3. ChatHandler 实现

  • 处理 WebSocket 连接、消息接收和广播。
java 复制代码 
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.util.concurrent.GlobalEventExecutor;

public class ChatHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {

    private static final ChannelGroup channels = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) {
        Channel incoming = ctx.channel();
        channels.add(incoming);
        System.out.println("Client connected: " + incoming.remoteAddress());
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) {
        Channel incoming = ctx.channel();
        channels.remove(incoming);
        System.out.println("Client disconnected: " + incoming.remoteAddress());
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) {
        String message = msg.text();
        System.out.println("Received: " + message);
        // 广播消息
        channels.writeAndFlush(new TextWebSocketFrame("Broadcast: " + message));
    }
}

4. 与 Spring Boot 集成

  • 在 Spring Boot 中初始化 Netty WebSocket 服务器。
java 复制代码 
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class WebSocketServerConfig {

    @Bean
    public EventLoopGroup bossGroup() {
        return new NioEventLoopGroup(1);
    }

    @Bean
    public EventLoopGroup workerGroup() {
        return new NioEventLoopGroup();
    }

    @Bean
    public ServerBootstrap serverBootstrap() {
        ServerBootstrap bootstrap = new ServerBootstrap();
        bootstrap.group(bossGroup(), workerGroup())
                 .channel(NioServerSocketChannel.class)
                 .childHandler(new WebSocketServerInitializer());
        return bootstrap;
    }
}

5. 启动 Netty WebSocket 服务器

  • 使用 ApplicationRunner 启动 Netty 服务器。
java 复制代码 
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;
import io.netty.channel.ChannelFuture;
import javax.annotation.Resource;

@Component
public class WebSocketServerRunner implements ApplicationRunner {

    @Resource
    private ServerBootstrap serverBootstrap;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        ChannelFuture future = serverBootstrap.bind(8081).sync();
        System.out.println("WebSocket Server started on port 8081");
        future.channel().closeFuture().sync();
    }
}

3.3 方式三：Spring Boot + Netty 文件服务

注意！

  • 以下方案中所谓的方式三其实也是类似于方式二，也是单独搭建了个服务器，只不过这里搭建的这个Netty服务器与上面的Netty服务器的内部组件不一样。
  • 不需要排除 Tomcat；让 Spring Boot 正常启动 Tomcat 处理 server.port=8080 上的 REST、网页、静态资源等。同时，你手动初始化一个 Netty 服务器监听 另一 端口（如 9090），处理你想交给 Netty 的 HTTP 任务（这里示例了文件下载）。
  • 其实完全可以通过使用Spring WebFlux替代Spring MVC来去享受Netty的异步与高并发特性，因为Spring WebFlux的底层就是Reactor Netty（又对Netty做了封装），这种方式可以不用自己去搭建Netty服务器，更加方便。

3.3.1. 为什么要让 Tomcat 与 Netty 共存？

  • 保留 Spring MVC 的便利

    • Spring Boot 默认整合 Tomcat，使用 @RestController、@RequestMapping 等注解式模式非常简单高效。
    • 提供常规 Web API、静态资源、过滤器等功能也不需要额外配置。

  • 同时享受 Netty 的高性能/高灵活

    • Netty 对高并发、大文件、WebSocket、TCP/UDP、自定义协议等场景具有强大支持。
    • 某些场景想用原生 Netty 来深度定制数据传输或协议处理，Tomcat 不方便做这一块。

  • 不同端口分工

    • Tomcat：以默认的 8080（或其他）端口运行，处理常规请求。
    • Netty：以 9090（或其他）端口运行，用于高并发文件下载、WebSocket 聊天、RPC 等需求。

结论 ：二者并存可以让你 在一个项目 中统一管理依赖与配置，既不失去 Tomcat 的开发便利，也能引入 Netty 做特定高性能/自定义场景。

3.3.2. 项目依赖与结构

Maven 依赖

XML 复制代码 
<dependencies>
    <!-- Spring Boot Web Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <!-- 注意：不排除Tomcat -->
    </dependency>

    <!-- Netty 核心依赖 -->
    <dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>
        <version>4.1.68.Final</version>
    </dependency>
</dependencies>
  • spring-boot-starter-web：Spring MVC + 内嵌 Tomcat。
  • netty-all：引入 Netty 的全部组件，方便示例；生产可精简。

目录示例

XML 复制代码 
src/main/java
└── com.example.demo
    ├── DemoApplication.java                   # Spring Boot 启动入口
    ├── controller
    │    └── HelloController.java              # Tomcat 默认处理
    ├── netty
    │    ├── NettyHttpProperties.java          # Netty的配置读取
    │    ├── NettyHttpServerConfig.java        # Netty线程组、ServerBootstrap
    │    ├── HttpFileServerHandler.java        # 自定义Handler, 提供HTTP下载
    │    └── NettyServerRunner.java            # 绑定端口, 启动Netty
    └── ...
src/main/resources
└── application.properties

application.properties

java 复制代码 
# ========== Tomcat配置 ==========
server.port=8080

# ========== Netty配置 ==========
netty.http.port=9090
netty.http.baseDir=D:/netty-files
netty.http.bossThreads=1
netty.http.workerThreads=4
  • server.port=8080：Spring Boot 默认 Tomcat 的端口；
  • netty.http.port=9090：Netty 的端口；
  • netty.http.baseDir：文件存放目录（如 D:/netty-files）；
  • netty.http.bossThreads、netty.http.workerThreads：Netty 线程数。

3.3.3 Tomcat 保留

示例：HelloController

java 复制代码 
package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 这是一个走Tomcat容器的普通Spring MVC接口
 */
@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello from Tomcat (default port 8080)!";
    }
}
  • 你可以访问 http://localhost:8080/hello 即可看到此响应。
  • Tomcat 会自动在端口 server.port=8080（若不指定则 8080）运行。

3.3.4 Netty 服务器配置

NettyHttpProperties

先做一个专门的配置类用于读取 Netty 端口、线程数以及文件根目录等信息：

java 复制代码 
package com.example.demo.netty;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties(prefix = "netty.http")
public class NettyHttpProperties {

    private int port;           // Netty监听端口
    private String baseDir;     // 本地文件存储根目录
    private int bossThreads;    // bossGroup线程数
    private int workerThreads;  // workerGroup线程数

    // Getter/Setter
    public int getPort() {
        return port;
    }
    public void setPort(int port) {
        this.port = port;
    }
    public String getBaseDir() {
        return baseDir;
    }
    public void setBaseDir(String baseDir) {
        this.baseDir = baseDir;
    }
    public int getBossThreads() {
        return bossThreads;
    }
    public void setBossThreads(int bossThreads) {
        this.bossThreads = bossThreads;
    }
    public int getWorkerThreads() {
        return workerThreads;
    }
    public void setWorkerThreads(int workerThreads) {
        this.workerThreads = workerThreads;
    }
}

要点：

  • @Configuration + @ConfigurationProperties(prefix = "netty.http") 会让 Spring Boot 自动从 application.properties 中读取 netty.http.* 配置并注入到该类。
  • 这样就能在其他地方 @Autowired NettyHttpProperties 来使用。

NettyHttpServerConfig

创建并配置 ServerBootstrap 等核心 Bean：

java 复制代码 
package com.example.demo.netty;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.*;
import io.netty.handler.stream.ChunkedWriteHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class NettyHttpServerConfig {

    @Bean
    public EventLoopGroup bossGroup(NettyHttpProperties props) {
        return new NioEventLoopGroup(props.getBossThreads());
    }

    @Bean
    public EventLoopGroup workerGroup(NettyHttpProperties props) {
        return new NioEventLoopGroup(props.getWorkerThreads());
    }

    @Bean
    public ServerBootstrap serverBootstrap(EventLoopGroup bossGroup,
                                          EventLoopGroup workerGroup,
                                          NettyHttpProperties props,
                                          HttpFileServerHandler fileHandler) {
        // 创建ServerBootstrap
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workerGroup)
         .channel(NioServerSocketChannel.class)
         .childHandler(new ChannelInitializer<Channel>() {
             @Override
             protected void initChannel(Channel ch) {
                 // 初始化pipeline
                 ch.pipeline().addLast(new HttpServerCodec());          // HTTP编解码
                 ch.pipeline().addLast(new HttpObjectAggregator(65536));// 聚合HTTP消息
                 ch.pipeline().addLast(new HttpContentCompressor());    // 响应压缩(可选)
                 ch.pipeline().addLast(new ChunkedWriteHandler());      // 大数据流写支持
                 ch.pipeline().addLast(fileHandler);                    // 自定义文件处理
             }
         });
        return b;
    }
}

逐段解释：

  • EventLoopGroup bossGroup、EventLoopGroup workerGroup

    • Netty 典型的双线程组模型：一个专门处理连接（bossGroup），另一个处理读写（workerGroup）。
    • 线程数从 NettyHttpProperties 读出，便于后期调整。

  • ServerBootstrap

    • group(...) 传入这两个线程组；

    • channel(NioServerSocketChannel.class) 表示用 NIO 实现；

    • childHandler(...) 给每个连接的 Channel 初始化 pipeline：

      • HttpServerCodec：将字节流与 HTTP 对象互相转换
      • HttpObjectAggregator(65536) ：把分段的请求合并成 FullHttpRequest，方便后面处理
      • HttpContentCompressor()：可选，对响应进行 gzip 等压缩
      • ChunkedWriteHandler()：分块写大数据
      • HttpFileServerHandler：自定义的业务处理（文件下载、请求路由等）。

HttpFileServerHandler

这是一个 Netty Handler ，示例展示如何提供文件下载 功能。例如，当访问 GET http://localhost:9090/download?filename=xxx 时，把对应的文件返回给客户端。

java 复制代码 
package com.example.demo.netty;

import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.handler.codec.http.*;
import io.netty.handler.stream.ChunkedStream;
import io.netty.util.CharsetUtil;
import org.springframework.stereotype.Component;

import java.io.File;
import java.io.FileInputStream;

@Component
@ChannelHandler.Sharable
public class HttpFileServerHandler extends SimpleChannelInboundHandler<FullHttpRequest> {

    private final NettyHttpProperties props;

    public HttpFileServerHandler(NettyHttpProperties props) {
        this.props = props;
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
        // 解析URI和查询参数
        QueryStringDecoder decoder = new QueryStringDecoder(request.uri());
        String path = decoder.path();            // e.g. "/download"
        String filename = null;
        if (decoder.parameters().containsKey("filename")) {
            filename = decoder.parameters().get("filename").get(0);
        }

        // 如果路径不是/download 或没有filename参数, 返回错误
        if (!"/download".equals(path) || filename == null) {
            sendError(ctx, HttpResponseStatus.NOT_FOUND, "Usage: /download?filename=xxx");
            return;
        }

        // 构造文件对象
        File file = new File(props.getBaseDir(), filename);
        if (!file.exists() || !file.isFile()) {
            sendError(ctx, HttpResponseStatus.NOT_FOUND, "File not found: " + filename);
            return;
        }

        // 返回文件数据
        writeFileResponse(ctx, file);
    }

    /**
     * 将文件内容通过HTTP响应写回
     */
    private void writeFileResponse(ChannelHandlerContext ctx, File file) throws Exception {
        // 1) 先写一个响应头
        HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);

        long fileLength = file.length();
        response.headers().set(HttpHeaderNames.CONTENT_LENGTH, fileLength);
        response.headers().set(HttpHeaderNames.CONTENT_TYPE, "application/octet-stream");
        // 告知客户端以附件形式下载
        response.headers().set(HttpHeaderNames.CONTENT_DISPOSITION, "attachment; filename=\"" + file.getName() + "\"");

        ctx.write(response);

        // 2) ChunkedStream 方式写文件内容
        FileInputStream fis = new FileInputStream(file);
        HttpChunkedInput chunkedInput = new HttpChunkedInput(new ChunkedStream(fis));

        ChannelFuture sendFileFuture = ctx.writeAndFlush(chunkedInput);
        sendFileFuture.addListener((ChannelFutureListener) future -> {
            fis.close();
        });
    }

    private void sendError(ChannelHandlerContext ctx, HttpResponseStatus status, String msg) {
        FullHttpResponse response = new DefaultFullHttpResponse(
                HttpVersion.HTTP_1_1, status,
                Unpooled.copiedBuffer(msg, CharsetUtil.UTF_8)
        );
        response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8");
        // 响应后关闭连接
        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    }
}

核心逻辑：

  • channelRead0：

    • 接收到一个完整的 FullHttpRequest；
    • 我们解析 uri，只处理 "/download" 路径，且需要一个 filename 查询参数；
    • 如果文件不存在或参数缺失，就返回错误给客户端。

  • writeFileResponse：

    • 先写一个 HTTP 响应行与头部，包含 Content-Length、Content-Type、Content-Disposition 等；
    • 使用 ChunkedStream 分块传输文件数据，无需把文件读进内存；
    • 也可以使用 DefaultFileRegion 实现零拷贝，但需考虑操作系统对 sendfile() 的支持，以及禁用 HttpContentCompressor（零拷贝与压缩冲突）。

  • @ChannelHandler.Sharable：

    • 表示此 Handler 可以被多个 Channel 共享（前提：无内部状态竞争）。

NettyServerRunner

最后，用 ApplicationRunner 来在 Spring Boot 启动完成后，绑定 Netty 的端口。二者（Tomcat 与 Netty）在同一进程运行，只是端口不同。

java 复制代码 
package com.example.demo.netty;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

@Component
public class NettyServerRunner implements ApplicationRunner {

    @Resource
    private ServerBootstrap serverBootstrap;

    @Resource
    private NettyHttpProperties props;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        // 绑定Netty端口(与Tomcat不同)
        ChannelFuture future = serverBootstrap.bind(props.getPort()).sync();
        System.out.println("Netty Server started on port " + props.getPort());

        // 阻塞等待关闭事件
        future.channel().closeFuture().sync();
    }
}

解释：

  • serverBootstrap.bind(props.getPort())：如 9090。
  • sync()：阻塞当前线程直到绑定成功；若失败会抛出异常。
  • closeFuture().sync()：保证 Netty 不会提前退出，一直运行到收到关闭事件。

3.3.5. 特殊说明

  • 统一域名？

    • 若要在同一域名上，只是不同端口，如 http://yourdomain:8080 与 http://yourdomain:9090；
    • 如果想只对外暴露 80/443 等标准端口，可使用 Nginx 反向代理：
      • 路径 /api -> 8080 (Tomcat)
      • 路径 /files -> 9090 (Netty)
    • 这样客户端感知不到两个不同端口。

  • 上传功能

    • 当前 Handler 只演示下载，若需要文件上传（POST /upload），可在 HttpFileServerHandler 中解析 multipart/form-data。
    • Netty 官方提供 HttpPostRequestDecoder，或你自己处理二进制流。

  • 零拷贝

    • 对超大文件下载，你可改用 DefaultFileRegion。注意：若要开启零拷贝，就需关闭 HttpContentCompressor（否则压缩与零拷贝冲突）。
    • 同时确认操作系统支持 sendfile。

  • 性能调优

    • Tomcat 与 Netty 线程数都可自定义，根据机器 CPU 核数、预计并发量进行调优。
    • 如果 Netty 主要用来跑大文件下载，可适当提高 workerThreads，并使用 EpollEventLoopGroup（Linux下）来进一步提升性能。

  • 会不会造成资源浪费？

    • 在某些场景下，两套容器各自占用线程池与内存。但这是必要的代价，如果你确实需要保留 Tomcat 的生态又想使用 Netty 特性。

  • 安全考虑

    • 如果要 HTTPS，可以分别对 Tomcat 和 Netty 做 SSL 配置（Tomcat SSL Connector、Netty SslHandler）。
    • 如果需要统一认证，可以让两端共享同一个认证服务或 token 验证逻辑。
相关推荐
等一场春雨2 分钟前
Java设计模式 十四 行为型模式 (Behavioral Patterns)
java·开发语言·设计模式
黄金小码农27 分钟前
C语言二级 2025/1/20 周一
c语言·开发语言·算法
萧若岚31 分钟前
Elixir语言的Web开发
开发语言·后端·golang
wave_sky35 分钟前
解决使用code命令时的bash: code: command not found问题
开发语言·bash
水银嘻嘻1 小时前
【Mac】Python相关知识经验
开发语言·python·macos
ac-er88881 小时前
Yii框架中的多语言支持：如何实现国际化
android·开发语言·php
酱学编程1 小时前
java中的单元测试的使用以及原理
java·单元测试·log4j
我的运维人生1 小时前
Java并发编程深度解析：从理论到实践
java·开发语言·python·运维开发·技术共享
一只爱吃“兔子”的“胡萝卜”2 小时前
2.Spring-AOP
java·后端·spring
HappyAcmen2 小时前
Java中List集合的面试试题及答案解析
java·面试·list
热门推荐
01xgboost: Why not implement distributed XGBoost on top of spark02Dell服务器升级ubuntu 22.04失败解决03半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)04密码学原理技术-第六章-introduction to pulibc-key cryptography05(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明06优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间07centos7 init.d 和system.d08Windows10安装PCL1.14.0及点云配准09渗透测试之SQLMAP工具详解 kali自带SQLmap解释 重点sqlmap --tamper 使用方式详解 搞完你就很nice了10ChatGPT + Stable Diffusion + 百度AI + MoviePy 实现文字生成视频，小说转视频，自媒体神器！(二)