基于Wildfly Swarm的微服务：如何注入Spring WebFlux的Http Handler到Undertow分块？是否需重构为Spring Boot？

嘿，这个方案完全可行，不用非得重构为Spring Boot！我来给你拆解具体怎么实现：

首先明确核心逻辑：通过一个适配器类，把Spring WebFlux的HttpHandler适配成Wildfly Swarm依赖的Undertow原生io.undertow.server.HttpHandler，再注册到Undertow容器中即可。

具体实现步骤 #

1. 配置依赖 #

先确保pom.xml里包含必要的依赖，注意版本兼容性（Wildfly Swarm 2018.x系列适配Spring 5.x版本）：

<dependencies>
    <!-- Wildfly Swarm Undertow核心依赖 -->
    <dependency>
        <groupId>org.wildfly.swarm</groupId>
        <artifactId>undertow</artifactId>
        <version>2018.5.0</version>
    </dependency>
    <!-- Spring WebFlux响应式API依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webflux</artifactId>
        <version>5.0.9.RELEASE</version>
    </dependency>
    <!-- Spring上下文管理依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.9.RELEASE</version>
    </dependency>
</dependencies>

2. 实现Spring WebFlux的HttpHandler #

先编写你的响应式API逻辑，比如用RouterFunction构建一个简单的处理器：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.http.server.reactive.HttpHandler;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.RouterFunctions;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;

import static org.springframework.web.reactive.function.server.RequestPredicates.GET;
import static org.springframework.web.reactive.function.server.RequestPredicates.accept;

@Configuration
public class ReactiveApiConfig {
    @Bean
    public RouterFunction<ServerResponse> helloRoute() {
        return RouterFunctions.route(
                GET("/api/hello").and(accept(MediaType.APPLICATION_JSON)),
                request -> ServerResponse.ok().body(Mono.just("Hello Reactive!"), String.class)
        );
    }

    @Bean
    public HttpHandler springHttpHandler(RouterFunction<ServerResponse> routerFunction) {
        return RouterFunctions.toHttpHandler(routerFunction);
    }
}

3. 编写Undertow-Spring适配器（核心步骤） #

创建适配器类，把Spring的HttpHandler转换成Undertow能识别的处理器，完成请求和响应的格式转换：

import io.undertow.server.HttpHandler;
import io.undertow.server.HttpServerExchange;
import org.springframework.http.server.reactive.HttpHandler;
import org.springframework.http.server.reactive.UndertowServerHttpRequest;
import org.springframework.http.server.reactive.UndertowServerHttpResponse;
import reactor.core.publisher.Mono;

public class SpringUndertowAdapter implements HttpHandler {
    private final org.springframework.http.server.reactive.HttpHandler springHandler;

    public SpringUndertowAdapter(org.springframework.http.server.reactive.HttpHandler springHandler) {
        this.springHandler = springHandler;
    }

    @Override
    public void handleRequest(HttpServerExchange exchange) throws Exception {
        // 转换Undertow请求/响应为Spring WebFlux格式
        UndertowServerHttpRequest springRequest = new UndertowServerHttpRequest(exchange);
        UndertowServerHttpResponse springResponse = new UndertowServerHttpResponse(exchange);

        // 处理响应式请求，完成后结束Undertow交换
        Mono<Void> handleMono = springHandler.handle(springRequest, springResponse);
        handleMono.subscribe(
                v -> exchange.endExchange(),
                error -> {
                    exchange.setStatusCode(500);
                    exchange.endExchange();
                }
        );
    }
}

4. 在Wildfly Swarm中注册适配器 #

最后在Swarm启动类中初始化Spring上下文，把适配器注册到Undertow容器：

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.wildfly.swarm.Swarm;
import org.wildfly.swarm.undertow.UndertowFraction;

public class SwarmBootstrap {
    public static void main(String[] args) throws Exception {
        // 初始化Spring上下文，加载响应式API配置
        AnnotationConfigApplicationContext springContext = 
                new AnnotationConfigApplicationContext(ReactiveApiConfig.class);
        org.springframework.http.server.reactive.HttpHandler springHandler = 
                springContext.getBean(org.springframework.http.server.reactive.HttpHandler.class);

        // 配置并启动Wildfly Swarm
        Swarm swarm = new Swarm();
        swarm.fraction(UndertowFraction.createDefaultFraction()
                .server(server -> server
                        .host("0.0.0.0")
                        .port(8080)
                        .handler(new SpringUndertowAdapter(springHandler))));
        
        swarm.start();
    }
}

注意事项 #

• 版本兼容性：一定要确认Wildfly Swarm和Spring组件的版本匹配，避免类加载冲突或API不兼容问题。
• 错误处理：上面的适配器只做了简单的错误兜底，你可以根据业务需求扩展更完善的错误处理逻辑。
• 上下文生命周期：Spring上下文要在Swarm启动前初始化完成，确保所有Bean都已正确加载。

后续建议 #

如果你的应用后续需要深度整合Spring生态（比如Spring Cloud、Spring Security WebFlux等），迁移到Spring Boot会更省心——毕竟Spring Boot对WebFlux的集成是开箱即用的。但如果只是给现有Swarm应用添加响应式API，上面的方案完全足够，不需要重构。

内容的提问来源于stack exchange，提问作者RA26