Java网络编程演进：从NIO到Netty的UDP实践全解析

前言

在当前高并发、大数据量的互联网环境下，高性能的网络通信框架变得越来越重要。本文将深入探讨Java网络编程的演进，从NIO到Netty，并通过实际案例分析Netty的优势和应用。（本次主要以UDP请求为例）

Java网络编程演进

传统的BIO（Blocking I/O）

• 每个连接一个线程
• 适用于连接数较少的场景
• 资源消耗大，连接数增加时性能下降明显

NIO（Non-blocking I/O）

• 引入了Channel、Buffer、Selector的概念
• 支持非阻塞I/O操作
• 可以用少量线程处理大量连接
• 编程模型复杂，开发难度大

Netty

• 基于NIO的异步事件驱动框架
• 简化了NIO编程模型
• 提供了丰富的协议支持和工具类
• 高性能、高可扩展性

比较

1. 传统NIO vs Netty

特性	传统NIO	Netty
编程复杂度	较高	较低
代码可维护性	较差	较好
内存管理	手动管理	自动管理(ByteBuf)
线程模型	需自行实现	已封装完善
处理粘包/拆包	需自行实现	提供多种编解码器

2. Tomcat vs Netty

特性	Tomcat	Netty
定位	Web容器	网络应用框架
协议支持	主要HTTP	多协议支持
性能	中等	高
使用场景	Web应用	通用网络服务

核心组件

1. Channel

Channel是Netty网络操作抽象类，包含了基本的I/O操作。

2. EventLoop

EventLoop负责处理注册到其上的Channel的所有I/O操作。

3. ChannelPipeline

ChannelPipeline提供了ChannelHandler链的容器，负责处理或拦截Channel的入站事件和出站操作。

网络协议支持

Netty支持多种协议，包括TCP和UDP。本文将重点介绍UDP协议的实现。

Maven依赖如下

        <dependency><groupId>io.netty</groupId><artifactId>netty-all</artifactId><version>4.1.100.Final</version></dependency><dependency><groupId>cn.hutool</groupId><artifactId>hutool-all</artifactId><version>5.8.35</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency>

1. NIO实现

1.1 服务端代码

NIO的UDP实现相对复杂，需要手动处理以下方面：

