annotazioni @RequestBody e @ResponseBody in primavera

Question

Qualcuno può spiegare le annotazioni @RequestBody e @ResponseBody nella primavera 3? A cosa servono? Ogni esempio sarebbe fantastico.

Answer 1

C'è un'intera sezione nei documenti denominata 16.3.3.4 Mapping the request body with the @RequestBody annotation. E uno chiamato 16.3.3.5 Mapping the response body with the @ResponseBody annotation. Ti suggerisco di consultare quelle sezioni. Anche rilevanti: @RequestBody javadocs, @ResponseBody javadocs

Esempi di utilizzo sarebbe qualcosa di simile:

Utilizzando un Javascript-biblioteca come JQuery, si dovrebbe inviare un JSON-oggetto come questo:

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

tuo metodo di controllo sarebbe simile a questa:

// 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 avete Jackson sul classpath (e disponendo di una configurazione <mvc:annotation-driven>), Spring convertirà il JSON in entrata in un oggetto UserStats dal corpo del post (perché hai aggiunto l'annotazione @RequestBody) e serializzerà l'oggetto restituito a JSON (perché hai aggiunto l'annotazione @ResponseBody). Così il Browser/client vedrebbe questo risultato JSON:

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

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

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

---

Aggiornamento: Sin da 4.x primavera, di solito si Non utilizzare @ResponseBody sul livello di metodo, ma piuttosto @RestController sul livello di classe, con lo stesso effetto. Vedere Creating REST Controllers with the @RestController annotation

Answer 2

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 di cui sopra hanno intenzione di visualizzare tutti i dati dell'utente e particolare id ora voglio utilizzare sia id e il nome,

1) localhost: 8093/plejson/negozio/user < - --Questo link per visualizzare tutti i dettagli utente
2) localhost: 8093/plejson/negozio/user/11 < ---- se io uso 11 nei mezzi di collegamento, verrà visualizzato particolare utente 11 dettagli

ora desidera utilizzare sia l'ID che il nome

localhost: 8093/plejson/shop/user/11/raju < ----------------- come questo significa che possiamo usare qualsiasi in questo per favore aiutami .....

Answer 3

@RequestBody: L'annotazione che indica un parametro di metodo deve essere associata al corpo della richiesta HTTP.

Ad esempio:

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

@ResponseBody annotazione può essere messo su un metodo e indica che il tipo di ritorno deve essere scritto direttamente nel corpo della risposta HTTP (e non posto in un modello, o interpretato come un nome di vista).

Ad esempio:

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

alternativa, possiamo usare @RestController annotazioni al posto di @Controller annotazione. Ciò eliminerà la necessità di utilizzare @ResponseBody.

for more details

Answer 4

seguito è un esempio di un metodo in un controllore Java.

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

Utilizzando annotazione @RequestBody otterrete i vostri valori mappati con il modello è stato creato nel vostro sistema per la gestione di qualsiasi chiamata specifica. Mentre usando @ResponseBody puoi inviare qualcosa al posto da dove è stata generata la richiesta. Entrambe le cose verranno mappate facilmente senza scrivere alcun parser personalizzato ecc.