Http üzenetátalakítók a tavaszi keretrendszerrel

1. Áttekintés

Ez a cikk leírja hogyan kell konfigurálni HttpMessageConverter tavasszal.

Egyszerűen fogalmazva, használhatjuk az üzenetátalakítókat a Java objektumok és a JSON, XML stb. Irányításához és elküldéséhez HTTP-n keresztül.

2. Az alapok

2.1. Engedélyezze a webes MVC-t

Először a webalkalmazásnak kell lennie Spring MVC támogatással konfigurálva. Ennek kényelmes és nagyon testreszabható módja a @EnableWebMvc kommentár:

@EnableWebMvc @Configuration @ComponentScan ({"com.baeldung.web"}) nyilvános osztály WebConfig valósítja meg a WebMvcConfigurer {...}

Vegye figyelembe, hogy ez az osztály megvalósítja WebMvcConfigurer - amely lehetővé teszi számunkra, hogy a sajátunkkal megváltoztassuk a Http átalakítók alapértelmezett listáját.

2.2. Az alapértelmezett üzenetátalakítók

Alapértelmezés szerint a következő HttpMessageConverter s példányai előre engedélyezve vannak:

  • ByteArrayHttpMessageConverter - átalakítja a bájt tömböket
  • StringHttpMessageConverter - konvertálja a húrokat
  • ResourceHttpMessageConverter - megtért org.springframework.core.io.Resource bármilyen típusú oktettfolyamra
  • SourceHttpMessageConverter - megtért javax.xml.transform.Source
  • FormHttpMessageConverter - konvertálja az űrlap adatait a-ba MultiValueMap.
  • Jaxb2RootElementHttpMessageConverter - konvertálja a Java objektumokat XML-ből / -be (csak akkor adjuk hozzá, ha a JAXB2 van az osztályúton)
  • MappingJackson2HttpMessageConverter - konvertálja a JSON-ot (csak akkor adjuk hozzá, ha a Jackson 2 jelen van az osztályúton)

  • MappingJacksonHttpMessageConverter - konvertálja a JSON-ot (csak akkor adjuk hozzá, ha Jackson jelen van az osztályúton)
  • AtomFeedHttpMessageConverter - átalakítja az Atom hírcsatornákat (csak akkor adjuk hozzá, ha Róma jelen van az osztályúton)
  • RssChannelHttpMessageConverter - átalakítja az RSS-hírcsatornákat (csak akkor adjuk hozzá, ha Róma jelen van az osztályúton)

3. Ügyfél-kiszolgáló kommunikáció - csak JSON

3.1. Magas szintű tartalmi tárgyalás

Minden egyes HttpMessageConverter a megvalósítás egy vagy több társított MIME-típussal rendelkezik.

Amikor új kérést kap, A tavasz aElfogad”Fejlécet annak a hordozótípusnak a meghatározásához, amellyel reagálnia kell.

Ezután megpróbálja megtalálni a regisztrált átalakítót, amely képes kezelni az adott médiatípust. Végül ezt fogja használni az entitás konvertálására és a válasz visszaküldésére.

A folyamat hasonló a JSON-információkat tartalmazó kérés fogadásához. A keret fog használja a "Tartalom típus”Fejléc a kérelem törzsének médiatípusának meghatározásához.

Ezután megkeresi a HttpMessageConverter amely átalakíthatja az ügyfél által küldött törzset Java objektummá.

Tisztázzuk ezt egy gyors példával:

  • az Ügyfél GET kérést küld a / foos a ... val Elfogad fejléc beállítása alkalmazás / json - hogy mindent megkapjon Foo erőforrásokat JSON néven
  • a Foo A rugóvezérlőt eltalálja, és visszaadja a megfelelőt Foo Java entitások
  • Ezután Spring az egyik Jackson üzenet-átalakító segítségével rendezi az entitásokat a JSON-hoz

Most nézzük meg, hogyan működik ez - és hogyan tudjuk kihasználni a @ResponseBody és @RequestBody annotációk.

3.2. @ResponseBody

@ResponseBody egy Controller módszerrel jelzi Springnek, hogy a metódus visszatérési értéke közvetlenül a HTTP-válasz törzséhez kerül sorosításra. Amint fentebb említettük, a „Elfogad”Az ügyfél által megadott fejlécet használjuk az entitás rendezéséhez a megfelelő Http Converter kiválasztására.

Nézzünk meg egy egyszerű példát:

@GetMapping ("/ {id}") public @ResponseBody Foo findById (@PathVariable long id) {return fooService.findById (id); }

Most az ügyfél megadja az „Accept” fejlécet alkalmazás / json a kérésben - példa becsavar parancs:

