Async API using Spring + Jersey

Question

Sto lavorando alla creazione di API che potrebbero potenzialmente avere un numero elevato di richieste al secondo e alcune richieste potrebbero richiedere molti calcoli (report complessi). Mi è stato chiesto di mettere insieme un piccolo prototipo come prova del concetto. Sto usando Spring Boot con Jersey come implementazione JAX-RS. In passato ho fatto qualcosa di simile con Spring MVC.

@RequestMapping(value = "/dashboard", method = RequestMethod.GET) 
public DeferredResult<String> showDashboard(Model model) { 
    DeferredResult<String> result = new DeferredResult<>(); 
    model.addAttribute("testObj", new User()); 
    result.setResult("home/dashboard"); 
    return result; 
} 

Ho provato questo con Jersey e sembra funzionare, o almeno non ha generato un errore.

@GET 
    public DeferredResult<String> getClients() { 
     DeferredResult<String> deferredResult = new DeferredResult<>(); 
     deferredResult.setResult("Nothing! But I'm Async!"); 
     return deferredResult; 
    } 

Tuttavia, tutti gli esempi che ho visto per le operazioni di gestione in modo asincrono in Jersey appaiono in questo modo.

Produces(MediaType.TEXT_PLAIN) 
public void get(@Suspended final AsyncResponse response) { 
    // This call does not block. 
    client.callExternalService(
    // This callback is invoked after the external service responds. 
    new Callback<string>() { 
     public void callback(String result) { 
     response.resume("Result: " + result + ".n"); 
     } 
    }); 
} 

La mia domanda principale è qual è la differenza tra questi tre frammenti di codice dietro le quinte, se ce ne sono addirittura. Questi compiranno tutti la stessa cosa?

C'è un modo migliore per eseguire async? Ho anche visto l'uso di Future in Java, ma non l'ho mai usato.

UPDATE:

Ho il seguente codice nel mio controller Jersey, che è tutto il funzionamento.

@GET 
    public String getClients() { 
     return "Nothing, I'm Sync!"; 
    } 

    @GET 
    @Path("/deferred") 
    public DeferredResult<String> getClientsAsync() { 
     DeferredResult<String> deferredResult = new DeferredResult<>(); 
     deferredResult.setResult("Nothing! But I'm Async!"); 
     return deferredResult; 
    } 

    @GET 
    @Path("/async") 
    public void getClientsJAXRSAsync(@Suspended AsyncResponse response) { 
     new Thread(() -> { 
      response.resume("I am Async too! But I am using @Suspended"); 
     }).start(); 
    } 

Torna alla mia domanda principale, qual è la differenza tra questi? La mia comprensione è DeferredResult è una cosa di primavera quindi non sono sicuro se è appropriato utilizzare con Jersey, anche se sto usando Jersey + Spring.

Answer 1

La tua comprensione è giusta. Entrambi stanno facendo lo stesso lavoro. Ma le implementazioni sono diverse. DeferredResult è l'implementazione della primavera. E nella tua base di codice la maggior parte della parte è di implementazione JAX-RS. Non sono sicuro che riceverai risposta dal primo pugno.

Ma la mia opinione è, o si utilizzano classi primaverili o JAX-RS. Ma non entrambi nello stesso metodo.