streamalism.org

1. Oversikt

I denne opplæringen vil vi fokusere på en av hovedkommentarene i Vår MVC: @RequestMapping.

Enkelt sagt, kommentaren brukes til å tilordne nettforespørsler til Spring Controller-metoder.

2. @RequestMapping Grunnleggende

La oss starte med et enkelt eksempel: kartlegge en HTTP-forespørsel til en metode ved hjelp av noen grunnleggende kriterier.

2.1. @RequestMapping - ved sti

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

Å teste ut denne kartleggingen med en enkel krølle kommando, kjør:

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

2.2. @RequestMapping - HTTP-metoden

HTTP metode parameter har ingen standard. Så hvis vi ikke spesifiserer en verdi, vil den tilordnes til en hvilken som helst HTTP-forespørsel.

Her er et enkelt eksempel, som det forrige, men denne gangen tilordnet en HTTP POST-forespørsel:

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

Å teste POST via a krølle kommando:

krøll -i -X ​​POST // localhost: 8080 / spring-rest / ex / foos

3. RequestMapping og HTTP-overskrifter

3.1. @RequestMapping Med topptekster Egenskap

Kartleggingen kan begrenses ytterligere ved å angi en overskrift for forespørselen:

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

For å teste operasjonen, skal vi bruke krølle topptekststøtte:

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

og til og med flere overskrifter via topptekster attributt av @RequestMapping:

@RequestMapping (value = "/ ex / foos", headers = {"key1 = val1", "key2 = val2"}, method = GET) @ResponseBody public String getFoosWithHeaders () {return "Få noen foos med header"; }

Vi kan teste dette med kommandoen:

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

Merk at for krølle syntaks, skiller et kolon topptekst og topptekstverdi, den samme som i HTTP-spesifikasjonen, mens det på våren brukes likhetstegnet.

3.2. @RequestMapping Forbruker og produserer

Kartlegging medietyper produsert av en kontroller metoden er verdt spesiell oppmerksomhet.

Vi kan kartlegge en forespørsel basert på dens Aksepterer topptekst via @RequestMappingtopptekster attributt introdusert ovenfor:

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

Matchingen for denne måten å definere Aksepterer header er fleksibel - den bruker inneholder i stedet for lik, så en forespørsel som følgende vil fremdeles kartlegges riktig:

krøll -H "Godta: applikasjon / json, tekst / html" // localhost: 8080 / spring-rest / ex / foos

Fra og med våren 3.1, den @RequestMapping kommentar har nå produserer og forbruker attributter, spesielt for dette formålet:

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

Også den gamle typen kartlegging med topptekster attributt blir automatisk konvertert til det nye produserer mekanisme som starter med våren 3.1, så resultatene blir identiske.

Dette forbrukes via krølle på samme måten:

krølle -H "Godta: applikasjon / json" // localhost: 8080 / vårhvile / ex / foos

I tillegg produserer støtter også flere verdier:

@RequestMapping (verdi = "/ ex / foos", metode = GET, produserer = {"applikasjon / json", "applikasjon / xml"})

Husk at disse - de gamle og nye måtene å spesifisere Aksepterer header - er i utgangspunktet den samme kartleggingen, så Spring tillater dem ikke sammen.

Å ha begge disse metodene aktive vil resultere i:

Forårsaket av: java.lang.IllegalStateException: Tvetydig kartlegging funnet. Kan ikke kartlegge 'fooController' bønnemetoden java.lang.String org.baeldung.spring.web.controller .FooController.getFoosAsJsonFromREST () til {[/ ex / foos], methods = [GET], params = [], headers = [ ], forbruker = [], produserer = [applikasjon / json], tilpasset = []}: Det er allerede 'fooController' bønnemetode java.lang.String org.baeldung.spring.web.controller .FooController.getFoosAsJsonFromBrowser () kartlagt .

En siste merknad om det nye produserer og forbruker mekanismer, som oppfører seg annerledes enn de fleste andre merknader: Når spesifisert på typenivå, merknadene på metodenivå kompletterer ikke, men overstyrer informasjon om typenivå.

Og selvfølgelig, hvis du vil grave dypere i å bygge en REST API med Spring, sjekk ut den nye REST med vårkurs.