1. 创建和配置DatagramChannel
2. 设置非阻塞模式
3. 创建Selector并注册Channel
4. 实现事件循环来处理I/O事件
5. 手动管理ByteBuffer

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.charset.StandardCharsets;
import java.util.Iterator;
import java.util.Scanner;
import java.util.concurrent.ConcurrentHashMap;public class NioUdpServer {private static final int SERVER_PORT = 8080;private DatagramChannel datagramChannel;private Selector selector;private final ByteBuffer buffer = ByteBuffer.allocate(1024);private final ConcurrentHashMap<String, InetSocketAddress> clientAddresses = new ConcurrentHashMap<>();private volatile boolean running = true;public void start() throws IOException {// 创建DatagramChannel并配置为非阻塞模式datagramChannel = DatagramChannel.open();datagramChannel.configureBlocking(false);datagramChannel.bind(new InetSocketAddress(SERVER_PORT));// 创建Selector并注册channelselector = Selector.open();datagramChannel.register(selector, SelectionKey.OP_READ);System.out.println("NIO UDP Server started on port " + SERVER_PORT);// 启动发送消息的线程Thread senderThread = new Thread(this::handleUserInput);senderThread.start();// 主线程处理接收消息while (running) {try {if (selector.select() > 0) {Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();while (iterator.hasNext()) {SelectionKey key = iterator.next();iterator.remove();if (key.isReadable()) {handleRead(key);}}}} catch (IOException e) {e.printStackTrace();}}}private void handleRead(SelectionKey key) throws IOException {DatagramChannel channel = (DatagramChannel) key.channel();buffer.clear();InetSocketAddress clientAddress = (InetSocketAddress) channel.receive(buffer);if (clientAddress != null) {buffer.flip();String message = StandardCharsets.UTF_8.decode(buffer).toString();System.out.println("Received from " + clientAddress + ": " + message);// 保存客户端地址clientAddresses.put(clientAddress.toString(), clientAddress);// 发送确认消息String response = "Server received: " + message;sendMessage(response, clientAddress);}}private void handleUserInput() {Scanner scanner = new Scanner(System.in);while (running) {System.out.print("Enter message to broadcast (type 'exit' to quit): ");String message = scanner.nextLine();if ("exit".equalsIgnoreCase(message)) {running = false;break;}// 广播消息给所有已知客户端broadcastMessage(message);}scanner.close();}private void broadcastMessage(String message) {for (InetSocketAddress clientAddress : clientAddresses.values()) {sendMessage(message, clientAddress);}}private void sendMessage(String message, InetSocketAddress address) {try {ByteBuffer buffer = ByteBuffer.wrap(message.getBytes(StandardCharsets.UTF_8));datagramChannel.send(buffer, address);System.out.println("Sent to " + address + ": " + message);} catch (IOException e) {e.printStackTrace();}}public void stop() {running = false;try {if (selector != null) {selector.close();}if (datagramChannel != null) {datagramChannel.close();}} catch (IOException e) {e.printStackTrace();}}public static void main(String[] args) {try {new NioUdpServer().start();} catch (IOException e) {e.printStackTrace();}}
}

1.2 NIO实现服务端代码解析

(1) 通道配置

datagramChannel = DatagramChannel.open();
datagramChannel.configureBlocking(false);
datagramChannel.bind(new InetSocketAddress(SERVER_PORT));

解析：

• 手动创建 DatagramChannel，用于 UDP 传输

• 设置非阻塞模式，提高并发处理能力

• 显式绑定端口，监听 UDP 请求

---

(2) 选择器管理

selector = Selector.open();
datagramChannel.register(selector, SelectionKey.OP_READ);

解析：

• 手动创建 Selector，用于监听多个通道

• 注册 DatagramChannel 到 Selector，监听 OP_READ 事件

---

(3) 消息处理

private void handleRead(SelectionKey key) throws IOException {DatagramChannel channel = (DatagramChannel) key.channel();buffer.clear();InetSocketAddress clientAddress = (InetSocketAddress) channel.receive(buffer);// 处理消息
}

解析：

• 手动管理 ByteBuffer，需 flip() 切换读写模式

• 显式处理 receive() 解析数据

• 必须手动清理 buffer，避免数据残留

1.3 客户端代码

import lombok.extern.slf4j.Slf4j;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.charset.StandardCharsets;
import java.util.Iterator;
import java.util.Scanner;@Slf4j
public class NioUdpClient {private static final String SERVER_HOST = "127.0.0.1";private static final int SERVER_PORT = 8080;private static final int CLIENT_PORT = 9090;private DatagramChannel datagramChannel;private Selector selector;private final ByteBuffer buffer = ByteBuffer.allocate(1024);private volatile boolean running = true;public void start() throws IOException {// 创建DatagramChannel并配置为非阻塞模式datagramChannel = DatagramChannel.open();datagramChannel.configureBlocking(false);datagramChannel.bind(new InetSocketAddress(CLIENT_PORT));// 创建Selector并注册channelselector = Selector.open();datagramChannel.register(selector, SelectionKey.OP_READ);log.info("NIO UDP Client 使用端口为 {}", CLIENT_PORT);// 启动发送消息的线程Thread senderThread = new Thread(this::handleUserInput);senderThread.start();// 主线程处理接收消息while (running) {try {if (selector.select() > 0) {Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();while (iterator.hasNext()) {SelectionKey key = iterator.next();iterator.remove();if (key.isReadable()) {handleRead(key);}}}} catch (IOException e) {log.error("");}}}private void handleRead(SelectionKey key) throws IOException {DatagramChannel channel = (DatagramChannel) key.channel();buffer.clear();InetSocketAddress serverAddress = (InetSocketAddress) channel.receive(buffer);if (serverAddress != null) {buffer.flip();String message = StandardCharsets.UTF_8.decode(buffer).toString();log.info("从server接收到消息: {}", message);}}private void handleUserInput() {Scanner scanner = new Scanner(System.in);while (running) {log.info("输入消息并按回车发送 (type 'exit' to quit): ");String message = scanner.nextLine();if ("exit".equalsIgnoreCase(message)) {running = false;break;}sendMessage(message);}scanner.close();}private void sendMessage(String message) {try {ByteBuffer buffer = ByteBuffer.wrap(message.getBytes(StandardCharsets.UTF_8));InetSocketAddress serverAddress = new InetSocketAddress(SERVER_HOST, SERVER_PORT);datagramChannel.send(buffer, serverAddress);log.info("Sent to server: {}", message);} catch (IOException e) {log.error("发送失败,{}",e.getMessage());}}public void stop() {running = false;try {if (selector != null) {selector.close();}if (datagramChannel != null) {datagramChannel.close();}} catch (IOException e) {log.error("关闭Selector或DatagramChannel失败,{}", e.getMessage());}}public static void main(String[] args) {try {new NioUdpClient().start();} catch (IOException e) {log.error("启动失败, {}", e.getMessage());}}
}

1.4 NIO实现客户端代码解析

(1) 初始化

datagramChannel = DatagramChannel.open();
datagramChannel.configureBlocking(false);
datagramChannel.bind(new InetSocketAddress(CLIENT_PORT));

解析：

• 需要手动配置通道
• 显式设置客户端端口
• 手动管理资源生命周期

---

(2) 发送数据

ByteBuffer buffer = ByteBuffer.wrap(message.getBytes(StandardCharsets.UTF_8));
InetSocketAddress serverAddress = new InetSocketAddress(SERVER_HOST, SERVER_PORT);
datagramChannel.send(buffer, serverAddress);

解析：

• 手动管理 ByteBuffer

• 显式指定目标地址

• 同步发送消息

2. Netty实现

Netty的UDP实现简洁明了，主要涉及以下几个步骤：

1. 配置Bootstrap
2. 设置Channel类型为NioDatagramChannel
3. 配置ChannelHandler来处理数据收发

2.1 服务端代码

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioDatagramChannel;
import io.netty.channel.socket.DatagramPacket;
import io.netty.buffer.ByteBuf;
import io.netty.util.CharsetUtil;
import lombok.extern.slf4j.Slf4j;import java.net.InetSocketAddress;
@Slf4j
public class NettyUdpServer {public static void main(String[] args) throws InterruptedException {// 创建事件循环组，负责处理 I/O 操作EventLoopGroup group = new NioEventLoopGroup();try {// 创建引导程序，用于设置服务器参数Bootstrap b = new Bootstrap();b.group(group)// 设置通道类型为 NioDatagramChannel，适用于 UDP.channel(NioDatagramChannel.class)// 设置处理器.handler(new SimpleChannelInboundHandler<DatagramPacket>() {@Overrideprotected void channelRead0(ChannelHandlerContext ctx, DatagramPacket packet) throws Exception {// 获取客户端地址InetSocketAddress sender = packet.sender();// 获取接收到的数据ByteBuf buf = packet.content();String received = buf.toString(CharsetUtil.UTF_8);log.info("收到来自 {} 的消息: {}", sender, received);// 回复客户端String response = "消息已收到: " + received;ByteBuf responseBuf = ctx.alloc().buffer();responseBuf.writeBytes(response.getBytes(CharsetUtil.UTF_8));ctx.writeAndFlush(new DatagramPacket(responseBuf, sender));}});// 绑定端口并启动服务器ChannelFuture f = b.bind(8080).sync();log.info("UDP 服务器已启动，监听端口 8080");// 等待服务器通道关闭f.channel().closeFuture().await();} finally {// 关闭事件循环组group.shutdownGracefully();}}
}

2.2 Netty实现服务端代码解析

(1) Bootstrap 配置

Bootstrap b = new Bootstrap();
b.group(group).channel(NioDatagramChannel.class).handler(new SimpleChannelInboundHandler<DatagramPacket>()

解析：

• 使用 Bootstrap 而不是 ServerBootstrap，因为 UDP 是无连接的协议

• 使用 NioDatagramChannel 作为通道类型，专门用于 UDP 通信

• 通过 handler 处理数据包，定义如何解析和处理接收的数据

(2) 消息处理流程

protected void channelRead0(ChannelHandlerContext ctx, DatagramPacket packet) {InetSocketAddress sender = packet.sender();ByteBuf buf = packet.content();String received = buf.toString(CharsetUtil.UTF_8);// 处理消息并回复
}

解析：

• 通过 DatagramPacket 封装 UDP 数据包

• 使用 packet.sender() 获取发送方地址

• ByteBuf 处理二进制数据（Netty 提供的高效缓冲区）

• 自动释放 ByteBuf，避免手动管理内存

2.3 客户端代码

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.DatagramPacket;
import io.netty.channel.socket.nio.NioDatagramChannel;
import io.netty.util.CharsetUtil;import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;@Slf4j
@AllArgsConstructor
public class NettyUdpClient {private final String host;private final int port;private Channel channel;public void run() throws Exception {// 创建事件循环组EventLoopGroup group = new NioEventLoopGroup();try {// 创建客户端引导程序Bootstrap b = new Bootstrap();b.group(group)// 设置通道类型为 NioDatagramChannel.channel(NioDatagramChannel.class)// 设置处理器.handler(new SimpleChannelInboundHandler<DatagramPacket>() {@Overrideprotected void channelRead0(ChannelHandlerContext ctx, DatagramPacket packet) {// 接收并打印服务器的响应String response = packet.content().toString(CharsetUtil.UTF_8);log.info("收到服务器响应：{}", response);}@Overridepublic void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {log.error("客户端异常：", cause);}});// 绑定随机端口并等待channel = b.bind(0).sync().channel();log.info("UDP 客户端已启动，准备发送消息...");// 从控制台读取输入并发送BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));// 启动一个循环，不断从控制台读取输入while (true) {System.out.print("请输入要发送的消息(输入'exit'退出)：");String message = reader.readLine();// 如果输入exit则退出if ("exit".equalsIgnoreCase(message)) {log.info("客户端即将关闭...");break;}// 创建UDP数据包并发送ByteBuf buf = Unpooled.copiedBuffer(message, CharsetUtil.UTF_8);DatagramPacket packet = new DatagramPacket(buf, new InetSocketAddress(host, port));// 发送消息channel.writeAndFlush(packet).addListener((ChannelFutureListener) future -> {if (future.isSuccess()) {log.info("消息发送成功");} else {log.error("消息发送失败：{}", future.cause().getMessage());}});}// 关闭连接if (channel != null) {channel.close().sync();}} finally {// 优雅关闭事件循环组group.shutdownGracefully();}}public static void main(String[] args) throws Exception {// 默认连接本地8080端口String host = "127.0.0.1";int port = 8080;new NettyUdpClient(host, port, null).run();}
}

2.4 Netty实现客户端代码解析

(1) 初始化配置

Bootstrap b = new Bootstrap();
b.group(group).channel(NioDatagramChannel.class).handler(new SimpleChannelInboundHandler<DatagramPacket>()

解析：

• 与服务端类似，使用 NioDatagramChannel 处理 UDP 通信

• 客户端不需要绑定端口，可以随机使用本地端口发送数据

---

(2) 消息发送

ByteBuf buf = Unpooled.copiedBuffer(message, CharsetUtil.UTF_8);
DatagramPacket packet = new DatagramPacket(buf, new InetSocketAddress(host, port));
channel.writeAndFlush(packet)

解析：

• 使用 Unpooled.copiedBuffer 创建数据缓冲区

• DatagramPacket 封装目标地址

• writeAndFlush 异步发送数据

2.5 Netty小结特点

1. 支持异步发送确认
2. 灵活的消息收发处理
3. 优雅的关闭机制
4. 完善的异常处理

Netty实现UDP双向通信

服务端代码

package com.lps.netty;import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioDatagramChannel;
import io.netty.channel.socket.DatagramPacket;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.util.CharsetUtil;
import lombok.extern.slf4j.Slf4j;import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.util.HashSet;
import java.util.Set;@Slf4j
public class NettyUdpBidirectionalServer {private static final int PORT = 8080;private static final Set<InetSocketAddress> clients = new HashSet<>();private static Channel serverChannel;public static void main(String[] args) throws Exception {EventLoopGroup group = new NioEventLoopGroup();try {Bootstrap b = new Bootstrap();b.group(group).channel(NioDatagramChannel.class).handler(new SimpleChannelInboundHandler<DatagramPacket>() {@Overrideprotected void channelRead0(ChannelHandlerContext ctx, DatagramPacket packet) {InetSocketAddress sender = packet.sender();clients.add(sender); // 记录客户端地址ByteBuf buf = packet.content();String received = buf.toString(CharsetUtil.UTF_8);log.info("【服务器】收到来自 {} 的消息: {}", sender, received);// 回复客户端String response = "服务器已收到: " + received;ByteBuf responseBuf = Unpooled.copiedBuffer(response, CharsetUtil.UTF_8);ctx.writeAndFlush(new DatagramPacket(responseBuf, sender));}});serverChannel = b.bind(PORT).sync().channel();log.info("【服务器】UDP 服务器已启动，监听端口 {}", PORT);// 服务器主动向客户端发送消息BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));while (true) {System.out.print("【服务器】请输入要发送的消息 (输入exit退出)：");String message = reader.readLine();if ("exit".equalsIgnoreCase(message)) {break;}sendMessageToClients(message);}} finally {group.shutdownGracefully();}}// 服务器主动向所有已知客户端发送消息private static void sendMessageToClients(String message) {if (serverChannel == null || clients.isEmpty()) {log.warn("【服务器】没有可发送的客户端");return;}ByteBuf buf = Unpooled.copiedBuffer(message, CharsetUtil.UTF_8);for (InetSocketAddress client : clients) {serverChannel.writeAndFlush(new DatagramPacket(buf.retainedDuplicate(), client));log.info("【服务器】向 {} 发送消息: {}", client, message);}}
}

客户端代码

package com.lps.netty;import cn.hutool.core.util.RandomUtil;
import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.DatagramPacket;
import io.netty.channel.socket.nio.NioDatagramChannel;
import io.netty.util.CharsetUtil;
import lombok.extern.slf4j.Slf4j;import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;@Slf4jpublic class NettyUdpBidirectionalClient {private static final String SERVER_HOST = "127.0.0.1";private static final int SERVER_PORT = 8080;private static final int CLIENT_PORT = 9090; // 客户端固定端口private Channel clientChannel;public static void main(String[] args) throws Exception {new NettyUdpBidirectionalClient().run();}public void run() throws Exception {EventLoopGroup group = new NioEventLoopGroup();try {Bootstrap b = new Bootstrap();b.group(group).channel(NioDatagramChannel.class).handler(new SimpleChannelInboundHandler<DatagramPacket>() {@Overrideprotected void channelRead0(ChannelHandlerContext ctx, DatagramPacket packet) {String response = packet.content().toString(CharsetUtil.UTF_8);log.info("【客户端】收到服务器的消息: {}", response);}});clientChannel = b.bind(RandomUtil.randomInt(9000,10001)).sync().channel();log.info("【客户端】UDP 客户端已启动，监听端口 {}", RandomUtil.randomInt(9000,10001));// 发送消息到服务器BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));while (true) {System.out.print("【客户端】请输入要发送的消息 (输入'exit'退出)：");String message = reader.readLine();if ("exit".equalsIgnoreCase(message)) {break;}sendMessageToServer(message);}} finally {group.shutdownGracefully();}}// 发送消息到服务器private void sendMessageToServer(String message) {ByteBuf buf = Unpooled.copiedBuffer(message, CharsetUtil.UTF_8);DatagramPacket packet = new DatagramPacket(buf, new InetSocketAddress(SERVER_HOST, SERVER_PORT));clientChannel.writeAndFlush(packet);log.info("【客户端】发送消息到服务器: {}", message);}
}

---

核心类和方法解析

 Netty 核心类

类名	作用
Bootstrap	用于启动 Netty 客户端或无连接的服务端
NioDatagramChannel	适用于 UDP 的 Netty 通道
DatagramPacket	UDP 数据包封装

---

 NIO核心类

类名	作用
DatagramChannel	NIO 提供的 UDP 通道
Selector	多路复用器，监听多个通道
ByteBuffer	NIO 的缓冲区管理

---

Netty vs. NIO 对比分析

特性	Netty	NIO
代码复杂度	低	高
内存管理	自动	手动
异步处理	内置支持	需要自行实现
异常处理	统一完善	需手动处理
扩展性	强	一般

总结

通过对比NIO和Netty的实现，我们可以清楚地看到Netty在简化网络编程、提高开发效率和性能方面的优势。Netty不仅封装了复杂的NIO操作，还提供了丰富的功能和优化措施，使得开发高性能网络应用变得更加容易。

随着技术的不断发展，保持学习和实践的态度，将帮助我们在网络编程领域不断提升。无论是使用NIO还是Netty，核心都是要理解网络编程的基本原理。