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.