4. RequestMapping Med banevariabler

Deler av kartleggings-URI kan bindes til variabler via @PathVariable kommentar.

4.1. Enkelt @PathVariable

Et enkelt eksempel med en enkelt sti-variabel:

@RequestMapping (value = "/ ex / foos / {id}", method = GET) @ResponseBody public String getFoosBySimplePathWithPathVariable (@PathVariable ("id") long id) {return "Få en spesifikk Foo med / ex / foos / { id} ", method = GET) @ResponseBody public String getFoosBySimplePathWithPathVariable (@PathVariable String id) {return" Få en spesifikk Foo med2-multiple-pathvariable ">4.2. Flere @PathVariable
En mer kompleks URI må kanskje kartlegge flere deler av URI til flere verdier:
@RequestMapping (value = "/ ex / foos / {fooid} / bar / {barid}", method = GET) @ResponseBody public String getFoosBySimplePathWithPathVariables (@PathVariable long fooid, @PathVariable long barid) {return "Få en spesifikk Bar med fra en Foo med3-pathvariable-with-regex ">4.3. @PathVariable Med Regex
Regulære uttrykk kan også brukes ved kartlegging av @PathVariable.
For eksempel vil vi begrense kartleggingen til å bare akseptere numeriske verdier for id:
@RequestMapping (value = "/ ex / bars / {numericId: [\ d] +}", method = GET) @ResponseBody public String getBarsBySimplePathWithPathVariable (@PathVariable long numericId) {return "Få en spesifikk Bar med forespørsel-param">5. RequestMapping Med forespørselsparametere
@RequestMapping gjør det enkelt kartlegging av URL-parametere med @RequestParam kommentar. 
Vi kartlegger nå en forespørsel til en URI:
// localhost: 8080 / spring-rest / ex / bars? id = 100
@RequestMapping (value = "/ ex / bars", method = GET) @ResponseBody public String getBarBySimplePathWithRequestParam (@RequestParam ("id") long id) {return "Få en spesifikk Bar med / ex / bars", params = "id ", method = GET) @ResponseBody public String getBarBySimplePathWithExplicitRequestParam (@RequestParam (" id ") long id) {return" Få en spesifikk Bar med / ex / bars ", params = {" id "," second "}, method = GET) @ResponseBody public String getBarBySimplePathWithExplicitRequestParams (@RequestParam ("id") long id) {return "Narrow Få en spesifikk Bar withcorner-cases">6. RequestMapping Hjørnesaker
6.1. @RequestMapping - Flere baner kartlagt til samme kontrollermetode
Selv om en singel @RequestMapping baneverdi brukes vanligvis for en enkelt kontrollermetode (bare god praksis, ikke en hard og rask regel), det er noen tilfeller der det kan være nødvendig å kartlegge flere forespørsler til samme metode.
I så fall, de verdi attributt av @RequestMapping godtar flere kartlegginger, ikke bare en eneste:
@RequestMapping (value = {"/ ex / advanced / bars", "/ ex / advanced / foos"}, method = GET) @ResponseBody public String getFoosOrBarsByPath () {return "Advanced - Get some Foos or Bars"; }
Nå begge disse krølle kommandoer skal treffe samme metode:
curl -i // localhost: 8080 / spring-rest / ex / advanced / foos curl -i // localhost: 8080 / spring-rest / ex / advanced / bar
6.2. @RequestMapping - Flere HTTP-forespørselsmetoder til samme kontrollermetode
Flere forespørsler ved bruk av forskjellige HTTP-verb kan tilordnes til samme kontrollermetode:
@RequestMapping (value = "/ ex / foos / multiple", method = {RequestMethod.PUT, RequestMethod.POST}) @ResponseBody public String putAndPostFoos () {return "Advanced - PUT and POST within single method"; }
Med krølle, begge disse vil nå treffe den samme metoden:
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 - en tilbakefall for alle forespørsler
Slik implementerer du en enkel reserve for alle forespørsler ved hjelp av en bestemt HTTP-metode, for eksempel for en GET:
@RequestMapping (value = "*", method = RequestMethod.GET) @ResponseBody public String getFallback () {return "Fallback for GET Requests"; }
eller til og med for alle forespørsler:
@RequestMapping (value = "*", method = {RequestMethod.GET, RequestMethod.POST ...}) @ResponseBody public String allFallback () {return "Fallback for All Requests"; }
6.4. Tvetydig kartleggingsfeil
Den tvetydige kartleggingsfeilen oppstår når Spring vurderer to eller flere forespørselstilordninger for å være de samme for forskjellige kontrollermetoder. En forespørselskartlegging er den samme når den har samme HTTP-metode, URL, parametere, overskrifter og medietype.
For eksempel er dette en tvetydig kartlegging:
@GetMapping (value = "foos / duplicate") public Streng duplicate () {return "Duplicate"; } @GetMapping (value = "foos / duplicate") public String duplicateEx () {return "Duplicate"; }
Unntaket som kastes har vanligvis feilmeldinger i denne retning:
Forårsaket av: java.lang.IllegalStateException: Tvetydig kartlegging. Kan ikke kartlegge 'fooMappingExamplesController' -metoden offentlig java.lang.String org.baeldung.web.controller.FooMappingExamplesController.duplicateEx () til {[/ ex / foos / duplicate], methods = [GET]}: Det er allerede 'fooMappingExamplesController' bønne metoden offentlig java.lang.String org.baeldung.web.controller.FooMappingExamplesController.duplicate () kartlagt.
En nøye lesing av feilmeldingen peker på det faktum at Spring ikke klarer å kartlegge metoden org.baeldung.web.controller.FooMappingExamplesController.duplicateEx (), siden den har en motstridende kartlegging med en allerede kartlagt org.baeldung.web.controller.FooMappingExamplesController.duplicate ().
Kodebiten nedenfor vil ikke føre til tvetydig kartleggingsfeil fordi begge metodene returnerer forskjellige innholdstyper:
@GetMapping (verdi = "foos / duplicate", produserer = MediaType.APPLICATION_XML_VALUE) offentlig String duplicateXml () {return "Duplicate"; } @GetMapping (verdi = "foos / duplicate", produserer = MediaType.APPLICATION_JSON_VALUE) offentlig String duplicateJson () {return "{\" message \ ": \" Duplicate \ "}"; }
Denne differensieringen gjør at vår kontroller kan returnere riktig datarepresentasjon basert på Godtar topptekst levert i forespørselen.
En annen måte å løse dette på er å oppdatere URL-en som er tildelt en av de to involverte metodene.
7. Nye snarveier for kartforespørsel
 Spring Framework 4.3 introduserte noen få nye HTTP-kartleggingsanmerkninger, alt basert på @RequestMapping : 
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
 Disse nye merknadene kan forbedre lesbarheten og redusere koden. 
 La oss se på disse nye kommentarene i aksjon ved å lage en RESTful API som støtter CRUD-operasjoner: 
@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}") offentlig ResponseEntity updateBazz (@PathVariable String id, @RequestParam ("name") String name) {return new ResponseEntity (new Bazz (id, name), HttpStatus.OK); } @DeleteMapping ("/ {id}") offentlig ResponseEntity deleteBazz (@PathVariable String id) {return new ResponseEntity (new Bazz (id), HttpStatus.OK); }
 Et dypdykk i disse finner du her. 
8. Vårkonfigurasjon
Våren MVC-konfigurasjon er enkel nok, med tanke på at vår FooController er definert i følgende pakke:
pakke org.baeldung.spring.web.controller; @Controller offentlig klasse FooController {...}
Vi trenger bare en @Konfigurasjon klasse for å aktivere full MVC-støtte og konfigurere classpath-skanning for kontrolleren:
@Configuration @EnableWebMvc @ComponentScan ({"org.baeldung.spring.web.controller"}) offentlig klasse MvcConfig {//}
9. Konklusjon
Denne artikkelen fokuserte på @RequestMapping kommentar om våren, diskutere en enkel brukssak, kartlegging av HTTP-overskrifter, bindende deler av URI med @PathVariable, og arbeide med URI-parametere og @RequestParam kommentar.
Hvis du vil lære hvordan du bruker en annen kjerneannotasjon i Spring MVC, kan du utforske @ModelAttribute kommentar her.
Den fulle koden fra artikkelen er tilgjengelig på GitHub.