streamalism.org

1. Prehľad

V tomto tutoriáli sa zameriame na jednu z hlavných anotácií v Jarná MVC: @RequestMapping.

Jednoducho povedané, anotácia sa používa na mapovanie webových požiadaviek na metódy Spring Controller.

2. @RequestMapping Základy

Začnime jednoduchým príkladom: mapovanie požiadavky HTTP na metódu pomocou niektorých základných kritérií.

2.1. @RequestMapping - cestou

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

Vyskúšajte toto mapovanie pomocou jednoduchého zvlnenie príkaz, spustiť:

curl -i // localhost: 8080 / spring-rest / ex / foos

2.2. @RequestMapping - metóda HTTP

HTTP metóda parameter má žiadne predvolené nastavenie. Pokiaľ teda neurčíme hodnotu, bude sa mapovať na akúkoľvek požiadavku HTTP.

Tu je jednoduchý príklad, podobný predchádzajúcemu, ale tentokrát mapovaný na požiadavku HTTP POST:

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

Ak chcete otestovať POST prostredníctvom a zvlnenie príkaz:

curl -i -X ​​POST // localhost: 8080 / spring-rest / ex / foos

3. RequestMapping a hlavičky HTTP

3.1. @RequestMapping Vďaka hlavičky Atribút

Mapovanie je možné ešte viac zúžiť zadaním hlavičky požiadavky:

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

Na otestovanie prevádzky použijeme zvlnenie podpora hlavičiek:

curl -i -H "key: val" // localhost: 8080 / spring-rest / ex / foos

a dokonca aj viac hlavičiek cez hlavičky atribút @RequestMapping:

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

Môžeme to otestovať pomocou príkazu:

curl -i -H "key1: val1" -H "key2: val2" // localhost: 8080 / spring-rest / ex / foos

Všimnite si, že pre zvlnenie syntax, dvojbodka oddeľuje kľúč hlavičky a hodnotu hlavičky, rovnako ako v špecifikácii HTTP, zatiaľ čo na jar sa používa znamienko rovnosti.

3.2. @RequestMapping Konzumuje a vyrába

Mapovanie typy médií produkované radičom metóda stojí za osobitnú pozornosť.

Na základe toho môžeme zmapovať požiadavku súhlasiť hlavička cez @RequestMappinghlavičky vyššie uvedený atribút:

@RequestMapping (value = "/ ex / foos", method = GET, headers = "Accept = application / json") @ResponseBody public String getFoosAsJsonFromBrowser () {návrat "Získajte nejaké Foos so starou hlavičkou"; }

Zhoda pre tento spôsob definovania súhlasiť hlavička je flexibilná - používa namiesto rovnocenných obsahuje, takže požiadavka, ako je napríklad táto, by sa aj naďalej mapovala správne:

curl -H "Prijať: application / json, text / html" // localhost: 8080 / spring-rest / ex / foos

Počnúc jarom 3.1 @RequestMapping anotácia má teraz vyrába a spotrebúva atribúty, konkrétne na tento účel:

@RequestMapping (value = "/ ex / foos", method = RequestMethod.GET, produce = "application / json") @ResponseBody public String getFoosAsJsonFromREST () {návrat "Získajte nejaké Foos s hlavičkou New"; }

Tiež starý typ mapovania s hlavičky atribút sa automaticky prevedie na nový vyrába mechanizmus začínajúci na jar 3.1, takže výsledky budú identické.

Toto sa spotrebúva prostredníctvom zvlnenie rovnakym sposobom:

curl -H "Prijať: application / json" // localhost: 8080 / spring-rest / ex / foos

Navyše, vyrába podporuje aj viac hodnôt:

@RequestMapping (hodnota = "/ ex / foos", metóda = GET, produkuje = {"application / json", "application / xml"})

Majte na pamäti, že tieto - starý a nový spôsob špecifikácie súhlasiť hlavička - sú v podstate rovnaké mapovanie, takže Spring ich nedovolí spolu.

Aktivácia oboch týchto metód by mala za následok:

Spôsobil: java.lang.IllegalStateException: Bolo nájdené nejednoznačné mapovanie. Nie je možné mapovať fazuľovú metódu 'fooController' java.lang.String org.baeldung.spring.web.controller .FooController.getFoosAsJsonFromREST () na {[/ ex / foos], methods = [GET], params = [], headers = [ ], consumes = [], produce = [application / json], custom = []}: Existuje už metóda „fooController“ fazule java.lang.String org.baeldung.spring.web.controller .FooController.getFoosAsJsonFromBrowser () .

