JSON-parameters met Spring MVC

1. Overzicht

In deze korte zelfstudie gaan we nader bekijken hoe u met JSON-parameters in Spring MVC kunt werken.

Eerst beginnen we met een beetje achtergrondinformatie over JSON-parameters. Vervolgens gaan we het konijnenhol in om te zien hoe JSON-parameters in POST- en GET-verzoeken kunnen worden verzonden.

2. JSON-parameters in Spring MVC

Het gebruik van JSON om gegevens te verzenden of te ontvangen is een gangbare praktijk onder webontwikkelaars. De hiërarchische structuur van de JSON-strings biedt een compactere en door mensen leesbare manier om HTTP-verzoekparameters weer te geven.

Spring MVC biedt standaard kant-en-klare gegevensbinding voor eenvoudige gegevenstypen zoals Draad. Voor dat doel gebruikt het een lijst met ingebouwde eigendomsredacteurs onder de motorkap.

In real-world projecten willen we misschien meer complexe gegevenstypen binden. Het kan bijvoorbeeld handig zijn om een ​​JSON-parameter in een modelobject te kunnen mappen.

3. Verzend JSON-gegevens in POST

Spring biedt een eenvoudige manier om JSON-gegevens via POST-verzoeken te verzenden. De ingebouwde @RequestBody annotatie kan de JSON-gegevens die zijn ingekapseld in de hoofdtekst van het verzoek automatisch deserialiseren naar een bepaald modelobject.

Over het algemeen hoeven we de hoofdtekst van het verzoek niet zelf te analyseren. We kunnen de Jackson-bibliotheek gebruiken om al het zware werk voor ons te doen.

Laten we nu eens kijken hoe we JSON-gegevens kunnen verzenden via een POST-verzoek in Spring MVC.

Ten eerste moeten we een modelobject maken om de doorgegeven JSON-gegevens weer te geven. Beschouw bijvoorbeeld de Product klasse:

public class Product {privé int id; private String naam; particuliere dubbele prijs; // standaard constructor + getters + setters}

Laten we ten tweede een Spring-handler-methode definiëren die POST-verzoeken accepteert:

@PostMapping ("/ create") @ResponseBody public Product createProduct (@RequestBody Product product) {// aangepast logisch retourproduct; }

Zoals we kunnen zien, annoteren van de Product ruzie met @RequestBody is voldoende om de JSON-gegevens die door de clients zijn verzonden, te binden.

Nu kunnen we ons POST-verzoek testen met cURL:

curl -i \ -H "Accept: application / json" \ -H "Content-Type: application / json" \ -X POST --data \ '{"id": 1, "name": "Asus Zenbook", "price": 800} '"// localhost: 8080 / spring-mvc-basics-4 / products / create"

4. Verzend JSON-parameter in GET

Spring MVC biedt @RequestParam om queryparameters uit GET-verzoeken te extraheren. In tegenstelling tot @RequestBody, de @RequestParam annotatie ondersteunt alleen eenvoudige gegevenstypen zoals int en Draad.

Dus om JSON te verzenden, moeten we onze JSON-parameter definiëren als een eenvoudige tekenreeks.

De grote vraag hier is: hoe converteren we onze JSON-parameter (dat is een Draad) in een object van de Product klasse?

Het antwoord is vrij simpel! De ObjectMapper klasse geleverd door de Jackson-bibliotheek biedt een flexibele manier om JSON-strings om te zetten in Java-objecten.

Laten we nu eens kijken hoe we een JSON-parameter kunnen verzenden via een GET-verzoek in Spring MVC. Eerst moeten we een andere handlermethode in onze controller maken om GET-verzoeken af ​​te handelen:

@GetMapping ("/ get") @ResponseBody openbaar Product getProduct (@RequestParam String-product) genereert JsonMappingException, JsonProcessingException {Product prod = objectMapper.readValue (product, Product.class); terug prod; }

Zoals hierboven getoond, is de readValue () methode maakt het deserialiseren van de JSON-parameter mogelijk Product rechtstreeks in een instantie van de Product klasse.

Merk op dat we onze JSON-queryparameter definiëren als een Draad voorwerp. Nu, wat als we willen slagen voor een Product object zoals we deden bij het gebruik @RequestBody?

Om deze vraag te beantwoorden, biedt Spring een beknopte en flexibele oplossing via aangepaste vastgoededitors.

Eerste, we zullen een aangepaste eigenschap-editor moeten maken om de logica van het converteren van de JSON-parameter die wordt gegeven als een Draad naar een Product voorwerp:

openbare klasse ProductEditor breidt PropertyEditorSupport {private ObjectMapper objectMapper uit; openbare ProductEditor (ObjectMapper objectMapper) {this.objectMapper = objectMapper; } @Override public void setAsText (String-tekst) gooit IllegalArgumentException {if (StringUtils.isEmpty (tekst)) {setValue (null); } else {Product prod = new Product (); probeer {prod = objectMapper.readValue (tekst, Product.class); } catch (JsonProcessingException e) {gooi nieuwe IllegalArgumentException (e); } setValue (prod); }}}

Laten we vervolgens de JSON-parameter binden aan een object van Product klasse:

@GetMapping ("/ get2") @ResponseBody openbaar product get2Product (@RequestParam Productproduct) {// aangepast logisch retourproduct; }

Ten slotte moeten we het laatste ontbrekende stukje van de puzzel toevoegen. Laten we registreren Producteditor in onze Spring-controller:

@InitBinder openbare void initBinder (WebDataBinder-binder) {binder.registerCustomEditor (Product.class, nieuwe ProductEditor (objectMapper)); }

Bedenk dat we moeten de JSON-parameter URL-coderen om veilig transport te garanderen.

Dus in plaats van:

GET / spring-mvc-basics-4 / products / get2? Product = {"id": 1, "name": "Asus Zenbook", "price": 800}

We moeten sturen:

GET / spring-mvc-basics-4 / products / get2? Product =% 7B% 22id% 22% 3A% 201% 2C% 22name% 22% 3A% 20% 22Asus% 20Zenbook% 22% 2C% 22price% 22% 3A % 20800% 7D

5. Conclusie

Kortom, we hebben gezien hoe we met JSON kunnen werken in Spring MVC. Onderweg hebben we laten zien hoe u JSON-parameters kunt verzenden in POST- en GET-verzoeken.

Zoals altijd is de volledige broncode van de voorbeelden beschikbaar op GitHub.


$config[zx-auto] not found$config[zx-overlay] not found