HTTP Concurrency Model

@RestController
@RequestMapping("/api")
class MessageController {
    private final MessageService service;

    MessageController(MessageService service) {
        this.service = service;
    }

    @GetMapping("/messages/{id}")
    Message get(@PathVariable long id) {
        // On platform threads, this worker sits idle while the
        // database answers. With server.tomcat.threads.max=200,
        // request 201 waits in the worker executor's queue.
        return service.findById(id);
    }
}

@RestController
@RequestMapping("/api")
class MessageController {
    private final ReactiveMessageService service;

    MessageController(ReactiveMessageService service) {
        this.service = service;
    }

    @GetMapping("/messages/{id}")
    Mono<ResponseEntity<Message>> get(@PathVariable long id) {
        return service.findById(id)          // R2DBC, not JDBC
            .map(ResponseEntity::ok)
            .defaultIfEmpty(ResponseEntity.notFound().build());
    }
    // One accidental blocking call inside the chain stalls an
    // event-loop thread, and every request queued behind it.
}

type MessageHandler struct {
    messages *message.Service
}

// net/http runs this in a goroutine of its own: one per connection
// on HTTP/1.x, one per request stream on HTTP/2.
// While Find waits on Postgres, the goroutine is parked and its
// OS thread runs other goroutines. No callbacks, no Mono.
func (h *MessageHandler) Get(w http.ResponseWriter, r *http.Request) {
    msg, err := h.messages.Find(r.Context(), r.PathValue("id"))
    if err != nil {
        writeError(w, statusFor(err), "could not load message")
        return
    }
    writeJSON(w, http.StatusOK, msg)
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("GET /api/messages/{id}", handler.Get)
    // ... server with timeouts, graceful shutdown (see Lifecycle)
}