curl - header "Elfogadom: application / json" // localhost: 8080 / spring-boot-rest / foos / 1

A Foo osztály:

nyilvános osztály Foo {private long id; privát karakterlánc neve; }

És a Http Response Body:

{"id": 1, "name": "Paul",}

3.3. @ RequestBody

Használhatjuk a @ RequestBody annotáció a Controller metódus argumentumán a jelzéshez hogy a HTTP-kérelem törzse az adott Java-entitáshoz deserializált. A megfelelő átalakító meghatározásához Spring az ügyfélkérelem „Content-Type” fejlécét használja.

Nézzünk meg egy példát:

@PutMapping ("/ {id}") public @ResponseBody void update (@RequestBody Foo foo, @PathVariable String id) {fooService.update (foo); }

Ezután fogyasszuk el ezt egy JSON objektummal - megadjuk a „Tartalom-típust lenni alkalmazás / json:

curl -i -X ​​PUT -H "Tartalom-típus: application / json" -d '{"id": "83", "name": "klik"}' // localhost: 8080 / spring-boot-rest / foos / 1

200 OK-t kapunk vissza - sikeres válasz:

HTTP / 1.1 200 OK Szerver: Apache-Coyote / 1.1 Tartalom-hossz: 0 Dátum: 2014. január 10., péntek 11:18:54 GMT

4. Egyéni átalakítók beállítása

Azt is megtehetjük testreszabhatja az üzenetátalakítókat a WebMvcConfigurer felület és felülírja a configureMessageConverter módszer:

@EnableWebMvc @Configuration @ComponentScan ({"com.baeldung.web"}) nyilvános osztály A WebConfig megvalósítja a WebMvcConfigurer {@Override public void configureMessageConverters (List konverterek) {messageConverters.add (createXmlHttpMessageConverter ()); messageConverters.add (új MappingJackson2HttpMessageConverter ()); } private HttpMessageConverter createXmlHttpMessageConverter () {MarshallingHttpMessageConverter xmlConverter = új MarshallingHttpMessageConverter (); XStreamMarshaller xstreamMarshaller = új XStreamMarshaller (); xmlConverter.setMarshaller (xstreamMarshaller); xmlConverter.setUnmarshaller (xstreamMarshaller); return xmlConverter; }}

Ebben a példában egy új átalakítót hozunk létre - a MarshallingHttpMessageConverter - és a Spring XStream támogatás használatával konfigurálható. Ez nagy rugalmasságot enged azóta az alapul szolgáló rendezési keret alacsony szintű API -ival dolgozunk - ebben az esetben az XStream - és konfigurálhatjuk, amit akarunk.

Vegye figyelembe, hogy ebben a példában meg kell adni az XStream könyvtárat az osztályútvonalhoz.

Vegye figyelembe azt is, hogy a támogatási osztály kibővítésével elveszítjük az előzetesen regisztrált alapértelmezett üzenetátalakítókat.

Természetesen most ugyanezt tehetjük Jacksonért is - saját magunk meghatározásával MappingJackson2HttpMessageConverter. Most beállíthatunk egy szokást ObjectMapper ezen a konverteren, és konfiguráljuk a szükség szerint.

Ebben az esetben az XStream volt a kiválasztott marshaller / unmarshaller megvalósítás, de mások is szeretik CastorMarshaller használható is.

Ezen a ponton - engedélyezve az XML-t a háttérben - az API-t XML-ábrázolásokkal tudjuk fogyasztani:

curl --header "Elfogadás: application / xml" // localhost: 8080 / spring-boot-rest / foos / 1

4.1. Tavaszi csomagtartó támogatás

Ha a Spring Boot programot használjuk, elkerülhetjük a WebMvcConfigurer és manuálisan hozzáadjuk az összes üzenetátalakítót, ahogy fentebb tettük.

Csak mást határozhatunk meg HttpMessageConverter babot a kontextusban, és a Spring Boot automatikusan hozzáadja őket az általa létrehozott automatikus konfigurációhoz:

