为什么通过ServerResponse返回的flux会折叠为单个字符串，除非每个字符串元素都以“\n”结尾？

Question

在使用Spring Webflux和WebClient时，我注意到当返回包含Flux 的ServerResponse时的一个行为（由下面的html" target="_blank">代码演示）。除非字符串元素以换行符结尾，否则通过ServerResponse返回flux 似乎会将所有flux 元素连接到单个字符串中。有人能解释一下为什么我会看到这种行为，以及我是怎么做的导致这种行为的吗？

当每个字符串元素以换行符终止时，flux 将通过ServerResponse“按预期返回”，订阅返回的flux 将产生预期的结果。但是，如果将其视为简单的JSON（通过Postman），这也会导致在JSON主体中返回一个额外的空字符串元素。

控制台输出显示描述的行为...

>

String元素的第一个列表出现在StringProducerHandler.getAll（）中，并指示包含10个String元素的通量 的结果，其中每个String值的第二个出现以换行符结束，结果输出一个空行。

String元素的第二个列表出现在StringClient.getAll（）中，并演示了未用换行符终止的原始String元素如何与下面的元素连接。

2019-10-10 10:13:37.225信息8748---[main]O.s.B.Web.Embedded.Netty.NettyWebServer：Netty在端口上启动：8080 2019-10-10 10:13:37.228信息8748---[main]C.Example.FluxTest.FluxTestApplication：在1.271秒内启动了FluxTestApplication（JVM运行时间为1.796）

*****“Get”在http://localhost:8080/StringClient/StringClientHandler.getAll（ServerRequest）StringClient.getAll（）StringProducerHandler.getAll（ServerRequest）ListElement-0 ListElement-0

列表-1列表-1

列表元素-2列表元素-2

清单-3清单-3

列表-4列表-4

ListElement-0ListElement-0@1570727628948 ListElement-1ListElement-1@1570727628948 ListElement-2ListElement-2@1570727628948 ListElement-3ListElement-3@1570727628948 ListElement-4ListElement-4@1570727628949

下面提供了复制此行为的代码...

@SpringBootApplication
public class FluxTestApplication {

    public static void main(String[] args) {
        SpringApplication.run(FluxTestApplication.class, args);
    }
}


@Configuration
public class StringClientRouter {
    @Bean
    public RouterFunction<ServerResponse> clientRoutes(StringClientHandler requestHandler) {
        return nest(path("/StringClient"),
                nest(accept(APPLICATION_JSON),
                        RouterFunctions.route(RequestPredicates.GET("/String"), requestHandler::getAll)));
    }
}


@Component
public class StringClientHandler {

    @Autowired
    StringClient stringClient;

    public Mono<ServerResponse> getAll(ServerRequest request) {
        System.out.println("StringClientHandler.getAll( ServerRequest )");

        Mono<Void> signal = stringClient.getAll();
            return ServerResponse.ok().build();
        }
    }


@Component
public class StringClient {

    private final WebClient client;

    public StringClient() {
        client = WebClient.create();
    }

    public Mono<Void> getAll() {
        System.out.println("StringClient.getAll()");

        // break chain to explicitly obtain the ClientResponse
        Mono<ClientResponse> monoCR = client.get().uri("http://localhost:8080/StringProducer/String")
                                                  .accept(MediaType.APPLICATION_JSON)
                                                  .exchange();

        // extract the Flux<String> and print to console
        Flux<String> fluxString = monoCR.flatMapMany(response -> response.bodyToFlux(String.class));
        // this statement iterates over the Flux<String> and outputs each element
        fluxString.subscribe(strVal -> System.out.println(strVal + " @ " + System.currentTimeMillis()));

        return Mono.empty();
    }
}


@Configuration
public class StringProducerRouter {
    @Bean
    public RouterFunction<ServerResponse> demoPOJORoute(StringProducerHandler requestHandler) {
        return nest(path("/StringProducer"),
                nest(accept(APPLICATION_JSON),
                        RouterFunctions.route(RequestPredicates.GET("/String"), requestHandler::getAll)));
    }
}


@Component
public class StringProducerHandler {

    public Mono<ServerResponse> getAll(ServerRequest request) {
        System.out.println("StringProducerHandler.getAll( ServerRequest )");

        int          listSize = 5;
        List<String> strList  = new ArrayList<String>();

        for (int i=0; i<listSize; i++) {
            strList.add("ListElement-" + i);         // add String value without newline termination
            strList.add("ListElement-" + i + "\n");  // add String value with    newline termination
        }

        // this statement produces the expected console output of String values
        Flux.fromIterable(strList).subscribe(System.out::println);

        return ServerResponse.ok()
                             .contentType(MediaType.APPLICATION_JSON)
                             .body(Flux.fromIterable(strList), String.class);
    }
}

Answer 1

这是由于org.springframework.core.codec.stringdecoder的工作方式。

调用response.BodyToFlux(string.class)时，响应体将转换为String的Flux。org.springframework.core.codec.StringDecoder完成了很大的任务，并且认为它应该拆分默认分隔符。

List<byte[]> delimiterBytes = getDelimiterBytes(mimeType);

Flux<DataBuffer> inputFlux = Flux.from(input)
    .flatMapIterable(buffer -> splitOnDelimiter(buffer, delimiterBytes))
    .bufferUntil(buffer -> buffer == END_FRAME)
    .map(StringDecoder::joinUntilEndFrame)
    .doOnDiscard(PooledDataBuffer.class, DataBufferUtils::release);

return super.decode(inputFlux, elementType, mimeType, hints);

默认分隔符为public static final list DEFAULT_DELIMITERS=arrays.aslist（“\r\n”,“\n”）；

因此你得到：

ListElement-0ListElement-0 @ 1570732000374
ListElement-1ListElement-1 @ 1570732000375
...

而不是

ListElement-0 @ 1570732055461
ListElement-0 @ 1570732055461
ListElement-1 @ 1570732055462
ListElement-1 @ 1570732055462
...