WebClient is not successfully invoking "POST" operation

Question

I am playing with Spring's WebClient. The primary implementation of the REST endpoints (in DemoPOJORouter and DemoPOJOHandler) seem to work. Also, the http.Get endpoint in DemoClientRouter and DemoClientHandler seems to work.

But, the http.Post for the DemoClient implementation "does nothing". It returns success (200), but nothing gets added to the dummy repo. I have a feeling that I need to do something in DemoClient to cause the http.Post endpoint in DemoPOJOHandler to actually execute (i.e., I believe neither the statements in DemoPOJOService.add() nor DemoPOJORepo.add() are being executed).

Based on prior pratfalls in WebFlux/reactive/functional efforts, I have a feeling that I'm not successfully subscribing, and so the statements never are invoked. But, I'm having difficulty identifying the "why".

Test code follows...

DemoClient router...

@Configuration
public class DemoClientRouter {

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

DemoClient handler...

@Component
public class DemoClientHandler {

    public static final String PATH_VAR_ID = "id";

    @Autowired
    DemoClient demoClient;

    public Mono<ServerResponse> getById(ServerRequest request) {
        Mono<DemoPOJO> monoDemoPOJO;
        int            id;

        // short-circuit if bad request or invalid value for id
        id = getIdFromServerRequest(request);
        if (id < 1) {
            return ServerResponse.badRequest().build();
        }

        // non-blocking mechanism for either returning the Mono<DemoPOJO>
        //  or an empty response if Mono<Void> was returned by repo.getById()
        return demoClient.getById(id).flatMap(demoPOJO -> ServerResponse.ok()
                                                                        .contentType(MediaType.APPLICATION_JSON)
                                                                        .body(Mono.just(demoPOJO), DemoPOJO.class))
                                                                        .switchIfEmpty(ServerResponse.notFound().build());
    }

    public Mono<ServerResponse> add(ServerRequest request) {
        return request.bodyToMono(DemoPOJO.class).doOnSuccess( demoPOJO -> demoClient.add(demoPOJO))
                                                     .then(ServerResponse.ok().build())
                                                 .onErrorResume(e -> simpleErrorReporter(e))
                                                 .switchIfEmpty(ServerResponse.badRequest().build());
    }

    private int getIdFromServerRequest(ServerRequest request) {
        Map<String, String> pathVariables = request.pathVariables();
        int                 id            = -1;

        // short-circuit if bad request
        //  should never happen, but if this method is ever called directly (vice via DemoPOJORouter)
        if ((pathVariables == null)
         || (!pathVariables.containsKey(PATH_VAR_ID))) {
            return id;
        }

        try {
            id = Integer.parseInt(pathVariables.get(PATH_VAR_ID));
        } catch (NumberFormatException e) {
            // swallow the error, return value <0 to signal error
            id = -1;
        }
        return id;
    }

    private Mono<ServerResponse> simpleErrorReporter(Throwable e) {
        return ServerResponse.badRequest()
                             .contentType(MediaType.TEXT_PLAIN)
                             .syncBody(e.getMessage());
    }
}

DemoClient impl...

@Component
public class DemoClient {

    private final WebClient client;

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

    public Mono<DemoPOJO> getById(int id) {
        return client.get().uri("http://localhost:8080/v2/DemoPOJO/" + id)
                           .accept(MediaType.APPLICATION_JSON)
                           .exchange()
                           .flatMap(response -> response.bodyToMono(DemoPOJO.class));
    }

    public Mono<Boolean> add(DemoPOJO demoPOJO) {
        return client.post().uri("http://localhost:8080/v2/DemoPOJO")
                            .syncBody(demoPOJO)
                            .exchange()
                            .flatMap(response -> response.bodyToMono(Boolean.class));
    }
}

And, the DemoPOJO stuff, starting with DemoPOJORouter...

@Configuration
public class DemoPOJORouter {

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

DemoPOJOHandler...

@Component
public class DemoPOJOHandler {

    public static final String PATH_VAR_ID = "id";

    @Autowired
    private DemoPOJOService service;

