RESTendpoint在直接访问时起作用，但通过WebClient访问时不起作用

Question

注意：下面是对类似帖子/问题的编辑/修订，试图更好地识别我的问题/问题，并提供更好的代码示例来演示我的问题。

添加注意：代码示例已修改为包括工作代码。

我在同一个spring reactive应用程序中的两台路由器中有两个endpoint。第一个(/v2/demopojo)似乎可以正常工作。第二个(/v2/democlient/demopojo)，使用WebClient委托给/v2/demopojo似乎“什么也不做”（尽管记录的输出显示正在调用democlientHandler.add（）和democlient.add（）））。

当我向/v2/demopojoendpoint发出POST请求时，将调用doFirst()、doOnSuccess()和doFinally（）并输出适当的文本（在“Real Life”中，将向存储库中添加一行）。

当我向/v2/democlient/demopojoendpoint发出POST请求时，它返回200 OK状态，但没有输出任何预期的文本（在“实际生活”中，没有向存储库添加任何内容）。

以下文件支持/v2/demopojo终结点...

Demopojo的路由器类实现...

@Configuration
public class DemoPOJORouter {
    private Logger logger = LoggerFactory.getLogger(DemoPOJORouter.class);

    @Bean
    public RouterFunction<ServerResponse> demoPOJORoute(DemoPOJOHandler requestHandler) {
        logger.debug("DemoPOJORouter.demoPOJORoute( DemoPOJOHandler )");
        return nest(path("/v2"),
                nest(accept(APPLICATION_JSON),
                        RouterFunctions.route(RequestPredicates.POST("/DemoPOJO"), requestHandler::add)));
    }
}

DemoPojo的处理程序类实现...

@Component
public class DemoPOJOHandler {
    private Logger logger = LoggerFactory.getLogger(DemoPOJOHandler.class);

    public Mono<ServerResponse> add(ServerRequest request) {
        logger.debug("DemoPOJOHandler.add( ServerRequest )");

        return request.bodyToMono(DemoPOJO.class).doFirst(() -> System.out.println("-> doFirst()."))
                                                 .doOnSuccess(demoPOJO -> System.out.println("Received >> " + demoPOJO.toString()))
                                                     .then(ServerResponse.accepted().build())
                                                 .doOnError(e -> System.out.println("-> doOnError()"))
                                                 .doFinally(demoPOJO -> System.out.println("-> doFinally()"));
    }
}

DemoPOJO实现j...

public class DemoPOJO {
    private Logger logger = LoggerFactory.getLogger(DemoPOJO.class);

    public static final String DEF_NAME  = "DEFAULT NAME";
    public static final int    DEF_VALUE = 99;

    private int    id;
    private String name;
    private int    value;

    public DemoPOJO(@JsonProperty("id") int id, @JsonProperty("name") String name, @JsonProperty("value") int value) {
        logger.debug("DemoPOJO.DemoPOJO( {}, {}, {} )", id, name, value);
        this.id = id;
        this.name = name;
        this.value = value;
    }

    /*
     * setters and getters go here
     */

    public String toString() {
        logger.debug("DemoPOJO.toString()");
        StringBuilder builder = new StringBuilder();

        builder.append(id);
        builder.append(" :: ");
        builder.append(name);
        builder.append(" :: ");
        builder.append(value);
        return builder.toString();
    }
}

@Configuration
public class DemoClientRouter {
    private Logger logger = LoggerFactory.getLogger(DemoClientRouter.class);

    @Bean
    public RouterFunction<ServerResponse> clientRoutes(DemoClientHandler requestHandler) {
        logger.debug("DemoClientRouter.route( DemoClientHandler )");
        return nest(path("/v2/DemoClient"),
                nest(accept(APPLICATION_JSON),
                        RouterFunctions.route(RequestPredicates.POST("/DemoPOJO"), requestHandler::add)));
    }
}

@Component
public class DemoClientHandler {
    private Logger logger = LoggerFactory.getLogger(mil.navy.demo.demopojo.DemoPOJOHandler.class);

    @Autowired
    DemoClient demoClient;

    public Mono<ServerResponse> add(ServerRequest request) {
        logger.debug("DemoClientOHandler.add( ServerRequest )");

        // THIS CODE
        return request.bodyToMono(DemoPOJO.class).flatMap(demoPOJO -> demoClient.add(demoPOJO))
                                                 .then(ServerResponse.accepted().build());

        // REPLACES THIS CODE
        /*
           return request.bodyToMono(DemoPOJO.class).doOnSuccess( demoPOJO -> demoClient.add(demoPOJO))
                                                     .then(ServerResponse.ok().build())
                                                 .switchIfEmpty(ServerResponse.badRequest().build());
         */
    }
}

Democlient的WebClient实现...

@Component
public class DemoClient {
    private Logger logger = LoggerFactory.getLogger(DemoClient.class);

    private final WebClient client;

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

    public Mono<Boolean> add(DemoPOJO demoPOJO) {
        logger.debug("DemoClient.add( DemoPOJO )");

        logger.debug("DemoClient.add() >> DemoPOJO -> {}", demoPOJO.toString());
        return client.post().uri("http://localhost:8080/v2/DemoPOJO")
                            .accept(MediaType.APPLICATION_JSON)
                            .syncBody(demoPOJO)
                            .exchange()
                            .flatMap(response -> response.bodyToMono(Boolean.class));
    }
}

Answer 1

我猜这就是你的问题所在。

return request.bodyToMono(DemoPOJO.class)
    .doOnSuccess( demoPOJO -> demoClient.add(demoPOJO))

doonsuccess接受使用者，使用者返回void而不是mono 。

下面是使用者的详细用法。

Mono.just("hello")
    .doOnSuccess(new Consumer<String>() {

        @Override
        public void accept(String s) {

            // See here, it returns void

        }
    });

Mono<String> helloWorld = Mono.just("Hello")
    .doOnSuccess(string -> {
        // This will never be executed because 
        // it is just declared and never subscribed to
        Mono.just(string + " world");
    });

helloWorld.doOnSuccess(string -> {
        // This will print out Hello
        System.out.println(string);
    });

 Mono<String> hello = Mono.just("Hello")
        .doOnSuccess(string -> {
        // This will print out Hello World
        System.out.println(string + " World");
    });

 // hello hasn't been changed     
 hello.map(string -> {
        // This will also print out Hello World
        System.out.println(string + " World");
    });

 // This prints hello world to after we mapped it
 Mono<String> helloworld = Mono.just("hello")
     .map(s -> s + " World")
     .doOnSuccess(System.out::println);

 // Now this is what you are essentially doing
 // See how this is wrong?
 Mono<DemoPOJO> demoPOJO = request.bodyToMono(DemoPOJO.class)
    .doOnSuccess( demoPOJO -> Mono.empty() );

您正在调用democlient#add，该democlient#add返回一个单声道 。在这里，您正在破坏链，因为它返回的单声道上没有任何链接，因此它永远不会被订阅，因为它不在事件链中。

return request.bodyToMono(DemoPOJO.class)
    .map( demoPOJO -> {
        return demoClient.add(demoPOJO);
    });

如果您将其更改为map，它可能会起作用。接下来发生的是，它将一个单声道 并将其“映射”到一个单声道 ，该单声道 由add函数返回。并且突然它在事件链（回调）中。