Annotazioni @RequestBody e @ResponseBody in primavera

Qualcuno può spiegare le annotazioni @RequestBodye @ResponseBodynella primavera 3? A cosa servono? Qualsiasi esempio sarebbe fantastico.

C'è un'intera sezione nei documenti chiamata 16.3.3.4 Mappatura del corpo della richiesta con l'annotazione @RequestBody . E uno chiamato 16.3.3.5 Mappare il corpo della risposta con l'annotazione @ResponseBody . Ti consiglio di consultare quelle sezioni. Rilevante anche: @RequestBodyjavadocs, @ResponseBodyjavadocs

Esempi di utilizzo sarebbero qualcosa del genere:

Usando una libreria JavaScript come JQuery, invieresti un oggetto JSON come questo:

{ "firstName" : "Elmer", "lastName" : "Fudd" }

Il metodo del controller sarà simile al seguente:

// controller
@ResponseBody @RequestMapping("/description")
public Description getDescription(@RequestBody UserStats stats){
    return new Description(stats.getFirstName() + " " + stats.getLastname() + " hates wacky wabbits");
}

// domain / value objects
public class UserStats{
    private String firstName;
    private String lastName;
    // + getters, setters
}
public class Description{
    private String description;
    // + getters, setters, constructor
}

Ora se hai Jackson sul tuo percorso di classe (e hai una <mvc:annotation-driven>configurazione), Spring convertirà il JSON in arrivo in un oggetto UserStats dal corpo del post (perché hai aggiunto l' @RequestBodyannotazione) e serializzerebbe l'oggetto restituito in JSON (perché hai aggiunto il @ResponseBodyannotazione). Quindi il browser / client vedrebbe questo risultato JSON:

{ "description" : "Elmer Fudd hates wacky wabbits" }

Vedi questa mia precedente risposta per un esempio di lavoro completo: https://stackoverflow.com/a/5908632/342852

Nota: RequestBody / ResponseBody non è ovviamente limitato a JSON, entrambi possono gestire più formati, inclusi testo normale e XML, ma JSON è probabilmente il formato più utilizzato.

Aggiornare

Sin dalla primavera 4.x, di solito non si utilizzerà @ResponseBodya livello di metodo, ma piuttosto @RestControllera livello di classe, con lo stesso effetto.

Ecco una citazione dalla documentazione ufficiale di Spring MVC :

@RestControllerè un'annotazione composta che è a sua volta meta-annotata con @Controllere @ResponseBodyper indicare un controller il cui ogni metodo eredita l' @ResponseBodyannotazione a livello di tipo e, quindi, scrive direttamente nel corpo della risposta rispetto alla risoluzione della vista e al rendering con un modello HTML.

@RequestBody : le annotazioni che indicano un parametro di metodo devono essere associate al corpo della richiesta HTTP.

Per esempio:

@RequestMapping(path = "/something", method = RequestMethod.PUT)
public void handle(@RequestBody String body, Writer writer) throws IOException {
    writer.write(body);
}

L' annotazione @ResponseBody può essere inserita in un metodo e indica che il tipo restituito deve essere scritto direttamente nel corpo della risposta HTTP (e non inserito in un modello, oppure interpretato come un nome di vista).

Per esempio:

@RequestMapping(path = "/something", method = RequestMethod.PUT)
public  @ResponseBody String helloWorld() {
    return "Hello World";
}  

In alternativa, possiamo usare l' annotazione @RestController al posto @Controllerdell'annotazione. Ciò eliminerà la necessità di utilizzare @ResponseBody.

per ulteriori dettagli

Di seguito è riportato un esempio di un metodo in un controller Java.

@RequestMapping(method = RequestMethod.POST)
@ResponseBody
public HttpStatus something(@RequestBody MyModel myModel) 
{
    return HttpStatus.OK;
}

Usando l'annotazione @RequestBody otterrai i tuoi valori mappati con il modello che hai creato nel tuo sistema per gestire qualsiasi chiamata specifica. Mentre utilizzando @ResponseBody è possibile inviare qualsiasi cosa al luogo da cui è stata generata la richiesta. Entrambe le cose verranno mappate facilmente senza scrivere alcun parser personalizzato ecc.

package com.programmingfree.springshop.controller;

import java.util.List;

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.programmingfree.springshop.dao.UserShop;
import com.programmingfree.springshop.domain.User;


@RestController
@RequestMapping("/shop/user")
public class SpringShopController {

 UserShop userShop=new UserShop();

 @RequestMapping(value = "/{id}", method = RequestMethod.GET,headers="Accept=application/json")
 public User getUser(@PathVariable int id) {
  User user=userShop.getUserById(id);
  return user;
 }


 @RequestMapping(method = RequestMethod.GET,headers="Accept=application/json")
 public List<User> getAllUsers() {
  List<User> users=userShop.getAllUsers();
  return users;
 }


}

Nell'esempio sopra, visualizzeranno tutti i dettagli utente e ID particolare ora voglio usare sia id che nome,

1) localhost: 8093 / plejson / shop / user <--- questo link mostrerà tutti i dettagli dell'utente
2) localhost: 8093 / plejson / shop / user / 11 <---- se uso 11 in link significa, lo farà mostra particolari dettagli dell'utente 11

ora voglio usare sia id che nome

localhost: 8093 / plejson / shop / user / 11 / raju <----------------- in questo modo significa che possiamo usare chiunque in questo per favore aiutatemi .... .