spring webflux自定义netty 参数解析

下面是关于“spring webflux自定义netty 参数解析”的完整攻略，包括步骤和示例。

什么是spring webflux自定义netty参数解析？

在spring webflux项目中，我们可以使用自定义的netty编解码的方式来对请求中的参数进行解析。通过自定义参数解析器，我们可以控制如何对请求参数进行编解码操作，从而更好地满足我们的业务需求。

具体来说，我们可以编写自定义的Encoder和Decoder，并在netty的handler链中进行注册，在处理请求时候对请求参数进行处理。

实现步骤

1. 编写自定义的Encoder和Decoder

分别继承Netty的Encoder和Decoder类，并实现相应的抽象方法，在其中编写自己的编解码逻辑。

例如，假设我们需要将请求中的json格式的body转换为实体类对象，可以编写以下代码：

public class JsonDecoder extends ByteToMessageDecoder {
    private final ObjectMapper mapper;

    public JsonDecoder(ObjectMapper mapper) {
        this.mapper = Objects.requireNonNull(mapper, "mapper");
    }

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        final int length = in.readableBytes();
        final byte[] array = new byte[length];
        in.getBytes(in.readerIndex(), array);
        Object obj = mapper.readValue(array, TypeFactory.defaultInstance().constructType(MyObject.class));
        out.add(obj);
    }
}

public class JsonEncoder extends MessageToByteEncoder<Object> {
    private final ObjectMapper mapper;

    public JsonEncoder(ObjectMapper mapper) {
        this.mapper = Objects.requireNonNull(mapper, "mapper");
    }

    @Override
    protected void encode(ChannelHandlerContext ctx, Object msg, ByteBuf out) throws Exception {
        byte[] data = mapper.writeValueAsBytes(msg);
        out.writeBytes(data);
    }
}

2. 注册自定义的Encoder和Decoder

在WebFluxConfigurer中重写configureHttpMessageCodecs方法，在其中注册自定义的编解码器。

@Configuration
public class MyWebFluxConfigurer implements WebFluxConfigurer {

    @Override
    public void configureHttpMessageCodecs(ServerCodecConfigurer configurer) {
        ObjectMapper objectMapper = new ObjectMapper();
        SimpleModule module = new SimpleModule();
        module.addDeserializer(MyObject.class, new MyObjectDeserializer());
        objectMapper.registerModule(module);

        configurer.customCodecs().register(new Jackson2JsonDecoder(objectMapper));
        configurer.customCodecs().register(new Jackson2JsonEncoder(objectMapper));
    }
}

3. 配置nettyHandler

在@Bean注解的方法中，创建HttpServer并调用handle()方法，将编解码器和我们自定义的netty handler链装配进去。例如：

@Bean
public HttpServer myHttpServer() {
    ObjectMapper objectMapper = new ObjectMapper();
    SimpleModule module = new SimpleModule();
    module.addDeserializer(MyObject.class, new MyObjectDeserializer());
    objectMapper.registerModule(module);

    NettyRoutingFunction

    NettyWriteResponseFilter writeResponseFilter = new NettyWriteResponseFilter();

    HttpServer httpServer = HttpServer.create()
            .tcpConfiguration(tcpServer -> tcpServer
                    .option(ChannelOption.SO_BACKLOG, 100)
                    .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 1000)
                    .doOnConnection(connection -> connection.addHandler(new ConnectionMonitor())))
            .route(routes ->
                    routes
                            .get("/foo/{id}", handler::foo)
                            .post("/bar", handler::bar)
            )
            .compress(true)
            .protocol(HttpProtocol.H2C)
            .host("localhost")
            .port(port)
            .wiretap(true)
            .doOnConnection(conn -> conn.addHandlerLast(new LoggingHandler(LogLevel.DEBUG)))
            .doOnChannelInit((ObservableChannel channel, InetSocketAddress address) ->
                    channel.pipeline().addBefore(WebFluxServerHandler.class.getSimpleName(),
                            "codec",
                            new HttpServerCodec(),
                            new HttpContentDecompressor(),
                            new HttpObjectAggregator(1024 * 64),
                            new Jackson2JsonDecoder(objectMapper)
                    )
                            .addBefore(WebFluxServerHandler.class.getSimpleName(),
                                    "chunked-writer",
                                    new ChunkedWriter(),
                                    new Jackson2JsonEncoder(objectMapper)
                            )
                            .addLast(writeResponseFilter)
            )
            .handle((request, response) -> {
                if (request.uri().toString().equals("/foo")) {
                    return response.status(HttpStatus.OK).body(BodyInserters.fromObject(new MyResponse()));
                } else {
                    return response.status(HttpStatus.NOT_FOUND).build();
                }
            });
    return httpServer;
}

示例说明

示例一

在上述代码中，我们假设请求参数是一个json格式的字符串，需要将其转换为MyObject对象。具体的实现方案是：

1. 创建JsonDecoder解析器和JsonEncoder编码器，并且通过Jackson库将json字符串转化为Java对象；
2. 在MyWebFluxConfigurer配置类中注册编解码器；
3. 在myHttpServer()方法中的handler链中添加解析器。

这样，在请求中携带json格式字符串的时候，就能够被JsonDecoder解析为Java对象，从而方便业务处理。

示例二

当我们需要在响应中携带一些自定义的头信息时，我们可以创建一个过滤器来进行处理。具体的实现方案是：

1. 创建NettyWriteResponseFilter过滤器；
2. 在myHttpServer()方法中的handler链结尾添加过滤器。

这样，响应信息就可以在过滤器中进行处理了。例如，我们可以在过滤器中添加一个header信息：

public class NettyWriteResponseFilter implements NettyResponseFilter {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, NettyDataBufferFactory bufferFactory, NettyDataBufferFactory dataBufferFactory, Connection connection) {
        if (exchange.getResponse().getStatusCode() == HttpStatus.OK) {
            HttpHeaders headers = exchange.getResponse().getHeaders();
            headers.set("X-Custom-Header", "custom");
        }

        return Mono.empty();
    }
}

以上就是关于“spring webflux自定义netty参数解析”的完整攻略和示例说明。