streamalism.org

1. Áttekintés

Ebben az oktatóanyagban a következők egyikére koncentrálunk: Tavaszi MVC: @RequestMapping.

Egyszerűen fogalmazva: az annotációt a webes kérések Spring Controller módszerekhez való leképezésére használják.

2. @RequestMapping Alapok

Kezdjük egy egyszerű példával: egy HTTP-kérés hozzárendelése egy metódushoz néhány alapvető feltétel felhasználásával.

2.1. @RequestMapping - Path által

@RequestMapping (value = "/ ex / foos", method = RequestMethod.GET) @ResponseBody public String getFoosBySimplePath () {return "Get some Foos"; }

Ennek a feltérképezésnek egyszerű kipróbálása becsavar parancs, futtassa:

göndör -i // localhost: 8080 / spring-rest / ex / foos

2.2. @RequestMapping - a HTTP módszer

A HTTP módszer paraméter rendelkezik nincs alapértelmezett. Tehát, ha nem adunk meg értéket, akkor minden HTTP-kéréshez hozzárendel.

Íme egy egyszerű példa, hasonló az előzőhöz, de ezúttal egy HTTP POST-kérelemhez van hozzárendelve:

@RequestMapping (value = "/ ex / foos", method = POST) @ResponseBody public String postFoos () {return "Post some Foos"; }

A POST teszteléséhez a becsavar parancs:

göndör -i -X ​​POST // localhost: 8080 / rugós-pihenő / ex / foos

3. RequestMapping és a HTTP fejlécek

3.1. @RequestMapping A ... val fejlécek Tulajdonság

A leképezés még tovább szűkíthető, ha megad egy fejlécet a kéréshez:

@RequestMapping (value = "/ ex / foos", header = "key = val", method = GET) @ResponseBody public String getFoosWithHeader () {return "Get some Foos with Header"; }

A működés teszteléséhez a becsavar fejléc támogatás:

curl -i -H "key: val" // localhost: 8080 / rugós-rest / ex / foos

és akár több fejléc is a fejlécek attribútuma @RequestMapping:

@RequestMapping (value = "/ ex / foos", header = {"key1 = val1", "key2 = val2"}, method = GET) @ResponseBody public String getFoosWithHeaders () {return "Get some Foos with Header"; }

Ezt a következő paranccsal tesztelhetjük:

curl -i -H "key1: val1" -H "key2: val2" // localhost: 8080 / rugóstag / ex / foos

Vegye figyelembe, hogy a becsavar szintaxis, kettőspont választja el a fejléc kulcsot és a fejléc értékét, ugyanaz, mint a HTTP specifikációban, míg tavasszal az egyenlőségjelet használják.

3.2. @RequestMapping Fogyaszt és gyárt

Térképezés egy vezérlő által előállított médiatípusok módszer külön figyelmet érdemel.

Térképezhetünk egy kérést annak alapján Elfogad fejléc a @RequestMappingfejlécek a fent bevezetett attribútum:

@RequestMapping (value = "/ ex / foos", method = GET, header = "Accept = application / json") @ResponseBody public String getFoosAsJsonFromBrowser () {return "Get some Foos with Header Old"; }

Az illesztés a módszer meghatározásának ezen módjára Elfogad a fejléc rugalmas - az egyenlő helyett tartalmazza a tartalmat, így az alábbi kérés továbbra is helyesen térképezné fel:

curl -H "Elfogadás: application / json, text / html" // localhost: 8080 / spring-rest / ex / foos

A 3.1 tavasztól kezdve a @RequestMapping az annotációban megvan a termel és fogyaszt attribútumokat, kifejezetten erre a célra:

@RequestMapping (value = "/ ex / foos", method = RequestMethod.GET, tuottaa = "application / json") @ResponseBody public String getFoosAsJsonFromREST () {return "Get some Foos with Header New"; }

Ezenkívül a régi típusú leképezés a fejlécek attribútum automatikusan átalakul az új termel a 3.1 tavasszal kezdődő mechanizmus, így az eredmények azonosak lesznek.

Ezt keresztül fogyasztják becsavar ugyanúgy:

curl -H "Elfogadás: application / json" // localhost: 8080 / rugós-rest / ex / foos

Ezenkívül termel több értéket is támogat:

@RequestMapping (value = "/ ex / foos", method = GET, {= application / json "," application / xml "})

Ne feledje, hogy ezek - a régi és új módszerek a Elfogad fejléc - alapvetően ugyanazok a leképezések, így a Spring nem engedi meg őket együtt.

Ha mindkét módszer aktív lenne, az a következőket eredményezné:

Okozta: java.lang.IllegalStateException: Kétértelmű feltérképezés található. A „fooController” babmódszer nem java.lang.String org.baeldung.spring.web.controller .FooController.getFoosAsJsonFromREST () nem rendelhető ide: [[/ ex / foos], method = [GET], params = [], header = [ ], fogyaszt = [], termel = [alkalmazás / json], custom = []}: Már van egy „fooController” bab módszer java.lang.String org.baeldung.spring.web.controller .FooController.getFoosAsJsonFromBrowser () leképezve .

Utolsó megjegyzés az újról termel és fogyaszt mechanizmusok, amelyek eltérően viselkednek a legtöbb egyéb kommentártól: Ha típusszinten adják meg, a módszer szintű annotációk nem kiegészítik, hanem felülírják a típusszintű információk.

És természetesen, ha mélyebbre akarsz ásni egy REST API felépítésével a Springszel, nézd meg az új REST tavaszi tanfolyammal.

4. RequestMapping Útváltozókkal

A leképezés URI egyes részei a @PathVariable annotáció.

4.1. Egyetlen @PathVariable

Egyszerű példa egyetlen útváltozóval:

@RequestMapping (value = "/ ex / foos / {id}", method = GET) @ResponseBody public String getFoosBySimplePathWithPathVariable (@PathVariable ("id") long id) {return "Konkrét Foo megszerzése a / ex / foos / { id} ", method = GET) @ResponseBody public String getFoosBySimplePathWithPathVariable (@PathVariable String id) {return" Adjon meg egy konkrét Foo-t, többszörös-többszörös-változóval ">4.2. Többszörös @PathVariable
Egy összetettebb URI-hez szükség lehet az URI több részének leképezésére több érték:
@RequestMapping (value = "/ ex / foos / {fooid} / bar / {barid}", módszer = GET) @ResponseBody public String getFoosBySimplePathWithPathVariables (@PathVariable long fooid, @PathVariable long barid) {return "Adjon meg egy adott sávot egy Foo with3-pathvariable-with-regex ">4.3. @PathVariable A Regexszel
Rendszeres kifejezéseket is lehet használni a @PathVariable.
Például korlátozzuk a leképezést, hogy csak numerikus értékeket fogadjon el a id:
@RequestMapping (érték = "/ ex / bárok / {numericId: [\ d] +}", módszer = GET) @ResponseBody nyilvános karakterlánc getBarsBySimplePathWithPathVariable (@PathVariable long numericId) {return "Adjon meg egy adott sávot withrequest-param">5. RequestMapping Kérés paraméterekkel
A @RequestMapping egyszerű URL paraméterek leképezése a @RequestParam annotáció. 
Most feltérképezünk egy kérést egy URI-hoz:
// localhost: 8080 / spring-rest / ex / bars? id = 100
@RequestMapping (érték = "/ ex / bárok", módszer = GET) @ResponseBody nyilvános karakterlánc getBarBySimplePathWithRequestParam (@RequestParam ("id") hosszú id) {return "Adjon meg egy adott sávot / ex / bárokkal", params = "id ", method = GET) @ResponseBody public String getBarBySimplePathWithExplicitRequestParam (@RequestParam (" id ") long id) {return" Adjon meg egy adott sávot / ex / bárokkal ", params = {" id "," second "}, módszer = GET) @ResponseBody public String getBarBySimplePathWithExplicitRequestParams (@RequestParam ("id") long id) {return "Narrow Get a specific Bar withcorner-cases">6. RequestMapping Sarok tokok
6.1. @RequestMapping - Több útvonal hozzárendelve ugyanazon vezérlő módszerhez
Bár egyetlen @RequestMapping az útvonal értékét általában egyetlen vezérlő módszerhez használják (csak jó gyakorlat, nem kemény és gyors szabály), vannak olyan esetek, amikor szükség lehet több kérés leképezésére ugyanarra a módszerre.
Ebben az esetben, a érték attribútuma @RequestMapping több leképezést is elfogad, nem csak egyetlen:
@RequestMapping (value = {"/ ex / advanced / bars", "/ ex / advanced / foos"}, method = GET) @ResponseBody public String getFoosOrBarsByPath () {return "Advanced - Get some Foos or Bars"; }
Most mindkettő becsavar a parancsoknak ugyanazt a módszert kell elérniük:
curl -i // localhost: 8080 / rugós-rest / ex / advanced / foos curl -i // localhost: 8080 / spring-rest / ex / advanced / bars
6.2. @RequestMapping - Több HTTP kérési módszer ugyanazon vezérlő módszerhez
Több, különböző HTTP igéket használó kérelem leképezhető ugyanarra a vezérlő metódusra:
@RequestMapping (value = "/ ex / foos / multiple", method = {RequestMethod.PUT, RequestMethod.POST}) @ResponseBody public String putAndPostFoos () {return "Advanced - PUT és POST egyetlen módszeren belül"; }
Val vel becsavar, mindkettő ugyanazt a módszert fogja elérni:
curl -i -X ​​POST // localhost: 8080 / rugós-rest / ex / foos / multiple curl -i -X ​​PUT // localhost: 8080 / spring-rest / ex / foos / multiple
6.3. @RequestMapping - tartalék minden kéréshez
Egy egyszerű tartalék megvalósítása az összes kérelem számára egy adott HTTP módszer segítségével, például egy GET esetében:
@RequestMapping (value = "*", method = RequestMethod.GET) @ResponseBody public String getFallback () {return "Fallback for GET Requests"; }
vagy akár minden kérés esetén:
@RequestMapping (érték = "*", módszer = {RequestMethod.GET, RequestMethod.POST ...}) @ResponseBody public String allFallback () {return "Fallback for All Requests"; }
6.4. Kétértelmű feltérképezési hiba
A kétértelmű feltérképezési hiba akkor következik be, amikor Spring két vagy több kérés-hozzárendelést azonosnak értékel a különböző vezérlő módszereknél. A kérelem-hozzárendelés ugyanaz, ha ugyanaz a HTTP-módszer, URL, paraméterek, fejlécek és médiatípus van.
Például ez egy félreérthető feltérképezés:
@GetMapping (value = "foos / duplicate") public String duplicate () {return "Duplicate"; } @GetMapping (value = "foos / duplicate") public String duplicateEx () {return "Duplicate"; }
A dobott kivételnek általában hibaüzenetei vannak az alábbiak szerint:
Okozta: java.lang.IllegalStateException: Kétértelmű feltérképezés. A 'fooMappingExamplesController' módszer nyilvános java.lang.String org.baeldung.web.controller.FooMappingExamplesController.duplicateEx () nem térképezhető le a [[/ ex / foos / duplicate], Methods = [GET]} fájlra: Már van 'fooMappingExameansConon metódus public java.lang.String org.baeldung.web.controller.FooMappingExamplesController.duplicate () leképezve.
A hibaüzenet figyelmes elolvasása arra utal, hogy Spring nem képes feltérképezni a módszert org.baeldung.web.controller.FooMappingExamplesController.duplicateEx (), mivel ellentmondásos térképezése van egy már leképezettel org.baeldung.web.controller.FooMappingExamplesController.duplicate ().
Az alábbi kódrészlet nem eredményez kétértelmű feltérképezési hibát, mert mindkét módszer különböző tartalomtípusokat ad vissza:
@GetMapping (value = "foos / duplicate", tuottaa = MediaType.APPLICATION_XML_VALUE) public String duplicateXml () {return "Duplicate"; } @GetMapping (value = "foos / duplicate", tuottaa = MediaType.APPLICATION_JSON_VALUE) public String duplicateJson () {return "{\" message \ ": \" Duplicate \ "}"; }
Ez a megkülönböztetés lehetővé teszi, hogy vezérlőnk a helyes adatábrázolást adja vissza a Elfogadja a kérésben megadott fejléc.
Ennek másik megoldási módja a két érintett módszer egyikéhez rendelt URL frissítése.
7. Új kérelem leképezési parancsikonok
 A Spring Framework 4.3 néhány új, HTTP alapú hozzárendelési jegyzetet vezetett be @RequestMapping : 
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
 Ezek az új kommentárok javíthatják az olvashatóságot és csökkenthetik a kód részletességét. 
 Nézzük meg ezeket az új megjegyzéseket a CRUD műveleteket támogató RESTful API létrehozásával: 
@GetMapping ("/ {id}") public ResponseEntity getBazz (@PathVariable String id) {return new ResponseEntity (new Bazz (id, "Bazz" + id), HttpStatus.OK); } @ PostMapping public ResponseEntity newBazz (@RequestParam ("name") String name) {return new ResponseEntity (new Bazz ("5", name), HttpStatus.OK); } @PutMapping ("/ {id}") public ResponseEntity updateBazz (@PathVariable String id, @RequestParam ("name") String name) {return new ResponseEntity (new Bazz (id, name), HttpStatus.OK); } @DeleteMapping ("/ {id}") public ResponseEntity deleteBazz (@PathVariable String id) {return new ResponseEntity (new Bazz (id), HttpStatus.OK); }
 Ezekbe mély merülés található itt. 
8. Tavaszi konfiguráció
A tavaszi MVC konfiguráció elég egyszerű, tekintve, hogy a mi FooController meghatározása a következő csomagban történik:
org.baeldung.spring.web.controller csomag; @Controller nyilvános osztály FooController {...}
Egyszerűen szükségünk van egy @ Konfiguráció osztály a teljes MVC támogatás engedélyezéséhez és a vezérlő osztályút keresésének konfigurálásához:
@Configuration @EnableWebMvc @ComponentScan ({"org.baeldung.spring.web.controller"}) nyilvános osztály MvcConfig {//}
9. Következtetés
Ez a cikk a @RequestMapping annotáció tavasszal, egy egyszerű használati eset megbeszélése, a HTTP fejlécek leképezése, az URI egyes részeinek megkötése a @PathVariable, valamint az URI paraméterekkel és a @RequestParam annotáció.
Ha szeretné megtanulni, hogyan használjon még egy alapjegyzetet a Spring MVC-ben, fedezze fel a @ModelAttribute annotáció itt.
A cikk teljes kódja elérhető a GitHub oldalon.