Posledná poznámka k novému vyrába a spotrebúva mechanizmy, ktoré sa správajú odlišne od väčšiny ostatných anotácií: Keď sú určené na úrovni typu, anotácie na úrovni metódy sa nedopĺňajú, ale majú prednosť informácie na úrovni typu.

A samozrejme, ak sa chcete hlbšie zaoberať budovaním rozhrania REST API s jarou, vyskúšajte nový kurz REST with Spring.

4. RequestMapping S premennými cesty

Časti mapovacieho URI je možné viazať na premenné pomocou @PathVariable anotácia.

4.1. Slobodný @PathVariable

Jednoduchý príklad s premennou jednej cesty:

@RequestMapping (value = "/ ex / foos / {id}", method = GET) @ResponseBody public String getFoosBySimplePathWithPathVariable (@PathVariable ("id") long id) {return "Získajte konkrétne Foo s / ex / foos / { id} ", method = GET) @ResponseBody public String getFoosBySimplePathWithPathVariable (@PathVariable String id) {return" Získajte konkrétny Foo s premennou2-multiple-pathvariable ">4.2. Viacnásobné @PathVariable
Zložitejší URI bude možno potrebné namapovať na viac častí URI viac hodnôt:
@RequestMapping (value = "/ ex / foos / {fooid} / bar / {barid}", method = GET) @ResponseBody public String getFoosBySimplePathWithPathVariables (@PathVariable long fooid, @PathVariable long barid) {návrat "Získajte konkrétny pruh s z Foo with3-pathvariable-with-regex ">4.3. @PathVariable S Regexom
Regulárne výrazy je možné použiť aj pri mapovaní súboru @PathVariable.
Napríklad obmedzíme mapovanie tak, aby akceptovalo iba číselné hodnoty pre id:
@RequestMapping (value = "/ ex / bars / {numericId: [\ d] +}", method = GET) @ResponseBody public String getBarsBySimplePathWithPathVariable (@PathVariable long numericId) {return "Get a specific Bar withrequest-param">5. RequestMapping S parametrami požiadavky
@RequestMapping umožňuje jednoduché mapovanie parametrov URL s @RequestParam anotácia. 
Teraz mapujeme požiadavku na URI:
// localhost: 8080 / spring-rest / ex / bars? id = 100
@RequestMapping (value = "/ ex / bars", method = GET) @ResponseBody public String getBarBySimplePathWithRequestParam (@RequestParam ("id") long id) {return "Get a specific Bar with / ex / bars", params = "id ", method = GET) @ResponseBody public String getBarBySimplePathWithExplicitRequestParam (@RequestParam (" id ") long id) {return" Získajte konkrétny Bar s / ex / bars ", params = {" id "," second "}, method = ZÍSKAJTE @ResponseBody verejný reťazec getBarBySimplePathWithExplicitRequestParams (@RequestParam ("id") dlhé ID) {návrat "Úzke Získať konkrétny pruh s obalmi">6. RequestMapping Rohové puzdrá
6.1. @RequestMapping - Viaceré cesty mapované na rovnakú metódu radiča
Aj keď single @RequestMapping hodnota cesty sa zvyčajne používa pre metódu jedného radiča (iba dobrá prax, nie tvrdé a rýchle pravidlo), v niektorých prípadoch môže byť potrebné mapovanie viacerých požiadaviek na rovnakú metódu.
V tom prípade, the hodnotu atribút @RequestMapping akceptuje viacnásobné priradenia, nielen jediný:
@RequestMapping (value = {"/ ex / advanced / bars", "/ ex / advanced / foos"}, method = GET) @ResponseBody public String getFoosOrBarsByPath () {return "Advanced - Get some Foos or Bars"; }
Teraz obaja zvlnenie príkazy by mali naraziť na rovnakú metódu:
curl -i // localhost: 8080 / spring-rest / ex / advanced / foos curl -i // localhost: 8080 / spring-rest / ex / advanced / bary
6.2. @RequestMapping - Viaceré metódy vyžiadania HTTP na rovnakú metódu radiča
Na jednu metódu radiča možno namapovať viac požiadaviek pomocou rôznych slovies HTTP:
@RequestMapping (value = "/ ex / foos / multiple", method = {RequestMethod.PUT, RequestMethod.POST}) @ResponseBody public String putAndPostFoos () {return "Advanced - PUT a POST v rámci jednej metódy"; }
S zvlnenie, oba narazia na rovnakú metódu:
curl -i -X ​​POST // localhost: 8080 / spring-rest / ex / foos / multiple curl -i -X ​​PUT // localhost: 8080 / spring-rest / ex / foos / multiple
6.3. @RequestMapping - náhrada za všetky žiadosti
Implementácia jednoduchej zálohy pre všetky požiadavky pomocou konkrétnej metódy HTTP, napríklad pre GET:
@RequestMapping (value = "*", method = RequestMethod.GET) @ResponseBody public String getFallback () {return "Fallback for GET Requests"; }
alebo dokonca pre všetky žiadosti:
@RequestMapping (value = "*", method = {RequestMethod.GET, RequestMethod.POST ...}) @ResponseBody public String allFallback () {return "Fallback for All Requests"; }
6.4. Nejednoznačná chyba mapovania
Nejasná chyba mapovania nastane, keď Spring vyhodnotí dve alebo viac mapovaní požiadaviek, aby boli rovnaké pre rôzne metódy radiča. Mapovanie žiadosti je rovnaké, ak má rovnakú metódu HTTP, URL, parametre, hlavičky a typ média.
Toto je napríklad nejednoznačné mapovanie:
@GetMapping (value = "foos / duplicate") public String duplicate () {return "Duplicate"; } @GetMapping (value = "foos / duplicate") public String duplicateEx () {return "Duplicate"; }
Vyvolaná výnimka má zvyčajne chybové správy v týchto riadkoch:
Spôsobené: java.lang.IllegalStateException: nejednoznačné mapovanie. Metódu „fooMappingExamplesController“ nemožno namapovať na verejný java.lang.String org.baeldung.web.controller.FooMappingExamplesController.duplicateEx () na {[/ ex / foos / duplicate], methods = [GET]}: Existuje už fazula „fooMappingExamplesController“ zmapovaná metóda public java.lang.String org.baeldung.web.controller.FooMappingExamplesController.duplicate ().
Pozorné prečítanie chybovej správy poukazuje na skutočnosť, že Spring nedokáže metódu zmapovať org.baeldung.web.controller.FooMappingExamplesController.duplicateEx (), pretože má konfliktné mapovanie s už mapovaným org.baeldung.web.controller.FooMappingExamplesController.duplicate ().
Fragment kódu uvedený nižšie nebude mať za následok nejednoznačnú chybu mapovania, pretože obe metódy vracajú rôzne typy obsahu:
@GetMapping (value = "foos / duplicate", produce = MediaType.APPLICATION_XML_VALUE) public String duplicateXml () {return "Duplicate"; } @GetMapping (value = "foos / duplicate", produce = MediaType.APPLICATION_JSON_VALUE) public String duplicateJson () {return "{\" message \ ": \" Duplicate \ "}"; }
Táto diferenciácia umožňuje nášmu kontrolórovi vrátiť správne znázornenie údajov na základe Prijíma hlavička dodaná v žiadosti.
Ďalším spôsobom, ako to vyriešiť, je aktualizácia adresy URL priradenej ktorejkoľvek z dvoch použitých metód.
7. Nové skratky pre mapovanie požiadaviek
 Spring Framework 4.3 predstavil niekoľko nových anotácií mapovania HTTP, všetky založené na @RequestMapping : 
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
 Tieto nové anotácie môžu zlepšiť čitateľnosť a znížiť výrečnosť kódu. 
 Pozrime sa na tieto nové anotácie v akcii vytvorením rozhrania RESTful API, ktoré podporuje operácie CRUD: 
@GetMapping ("/ {id}") public ResponseEntity getBazz (@PathVariable String id) {return new ResponseEntity (new Bazz (id, "Bazz" + id), HttpStatus.OK); } @PostMapping public ResponseEntity newBazz (@RequestParam ("name") názov reťazca) {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); }
 Hlboký ponor do nich nájdete tu. 
8. Konfigurácia pružiny
Jarná konfigurácia MVC je dosť jednoduchá, ak uvážime, že naša FooController je definované v nasledujúcom balíku:
balíček org.baeldung.spring.web.controller; @Controller verejná trieda FooController {...}
Jednoducho potrebujeme a @ Konfigurácia triedy, aby ste povolili úplnú podporu MVC a nakonfigurovali skenovanie classpath pre radič:
@Configuration @EnableWebMvc @ComponentScan ({"org.baeldung.spring.web.controller"}) verejná trieda MvcConfig {//}
9. Záver
Tento článok sa zameral na @RequestMapping anotácia na jar, diskutujeme jednoduchý prípad použitia, mapovanie HTTP hlavičiek, väzobné časti URI s @PathVariablea práca s parametrami URI a @RequestParam anotácia.
Ak by ste sa chceli naučiť používať inú základnú anotáciu v jarnom MVC, môžete preskúmať @ModelAttribute anotácia tu.
Celý kód z článku je k dispozícii na GitHub.