如何在SpringBoot中用Netty处理UDP与HTTP2请求及转发场景

原代码核心问题分析 #

你提供的代码存在几个关键逻辑错误，无法实现需求：

• Netty Handler 的 messageReceived 方法属于 Netty 异步上下文，不能直接返回 Spring 的 ResponseEntity，两者执行环境不兼容
• 缺少向 App3 发送 UDP 请求的核心逻辑
• Netty EventLoopGroup 未正确关闭，存在资源泄漏风险
• 未适配 HTTP2 协议，当前代码仅处理 HTTP 1.1 请求

修正后的完整实现 #

1. 依赖配置（pom.xml） #

引入支持 HTTP2 的 Spring WebFlux 及 Netty 依赖：

<dependencies>
    <!-- Spring WebFlux 用于 HTTP2 支持 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webflux</artifactId>
    </dependency>
    <!-- Netty UDP 通信依赖 -->
    <dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>
    </dependency>
</dependencies>

<properties>
    <spring-boot.version>3.2.0</spring-boot.version>
    <netty.version>4.1.100.Final</netty.version>
</properties>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <server>
                    <http2>
                        <enabled>true</enabled>
                    </http2>
                </server>
            </configuration>
        </plugin>
    </plugins>
</build>

2. UDP 通信工具类 #

封装 Netty UDP 发送/接收逻辑，用 CompletableFuture 异步获取响应：

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.net.InetSocketAddress;
import java.util.concurrent.CompletableFuture;

public class UdpClient {
    private final EventLoopGroup group = new NioEventLoopGroup(1);
    private Channel channel;

    public void init() throws InterruptedException {
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(group)
                .channel(NioDatagramChannel.class)
                .option(ChannelOption.SO_BROADCAST, true)
                .handler(new ChannelInitializer<NioDatagramChannel>() {
                    @Override
                    protected void initChannel(NioDatagramChannel ch) {
                        ch.pipeline().addLast(new SimpleChannelInboundHandler<DatagramPacket>() {
                            @Override
                            protected void messageReceived(ChannelHandlerContext ctx, DatagramPacket msg) {
                                String udpResponse = msg.content().toString(CharsetUtil.UTF_8);
                                // 完成异步结果，通知等待线程
                                CompletableFuture<String> future = ctx.channel().attr(AttributeKey.valueOf("responseFuture")).get();
                                future.complete(udpResponse);
                                ctx.close();
                            }
                        });
                    }
                });
        channel = bootstrap.bind(0).sync().channel(); // 绑定随机端口监听 UDP 响应
    }

    public CompletableFuture<String> sendUdpRequest(String targetHost, int targetPort, String requestContent) {
        CompletableFuture<String> responseFuture = new CompletableFuture<>();
        channel.attr(AttributeKey.valueOf("responseFuture")).set(responseFuture);

        ByteBuf contentBuf = Unpooled.copiedBuffer(requestContent, CharsetUtil.UTF_8);
        channel.writeAndFlush(new DatagramPacket(contentBuf, new InetSocketAddress(targetHost, targetPort)));

        return responseFuture;
    }

    public void shutdown() {
        group.shutdownGracefully();
    }
}

3. Spring Controller 实现（支持 HTTP2） #

用 WebFlux 的 Mono 异步处理请求，等待 UDP 响应后返回给 App1：

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;

@RestController
public class UdpToHttp2Controller {
    private UdpClient udpClient;

    @PostConstruct
    public void initUdpClient() throws InterruptedException {
        udpClient = new UdpClient();
        udpClient.init();
    }

    @GetMapping("/api/udp-to-http2")
    public Mono<ResponseEntity<String>> handleUdpToHttp2() {
        // 向 App3 发送 UDP 请求（假设 App3 地址为 localhost:8805）
        return Mono.fromFuture(udpClient.sendUdpRequest("localhost", 8805, "来自 App2 的 UDP 请求"))
                .map(udpResponse -> ResponseEntity.ok(udpResponse))
                .onErrorResume(e -> {
                    e.printStackTrace();
                    return Mono.just(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("UDP 请求处理失败"));
                });
    }

    @PreDestroy
    public void shutdownUdpClient() {
        udpClient.shutdown();
    }
}

4. 配置文件（application.yml） #

开启 HTTP2 支持：

server:
  port: 8080
  http2:
    enabled: true

关键逻辑说明 #

• 异步非阻塞：通过 CompletableFuture + Mono 实现异步等待 UDP 响应，避免阻塞 Spring 线程池
• 资源管理：用 @PostConstruct 和 @PreDestroy 初始化/销毁 Netty 资源，防止内存泄漏
• HTTP2 适配：基于 Spring WebFlux 开启 HTTP2 支持，满足 App1 与 App2 的通信协议要求
• 职责分离：UDP 通信逻辑封装为独立工具类，与 Controller 业务逻辑解耦

内容的提问来源于stack exchange，提问作者bharath m s