构建高性能网络服务：从 Socket 原理到 Netty 应用实践

1. 引言

在 Java 网络编程中，Socket 是实现网络通信的基础（可以查看我的上一篇博客）。它封装了 TCP/IP 协议栈，提供了底层通信的核心能力。而 Netty 是在 Socket 和 NIO 的基础上，进一步封装的高性能、异步事件驱动的网络框架，简化了复杂的网络编程。

为什么需要学习 Socket？
学习 Netty 之前，理解 Socket 的基本原理（如 TCP 三次握手、四次挥手、阻塞和非阻塞 I/O 模型等）是必不可少的。Netty 的优势在于简化了这些底层细节，但要灵活掌握 Netty，我们需要具备对 Socket 的基本认识。可以参考我的上一篇博客，其中详细讲解了以下内容：

Socket 基础：什么是 Socket？它在 TCP/IP 协议中的角色。
Socket 通信模型：阻塞式 I/O 和非阻塞式 I/O 的区别与使用场景。
多线程并发 Socket 服务器实现：从简单的 Echo 服务到并发服务器的完整代码示例。
TCP 粘包与拆包问题：及其在 Socket 编程中的解决方法。

Netty 的核心优势

简化开发流程
- 不需要手动管理 Selector、Channel 等底层细节。
- 内置多种编解码器，屏蔽二进制数据读写的复杂性。
性能优异
- 高并发处理能力，通过事件循环机制轻松处理大量连接请求。
- 支持零拷贝技术和内存池，减少内存复制，提高吞吐量。
解决常见问题
- 轻松解决粘包与拆包问题，提供多种解码器如 FixedLengthFrameDecoder、DelimiterBasedFrameDecoder 等。
- 提供灵活的 ByteBuf 管理，简化内存管理操作。
功能强大且可扩展
- 提供模块化架构，可轻松扩展功能，如自定义协议、日志监控等。
- 支持多种协议（如 HTTP、WebSocket、UDP），满足不同场景需求。
被广泛验证的可靠性
Netty 已被数百个商业项目验证，并成为分布式系统的基础组件，例如：
- gRPC、Dubbo：主流分布式通信框架。
- RocketMQ：高性能分布式消息队列。
- Spring WebFlux：提供异步非阻塞的 HTTP 通信能力。
易用性强
- Netty 提供了简洁直观的 API，使开发者能够专注于业务逻辑实现，而无需关心复杂的 I/O 细节。

典型应用场景

高并发服务器：如 HTTP 服务器、网关服务。
即时通讯系统：如在线聊天室、IM 应用等。
文件传输系统：如大文件上传、下载服务。
物联网通信：用于大规模设备间的数据上报与控制。

综上所述，Netty 是目前最流行的 NIO 框架，其健壮性、性能、可定制性和可扩展性在同类框架中首屈一指。学习 Netty 不仅需要理解其 API，还需要掌握其底层的事件驱动模型和线程池机制。通过本文的学习，我们将从 Netty 基础入门到拆包粘包问题示例，深入探索如何构建高性能的网络应用程序。

Netty架构图:

在这里插入图片描述

Netty特性:

在这里插入图片描述

4. Netty 快速入门示例

4.1 Netty 实现通信的步骤

Netty 客户端和服务器端的实现步骤基本一致，以下为实现通信的典型流程：

创建两个 NIO 线程组：
- 一个线程组专门用于处理网络事件（接收客户端连接）。
- 另一个线程组进行网络通信中的读写操作。
创建 ServerBootstrap（服务端）或 Bootstrap（客户端）对象：
- 这是 Netty 启动引导类，用于配置 Netty 的一系列参数，例如接收/发送缓冲区大小等。
创建 ChannelInitializer 类：
- 该类用于进行 Channel 的初始化配置，如设置字符集、数据格式、处理数据的 Handler。
绑定端口（服务端）或连接地址和端口（客户端）：
- 使用 bind() 方法绑定端口，connect() 方法进行连接。
- 使用 sync() 同步阻塞方法等待服务器端启动完成。