@Bean public HttpMessageConverter createXmlHttpMessageConverter () {MarshallingHttpMessageConverter xmlConverter = új MarshallingHttpMessageConverter (); // ... return xmlConverter; }

5. A tavasz használata RestTemplate Http üzenet konverterekkel

A kiszolgálói oldal mellett a Http Message Conversion a tavaszi kliens oldalon konfigurálható RestTemplate.

A sablont a „Elfogad”És„Tartalom típusFejléceket, ha szükséges. Ezután megpróbáljuk elfogyasztani a REST API-t az Foo Erőforrás - mind a JSON-nal, mind az XML-lel.

5.1. Az erőforrás beolvasása nem Elfogad Fejléc

@Test public void testGetFoo () {String URI = “// localhost: 8080 / spring-boot-rest / foos / {id}"; RestTemplate restTemplate = new RestTemplate (); Foo foo = restTemplate.getForObject (URI, Foo. osztály, "1"); Assert.assertEquals (új egész szám (1), foo.getId ());}

5.2. Erőforrás lekérése a következővel: application / xml Fogadja el a fejlécet

Most keressük meg kifejezetten az erőforrást XML-ábrázolásként. Meghatározzuk az átalakítók készletét, és ezeket beállítjuk a RestTemplate.

Mivel XML-t fogyasztunk, ugyanazt az XStream marshallert fogjuk használni, mint korábban:

@Test public void givenConsumingXml_whenReadingTheFoo_thenCorrect () {String URI = BASE_URI + "foos / {id}"; RestTemplate restTemplate = új RestTemplate (); restTemplate.setMessageConverters (getMessageConverters ()); HttpHeaders fejlécek = new HttpHeaders (); headers.setAccept (Arrays.asList (MediaType.APPLICATION_XML)); HttpEntity entitás = new HttpEntity (fejlécek); ResponseEntity response = restTemplate.exchange (URI, HttpMethod.GET, entitás, Foo.class, "1"); Foo erőforrás = response.getBody (); assertThat (erőforrás, nemNullValue ()); } privát lista getMessageConverters () {XStreamMarshaller marshaller = új XStreamMarshaller (); MarshallingHttpMessageConverter marshallingConverter = új MarshallingHttpMessageConverter (marshaller); Lista konverterek = ArrayList(); converters.add (marshallingConverter); visszatérő átalakítók; }

5.3. Erőforrás lekérése a következővel: alkalmazás / json Fogadja el a fejlécet

Hasonlóképpen, most fogyasszuk el a REST API-t azzal, hogy JSON-t kérünk:

@Test public void givenConsumingJson_whenReadingTheFoo_thenCorrect () {String URI = BASE_URI + "foos / {id}"; RestTemplate restTemplate = új RestTemplate (); restTemplate.setMessageConverters (getMessageConverters ()); HttpHeaders fejlécek = new HttpHeaders (); headers.setAccept (Arrays.asList (MediaType.APPLICATION_JSON)); HttpEntity entitás = new HttpEntity (fejlécek); ResponseEntity response = restTemplate.exchange (URI, HttpMethod.GET, entitás, Foo.class, "1"); Foo erőforrás = response.getBody (); assertThat (erőforrás, nemNullValue ()); } privát lista getMessageConverters () {Lista konverterek = új ArrayList(); converters.add (új MappingJackson2HttpMessageConverter ()); visszatérő átalakítók; }

5.4. Erőforrás frissítése XML használatával Tartalom típus

Végül küldjünk JSON adatokat is a REST API-nak, és adjuk meg az adatok média típusát a Tartalom típus fejléc:

@Test public void givenConsumingXml_whenWritingTheFoo_thenCorrect () {String URI = BASE_URI + "foos / {id}"; RestTemplate restTemplate = új RestTemplate (); restTemplate.setMessageConverters (getMessageConverters ()); Foo erőforrás = new Foo (4, "jason"); HttpHeaders fejlécek = new HttpHeaders (); headers.setAccept (Arrays.asList (MediaType.APPLICATION_JSON)); fejlécek.setContentType ((MediaType.APPLICATION_XML)); HttpEntity entitás = new HttpEntity (erőforrás, fejlécek); ResponseEntity response = restTemplate.exchange (URI, HttpMethod.PUT, entitás, Foo.class, resource.getId ()); Foo fooResponse = response.getBody (); Assert.assertEquals (erőforrás.getId (), fooResponse.getId ()); }

Itt érdekes az, hogy képesek vagyunk keverni a médiatípusokat - küldünk XML adatokat, de várjuk a JSON adatokat a szerverről. Ez megmutatja, hogy a Spring konverziós mechanizmus valóban milyen erős.

6. Következtetés

Ebben az oktatóanyagban megvizsgáltuk, hogy a Spring MVC miként teszi lehetővé a Http Message Converter átalakítását és teljes testreszabását automatikusan marshall / unmhallhall Java entitások az XML vagy a JSON felé. Ez természetesen leegyszerűsített meghatározás, és még sok minden mást képes megtenni az üzenetkonverziós mechanizmus - amint azt az utolsó tesztpéldából is láthatjuk.

Megvizsgáltuk azt is, hogyan lehet kihasználni ugyanazt az erős mechanizmust a RestTemplate kliens - az API használatának teljes típusbiztonságához vezet.

Mint mindig, az ebben a cikkben bemutatott kód elérhető a Github oldalon.