code: private CompletionStage<HttpResponse> serve0(ServiceRequestContext ctx, HttpRequest req) {
          final CompletableFuture<AggregatedHttpMessage> f =
                  aggregationRequired(aggregationStrategy, req) ? req.aggregate()
                                                                : CompletableFuture.completedFuture(null);
  
          ctx.setAdditionalResponseHeaders(defaultHttpHeaders);
          ctx.setAdditionalResponseTrailers(defaultHttpTrailers);
  
          switch (responseType) {
              case HTTP_RESPONSE:
                  return f.thenApply(
                          msg -> new ExceptionFilteredHttpResponse(ctx, req, (HttpResponse) invoke(ctx, req, msg),
                                                                   exceptionHandler));
              case COMPLETION_STAGE:
                  return f.thenCompose(msg -> toCompletionStage(invoke(ctx, req, msg)))
                          .handle((result, cause) -> cause == null ? convertResponse(ctx, req, null, result,
                                                                                     HttpHeaders.EMPTY_HEADERS)
                                                                   : exceptionHandler.handleException(ctx, req,
                                                                                                      cause));
              default:
                  return f.thenApplyAsync(msg -> convertResponse(ctx, req, null, invoke(ctx, req, msg),
                                                                 HttpHeaders.EMPTY_HEADERS),
                                          ctx.blockingTaskExecutor());
          }
      }
docs: Executes the service method in different ways regarding its return type and whether the request is
  required to be aggregated. If the return type of the method is not a {@link CompletionStage} or
  {@link HttpResponse}, it will be executed in the blocking task executor.