Netty的使用非常简单，仅仅引入依赖即可快速开始:

对于 Java 8 项目，Netty 版本建议选择 4.1.94.Final，该版本为长期维护版（LTS），稳定性较高。

<dependency><groupId>io.netty</groupId><artifactId>netty-all</artifactId><version>4.1.94.Final</version>
</dependency>

4.2 服务端示例

以下是完整的 Netty 服务端代码示例，展示了如何快速搭建一个简单的网络服务：

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;public class NettyServer {public static void main(String[] args) throws InterruptedException {// 创建两个 NIO 线程组EventLoopGroup bossGroup = new NioEventLoopGroup(1);  // 处理客户端连接EventLoopGroup workerGroup = new NioEventLoopGroup();  // 进行读写操作try {// 创建 ServerBootstrap 对象，配置 Netty 参数ServerBootstrap bootstrap = new ServerBootstrap();bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)  // 指定 NIO 传输方式.childHandler(new ChannelInitializer<SocketChannel>() {  // 初始化 Handler@Overrideprotected void initChannel(SocketChannel ch) {ch.pipeline().addLast(new NettyServerHandler());  // 添加处理器}});// 绑定端口，并同步等待启动ChannelFuture future = bootstrap.bind(8080).sync();System.out.println("服务器启动成功，端口：8080");// 阻塞等待关闭future.channel().closeFuture().sync();} finally {bossGroup.shutdownGracefully();  // 优雅关闭线程组workerGroup.shutdownGracefully();}}
}

说明：

NioServerSocketChannel：使用 NIO 方式接收客户端连接。
NettyServerHandler：自定义数据处理器，用于处理客户端发送的数据。

4.3 客户端示例

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;public class NettyClient {public static void main(String[] args) throws InterruptedException {// 创建 NIO 线程组EventLoopGroup group = new NioEventLoopGroup();try {// 创建 Bootstrap 对象Bootstrap bootstrap = new Bootstrap();bootstrap.group(group).channel(NioSocketChannel.class)  // 使用 NIO 通道类型.handler(new ChannelInitializer<Channel>() {@Overrideprotected void initChannel(Channel ch) {ch.pipeline().addLast(new NettyClientHandler());  // 添加客户端 Handler}});// 连接到服务器ChannelFuture future = bootstrap.connect("localhost", 8080).sync();System.out.println("客户端已连接到服务器");future.channel().closeFuture().sync();} finally {group.shutdownGracefully();  // 优雅关闭线程组}}
}

说明：

NioSocketChannel：NIO 传输方式，用于客户端连接。
NettyClientHandler：客户端处理器，用于发送数据或接收服务器响应。

4.4 关键类说明

ServerBootstrap / Bootstrap：Netty 启动引导类，配置线程组、处理器等。
EventLoopGroup：线程组，管理 I/O 线程池，处理网络事件。
ChannelInitializer：初始化 Channel，设置 Handler（如 NettyServerHandler）。
ChannelHandler：用于定义数据的处理逻辑。

4.5 完整运行步骤

引入依赖：
- 添加 Netty 依赖到项目的 pom.xml 中。
编写 Netty 服务端代码，启动服务器监听端口 8080。
编写 Netty 客户端代码，连接到服务器。
客户端发送数据，服务器接收并回显。

输出示例

服务器端输出：

服务器启动成功，端口：8080
新客户端已连接：/127.0.0.1
收到客户端消息：Hello Netty

客户端输出：

客户端已连接到服务器
收到服务器响应：Hello Netty

通过引入简单的依赖配置和少量代码，即可快速搭建基于 Netty 的高效网络通信服务，帮助我们轻松实现高并发、高性能的网络应用。

5. Netty 主要 API 介绍

在使用 Netty 时，理解其核心组件和常用方法是至关重要的。这些组件和方法构成了 Netty 框架的基础，帮助开发者灵活地进行网络应用开发。以下是对 Netty 核心组件及常用方法的详细说明。

5.1 核心组件

1. EventLoopGroup（事件循环组）

EventLoopGroup 是 Netty 的线程组接口，主要用于管理线程池，负责处理 I/O 事件和任务调度。Netty 使用了事件循环机制，通过 EventLoopGroup 来管理多个 EventLoop，每个 EventLoop 绑定到一个 Channel，以单线程方式处理 I/O 事件。

常见子类：
- NioEventLoopGroup：基于 NIO 实现的事件循环组，适用于大多数场景。
- EpollEventLoopGroup：基于 Linux 的高性能 Epoll 实现，仅支持 Linux 平台。
- DefaultEventLoopGroup：非 I/O 任务的默认事件循环组。
用途：
- 服务端需要两个 EventLoopGroup：
  - bossGroup：负责监听客户端的连接请求。
  - workerGroup：负责处理客户端的数据读写请求。
示例：

EventLoopGroup bossGroup = new NioEventLoopGroup(1);  // 只需 1 个线程接受连接
EventLoopGroup workerGroup = new NioEventLoopGroup();  // 处理读写操作的线程数为 CPU 核心数 * 2

2. Channel（通道）

Channel 是 Netty 对网络连接的抽象，表示网络通信的数据通道。它用于读写数据，并且 Netty 对 Channel 的读写是异步的。

常见子类：
- NioSocketChannel：表示客户端的连接通道，基于 NIO 实现。
- NioServerSocketChannel：表示服务端监听通道，接收客户端的连接。
常用方法：
- writeAndFlush(Object msg)：向 Channel 写入数据并立即刷新。
- close()：关闭 Channel，断开连接。
示例：

Channel channel = ctx.channel();  // 获取当前通道
channel.writeAndFlush("Hello Netty!");  // 向客户端发送消息

3. Pipeline（管道）

Pipeline 是 Netty 责任链模式的实现，用于管理一系列的处理器（Handler），处理数据的输入和输出。Netty 通过 Pipeline 实现对网络事件的处理流程控制。

每个 Channel 都有一个 ChannelPipeline，其中可以添加多个 ChannelHandler 进行数据处理。
Pipeline 是双向链表，支持前向和后向传递事件。
常用方法：
- addLast(ChannelHandler handler)：将 Handler 添加到管道末尾。
- addFirst(ChannelHandler handler)：将 Handler 添加到管道最前面。
示例：

ch.pipeline().addLast(new StringDecoder());  // 添加解码器
ch.pipeline().addLast(new NettyServerHandler());  // 添加自定义业务处理器

说明：

入站处理器：处理客户端发来的请求，如 StringDecoder 解码器。
出站处理器：处理返回给客户端的数据，如 StringEncoder 编码器。

4. ChannelHandler（事件处理器）

ChannelHandler 是 Netty 中事件处理器的接口，用于对网络事件（如数据读写、异常）进行处理。ChannelHandler 分为两种类型：

ChannelInboundHandler：入站事件处理器，处理数据读取事件。
ChannelOutboundHandler：出站事件处理器，处理数据写出事件。
常用方法：
- channelRead(ChannelHandlerContext ctx, Object msg)：读取客户端发送的数据。
- write(ChannelHandlerContext ctx, Object msg)：向客户端写出数据。
- exceptionCaught(ChannelHandlerContext ctx, Throwable cause)：处理异常。
示例：

public class NettyServerHandler extends ChannelInboundHandlerAdapter {@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {System.out.println("收到消息：" + msg);ctx.writeAndFlush("服务器已接收：" + msg);}@Overridepublic void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {cause.printStackTrace();  // 打印异常堆栈ctx.close();  // 关闭连接}
}

5.2 常用方法

1. `bind()`

作用：绑定端口，用于启动服务端监听指定端口。
调用示例：

bootstrap.bind(8080).sync();  // 绑定端口 8080，并同步等待启动

说明：bind() 返回 ChannelFuture，通过 sync() 方法阻塞等待端口绑定完成。

2. `connect()`

作用：连接到指定地址和端口，用于客户端连接到服务器。
调用示例：

bootstrap.connect("localhost", 8080).sync();  // 连接到本地 8080 端口的服务器

说明：connect() 方法也返回 ChannelFuture，可以通过回调函数监控连接状态。

3. `addLast()`

作用：将 ChannelHandler 添加到 Pipeline 的末尾。
调用示例：

pipeline.addLast(new StringDecoder());  // 添加字符串解码器
pipeline.addLast(new NettyServerHandler());  // 添加自定义业务处理器

说明：addLast() 通常用于添加输入、输出数据的编解码器以及自定义的业务逻辑处理器。

4. `addFirst()`

作用：将 ChannelHandler 添加到 Pipeline 的最前面。
调用示例：

pipeline.addFirst(new LoggingHandler(LogLevel.INFO));  // 在数据流入时先打印日志

使用场景：如需在数据流入时进行日志记录、身份校验等操作，可以优先添加处理器。

5. `writeAndFlush()`

作用：将数据写入 Channel 并立即刷新，确保数据被发送出去。
调用示例：

ctx.writeAndFlush("Hello, Netty!");

说明：Netty 的 I/O 操作是异步的，因此调用 writeAndFlush() 需要手动刷新数据以立即发送。

5.3 示例代码说明

以下示例演示了 Pipeline 如何通过责任链模式调用 ChannelHandler：

ch.pipeline().addLast(new StringDecoder());  // 解码入站数据
ch.pipeline().addLast(new StringEncoder());  // 编码出站数据
ch.pipeline().addLast(new NettyServerHandler());  // 添加业务处理器

在这里：

客户端发送字符串数据时，StringDecoder 将其解码为 String。
服务器通过 NettyServerHandler 读取数据并处理逻辑。
服务器返回响应时，StringEncoder 将 String 编码为字节流发送给客户端。

总结

通过 EventLoopGroup 线程池、Channel 通道、Pipeline 责任链和 Handler 事件处理器，Netty 构建了高效的异步 I/O 处理机制。熟练掌握这些核心组件及其方法，可以帮助我们轻松实现高并发、高性能的网络应用。

6. TCP 拆包与粘包问题

在基于 TCP 协议的网络编程中，数据传输是以字节流的形式进行的，发送方和接收方并不知道消息的边界。由于 TCP 是流式传输协议，没有消息的边界概念，因此会出现拆包和粘包问题。以下是对拆包和粘包问题的详细说明，以及常见的解决方案。

6.1 拆包与粘包的概念

1. 粘包（Packet Stickiness）

粘包是指发送方发送的多条消息被接收方合并成一条消息，即接收方在一次读取操作中读取到了多条消息的数据。

示例：
- 发送方
  
  发送了两条消息：
```
[Hello]
[World]
```
- 接收方
  
  在一次读取操作中读取到：
```
[HelloWorld]
```

2. 拆包（Packet Fragmentation）

拆包是指发送方发送的一条完整消息被接收方分成多次接收，即接收方在一次读取操作中只读取到消息的一部分。

示例：
- 发送方
  
  发送了一条消息：
```
[HelloWorld]
```
- 接收方
  
  第一次读取到：
```
[Hello]
```
- 接收方
  
  第二次读取到：
```
[World]
```

6.2 拆包与粘包的成因

网络传输协议特性：TCP 是流式传输协议，没有消息边界。
发送数据大小：数据量较大时，会被拆分成多个数据包传输。
接收缓存区大小：如果接收端缓存区较小，一次性无法接收完整数据，导致拆包。
操作系统协议栈优化：发送端会根据系统配置，将多条小数据合并成一个数据包，导致粘包。

6.3 拆包与粘包的影响

数据丢失：应用程序会将不完整的数据视为异常，导致通信失败。
数据错乱：数据包顺序错误或内容拼接错误，导致数据解析失败。
程序崩溃：如果程序没有考虑拆包和粘包情况，可能会在解析时抛出异常或崩溃。

6.4 拆包与粘包问题的解决方案

Netty 提供了多种内置编解码器，帮助开发者轻松处理拆包和粘包问题：

定长消息方案 (FixedLengthFrameDecoder)
固定长度读取数据，不足补齐。适用于固定格式的报文传输。
示例：报文格式 [Hello ]，长度固定为 10 字节。
分隔符方案 (DelimiterBasedFrameDecoder)
通过自定义分隔符划分消息边界。适用于文本协议数据传输。
示例：消息以 # 作为分隔符，如 Hello#Netty#。
消息头部方案 (LengthFieldBasedFrameDecoder)
消息前添加长度字段，指示消息体的长度。适用于变长二进制数据传输。
示例：[0005Hello]，前 4 个字节为消息长度，表示正文长度为 5 字节

6.5 Netty 编解码器使用示例

以下是 Netty 编解码器的完整示例，包含消息格式说明、解析方式、以及适用场景，帮助理解每种编解码器的应用场景和实现方式。

1. `FixedLengthFrameDecoder`（定长消息解码器）

消息格式

[Hello     ]  // 固定 10 字节长度的消息，不足用空格补齐

解析方式

每次读取固定长度的数据，如 10 字节。
超过或不足的部分被切割或补齐。

适用场景

金融系统报文传输：报文格式固定，长度一致。
设备通信协议：如固定格式的传感器数据上传。

完整示例代码

服务端代码：

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.FixedLengthFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;public class FixedLengthServer {public static void main(String[] args) throws InterruptedException {EventLoopGroup bossGroup = new NioEventLoopGroup(1);EventLoopGroup workerGroup = new NioEventLoopGroup();try {ServerBootstrap bootstrap = new ServerBootstrap();bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<SocketChannel>() {@Overrideprotected void initChannel(SocketChannel ch) {ch.pipeline().addLast(new FixedLengthFrameDecoder(10));  // 每条消息长度固定为 10 字节ch.pipeline().addLast(new StringDecoder());ch.pipeline().addLast(new SimpleServerHandler());}});ChannelFuture future = bootstrap.bind(8080).sync();System.out.println("FixedLength Server 已启动，端口：8080");future.channel().closeFuture().sync();} finally {bossGroup.shutdownGracefully();workerGroup.shutdownGracefully();}}static class SimpleServerHandler extends ChannelInboundHandlerAdapter {@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) {System.out.println("收到客户端消息：" + msg);ctx.writeAndFlush("服务端已收到：" + msg);}}
}

客户端代码：

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringEncoder;public class FixedLengthClient {public static void main(String[] args) throws InterruptedException {EventLoopGroup group = new NioEventLoopGroup();try {Bootstrap bootstrap = new Bootstrap();bootstrap.group(group).channel(NioSocketChannel.class).handler(new ChannelInitializer<Channel>() {@Overrideprotected void initChannel(Channel ch) {ch.pipeline().addLast(new StringEncoder());  // 添加字符串编码器}});Channel channel = bootstrap.connect("localhost", 8080).sync().channel();channel.writeAndFlush("Hello     ");  // 长度补齐至 10 字节} finally {group.shutdownGracefully();}}
}

2. `DelimiterBasedFrameDecoder`（分隔符解码器）

消息格式

Hello Netty#
How are you?#

解析方式

读取字节流，遇到 # 分隔符时，将其解析为一条完整的消息。
截取分隔符前的数据作为消息内容。

适用场景

文本协议：如聊天室、IM 系统。
简单 RPC 通信协议：以特定字符区分消息边界。

完整示例代码

服务端代码：

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.Unpooled;
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.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;public class DelimiterServer {public static void main(String[] args) throws InterruptedException {EventLoopGroup bossGroup = new NioEventLoopGroup(1);EventLoopGroup workerGroup = new NioEventLoopGroup();try {ServerBootstrap bootstrap = new ServerBootstrap();bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<SocketChannel>() {@Overrideprotected void initChannel(SocketChannel ch) {ch.pipeline().addLast(new DelimiterBasedFrameDecoder(1024, Unpooled.wrappedBuffer("#".getBytes())));ch.pipeline().addLast(new StringDecoder());ch.pipeline().addLast(new SimpleServerHandler());}});ChannelFuture future = bootstrap.bind(8080).sync();System.out.println("Delimiter Server 已启动，端口：8080");future.channel().closeFuture().sync();} finally {bossGroup.shutdownGracefully();workerGroup.shutdownGracefully();}}static class SimpleServerHandler extends ChannelInboundHandlerAdapter {@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) {System.out.println("收到客户端消息：" + msg);ctx.writeAndFlush("服务端已收到：" + msg + "#");}}
}

客户端代码：

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;public class DelimiterClient {public static void main(String[] args) throws InterruptedException {EventLoopGroup group = new NioEventLoopGroup();try {Bootstrap bootstrap = new Bootstrap();bootstrap.group(group).channel(NioSocketChannel.class).handler(new ChannelInitializer<Channel>() {@Overrideprotected void initChannel(Channel ch) {ch.pipeline().addLast(new SimpleClientHandler());}});Channel channel = bootstrap.connect("localhost", 8080).sync().channel();channel.writeAndFlush("Hello Netty#");channel.writeAndFlush("How are you?#");} finally {group.shutdownGracefully();}}static class SimpleClientHandler extends ChannelInboundHandlerAdapter {@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) {System.out.println("收到服务器消息：" + msg);}}
}

3. `LengthFieldBasedFrameDecoder`（基于消息头部的解码器）

消息格式

[0005Hello]  // 4 个字节的消息长度字段 + 消息正文

解析方式

读取前 4 个字节，获取消息长度 0005（5 字节）。
根据长度读取 Hello。

适用场景

二进制协议：如图片、视频等二进制数据传输。
文件传输：用于传输大文件时，精确获取数据长度。

完整示例代码

服务端代码：

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.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;public class LengthFieldServer {public static void main(String[] args) throws InterruptedException {EventLoopGroup bossGroup = new NioEventLoopGroup(1);EventLoopGroup workerGroup = new NioEventLoopGroup();try {ServerBootstrap bootstrap = new ServerBootstrap();bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<SocketChannel>() {@Overrideprotected void initChannel(SocketChannel ch) {ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(1024, 0, 4, 0, 4));ch.pipeline().addLast(new LengthFieldPrepender(4));ch.pipeline().addLast(new StringDecoder());ch.pipeline().addLast(new StringEncoder());ch.pipeline().addLast(new SimpleServerHandler());}});ChannelFuture future = bootstrap.bind(8080).sync();System.out.println("LengthField Server 已启动，端口：8080");future.channel().closeFuture().sync();} finally {bossGroup.shutdownGracefully();workerGroup.shutdownGracefully();}}static class SimpleServerHandler extends ChannelInboundHandlerAdapter {@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) {System.out.println("收到客户端消息：" + msg);ctx.writeAndFlush("服务端已收到：" + msg);}}
}

客户端代码：

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;public class LengthFieldClient {public static void main(String[] args) throws InterruptedException {EventLoopGroup group = new NioEventLoopGroup();try {Bootstrap bootstrap = new Bootstrap();bootstrap.group(group).channel(NioSocketChannel.class).handler(new ChannelInitializer<Channel>() {@Overrideprotected void initChannel(Channel ch) {ch.pipeline().addLast(new SimpleClientHandler());}});Channel channel = bootstrap.connect("localhost", 8080).sync().channel();channel.writeAndFlush("Hello LengthField Netty!");} finally {group.shutdownGracefully();}}
}