    public Mono<ServerResponse> getById(ServerRequest request) {
        Mono<DemoPOJO> monoDemoPOJO;
        int            id;

        // short-circuit if bad request or invalid value for id
        id = getIdFromServerRequest(request);
        if (id < 1) {
            return ServerResponse.badRequest().build();
        }

        // non-blocking mechanism for either returning the Mono<DemoPOJO>
        //  or an empty response if Mono<Void> was returned by repo.getById()
        return service.getById(id).flatMap(demoPOJO -> ServerResponse.ok()
                                                                     .contentType(MediaType.APPLICATION_JSON)
                                                                     .body(Mono.just(demoPOJO), DemoPOJO.class))
                                  .switchIfEmpty(ServerResponse.notFound().build());
    }

    public Mono<ServerResponse> add(ServerRequest request) {
        return request.bodyToMono(DemoPOJO.class).doOnSuccess( demoPOJO -> service.add(demoPOJO))
                                                     .then(ServerResponse.ok().build())
                                                 .onErrorResume(e -> simpleErrorReporter(e))
                                                 .switchIfEmpty(ServerResponse.badRequest().build());
    }

    private int getIdFromServerRequest(ServerRequest request) {
        Map<String, String> pathVariables = request.pathVariables();
        int                 id            = -1;

        // short-circuit if bad request
        //  should never happen, but if this method is ever called directly (vice via DemoPOJORouter)
        if ((pathVariables == null)
         || (!pathVariables.containsKey(PATH_VAR_ID))) {
            return id;
        }

        try {
            id = Integer.parseInt(pathVariables.get(PATH_VAR_ID));
        } catch (NumberFormatException e) {
            // swallow the exception, return illegal value to signal error
            id = -1;
        }
        return id;
    }

    private Mono<ServerResponse> simpleErrorReporter(Throwable e) {
        return ServerResponse.badRequest()
                             .contentType(MediaType.TEXT_PLAIN)
                             .syncBody(e.getMessage());
    }
}

DemoPOJOService...

@Component
public class DemoPOJOService {

    @Autowired
    private DemoPOJORepo demoPOJORepo;

    public Mono<DemoPOJO> getById(int id) {
        DemoPOJO demoPOJO = demoPOJORepo.getById(id);

        return (demoPOJO == null) ? Mono.empty()
                                  : Mono.just(demoPOJO);
    }

    public Mono<Boolean> add(DemoPOJO demoPOJO) {
        return Mono.just(demoPOJORepo.add(demoPOJO));
    }
}

DemoPOJORepo...

@Component
public class DemoPOJORepo {

    private static final int NUM_OBJS = 5;

    private static DemoPOJORepo demoRepo = null;

    private Map<Integer, DemoPOJO> demoPOJOMap;

    private DemoPOJORepo() {
        initMap();
    }

    public static DemoPOJORepo getInstance() {
        if (demoRepo == null) {
            demoRepo = new DemoPOJORepo();
        }
        return demoRepo;
    }

    public DemoPOJO getById(int id) {
        return demoPOJOMap.get(id);
    }

    public boolean add(DemoPOJO demoPOJO) throws InvalidParameterException {
        // short-circuit on null pointer or duplicate id
        if (demoPOJO == null) {
            throw new InvalidParameterException("Add failed, null object detected...");
        } else if (demoPOJOMap.containsKey(demoPOJO.getId())) {
            throw new InvalidParameterException("Add failed, duplicate id detected...");
        }

        demoPOJOMap.put(demoPOJO.getId(), demoPOJO);
        // if the return statement is reached, then the new demoPOJO was added
        return true;
    }
}

Finally, DemoPOJO...

public class DemoPOJO {

    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(int id) {
        this(id, DEF_NAME, DEF_VALUE);
    }

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

    /*
     * setters and getters go here
     */

    public String toString() {
        StringBuilder builder = new StringBuilder();

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

Answer 1

Here is probably your problem.

DemoPOJOHandler.class

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

DemoPOJOService.class

public Mono<Boolean> add(DemoPOJO demoPOJO) {
    return Mono.just(demoPOJORepo.add(demoPOJO));
}

doOnSuccess returns Void, but you are calling a method that wraps the "action" in a returning Mono. So the demoPOJORepo#add function will never be triggered because you have broken the event chain here. The easiest fix is to just remove the wrapping Mono and return void.

public void add(DemoPOJO demoPOJO) {
    demoPOJORepo.add(demoPOJO);
}