Tavaszi RequestMapping

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.