Пролетно запитване на карти

1. Общ преглед

В този урок ще се съсредоточим върху една от основните анотации в Spring MVC: @RequestMapping.

Най-просто казано, анотацията се използва за картографиране на уеб заявки към методите Spring Controller.

**2. @ RequestMapping Basics**

Нека започнем с прост пример: съпоставяне на HTTP заявка с метод, използвайки някои основни критерии.

**2.1. @RequestMapping - по Path**

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

За да изпробвате това картографиране с проста команда curl , изпълнете:

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

**2.2. @RequestMapping - HTTP метод**

В HTTP метод параметър има не по подразбиране. Така че, ако не посочим стойност, тя ще се свърже с всяка HTTP заявка.

Ето един прост пример, подобен на предишния, но този път съпоставен с HTTP POST заявка:

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

За да тествате POST чрез команда curl :

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

**3. RequestMapping и HTTP заглавки**

**3.1. @RequestMapping С заглавията атрибут**

Съпоставянето може да се стесни още повече, като се посочи заглавка за заявката:

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

За да тестваме операцията, ще използваме поддръжката на заглавката на curl :

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

и дори множество заглавки чрез атрибута заглавки на @RequestMapping :

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

Можем да тестваме това с командата:

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

Имайте предвид, че за синтаксиса на curl двоеточие разделя ключа на заглавката и стойността на заглавката, същото като в спецификацията на HTTP, докато през Spring се използва знакът за равенство.

**3.2. @RequestMapping консумира и произвежда**

Картографирането на типовете носители, произведени чрез метод на контролер , заслужава специално внимание.

Можем да картографираме заявка въз основа на нейния заглавка Accept чрез въведения по-горе атрибут @RequestMapping headers :

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

Съвпадението за този начин на дефиниране на заглавката Accept е гъвкаво - използва съдържа вместо равно, така че заявка като следната ще продължи да се прави правилно:

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

Започвайки с Spring 3.1, анотацията @RequestMapping вече има атрибути за производство и консумация , специално за тази цел:

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

Също така старият тип картографиране с атрибута headers автоматично ще бъде преобразуван в новия механизъм за производство , започвайки с Spring 3.1, така че резултатите ще бъдат идентични.

Това се консумира чрез curl по същия начин:

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

Освен това произвежда поддържа и множество стойности:

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

Имайте предвид, че тези - старите и новите начини за определяне на заглавката Accept - са основно едно и също картографиране, така че Spring няма да ги позволи заедно.

Активността на двата метода би довела до:

Caused by: java.lang.IllegalStateException: Ambiguous mapping found. Cannot map 'fooController' bean method java.lang.String org.baeldung.spring.web.controller .FooController.getFoosAsJsonFromREST() to { [/ex/foos], methods=[GET],params=[],headers=[], consumes=[],produces=[application/json],custom=[] }: There is already 'fooController' bean method java.lang.String org.baeldung.spring.web.controller .FooController.getFoosAsJsonFromBrowser() mapped.

Последна бележка за новите механизми за производство и консумация , които се държат по различен начин от повечето други анотации: Когато са посочени на ниво тип, анотациите на ниво метод не допълват, а заместват информацията на ниво тип.

И разбира се, ако искате да се задълбочите в изграждането на REST API с Spring, разгледайте новия курс REST с Spring .

**4. RequestMapping с променливи на пътя**

Части от картографиращия URI могат да бъдат обвързани с променливи чрез анотацията @PathVariable .

4.1. Единичен @PathVariable

Прост пример с променлива с един път:

@RequestMapping(value = "/ex/foos/{id}", method = GET) @ResponseBody public String getFoosBySimplePathWithPathVariable( @PathVariable("id") long id) { return "Get a specific Foo with/ex/foos/{id}", method = GET) @ResponseBody public String getFoosBySimplePathWithPathVariable( @PathVariable String id) { return "Get a specific Foo with2-multiple-pathvariable">4.2. Multiple @PathVariableA more complex URI may need to map multiple parts of the URI to multiple values:
@RequestMapping(value = "/ex/foos/{fooid}/bar/{barid}", method = GET) @ResponseBody public String getFoosBySimplePathWithPathVariables (@PathVariable long fooid, @PathVariable long barid) { return "Get a specific Bar with from a Foo with3-pathvariable-with-regex">4.3. @PathVariable With RegexRegular expressions can also be used when mapping the @PathVariable.
For example, we will restrict the mapping to only accept numerical values for the 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 With Request Parameters@RequestMapping allows easy mapping of URL parameters with the @RequestParam annotation. 
We are now mapping a request to a 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 "Get a specific Bar with/ex/bars", params = { "id", "second" }, method = GET) @ResponseBody public String getBarBySimplePathWithExplicitRequestParams( @RequestParam("id") long id) { return "Narrow Get a specific Bar withcorner-cases">6. RequestMapping Corner Cases6.1. @RequestMapping — Multiple Paths Mapped to the Same Controller Method
Although a single @RequestMapping path value is usually used for a single controller method (just good practice, not a hard and fast rule), there are some cases where mapping multiple requests to the same method may be necessary.
In that case, the value attribute of @RequestMapping does accept multiple mappings, not just a single one:
@RequestMapping( value = { "/ex/advanced/bars", "/ex/advanced/foos" }, method = GET) @ResponseBody public String getFoosOrBarsByPath() { return "Advanced - Get some Foos or Bars"; }
Now both of these curl commands should hit the same method:
curl -i //localhost:8080/spring-rest/ex/advanced/foos curl -i //localhost:8080/spring-rest/ex/advanced/bars
6.2. @RequestMapping — Multiple HTTP Request Methods to the Same Controller Method
Multiple requests using different HTTP verbs can be mapped to the same controller method:
@RequestMapping( value = "/ex/foos/multiple", method = { RequestMethod.PUT, RequestMethod.POST } ) @ResponseBody public String putAndPostFoos() { return "Advanced - PUT and POST within single method"; }
With curl, both of these will now hit the same method:
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 — a Fallback for All Requests
To implement a simple fallback for all requests using a particular HTTP method, for example, for a GET:
@RequestMapping(value = "*", method = RequestMethod.GET) @ResponseBody public String getFallback() { return "Fallback for GET Requests"; }
or even for all requests:
@RequestMapping( value = "*", method = { RequestMethod.GET, RequestMethod.POST ... }) @ResponseBody public String allFallback() { return "Fallback for All Requests"; }
6.4. Ambiguous Mapping Error
The ambiguous mapping error occurs when Spring evaluates two or more request mappings to be the same for different controller methods. A request mapping is the same when it has the same HTTP method, URL, parameters, headers, and media type.
For example, this is an ambiguous mapping:
@GetMapping(value = "foos/duplicate" ) public String duplicate() { return "Duplicate"; } @GetMapping(value = "foos/duplicate" ) public String duplicateEx() { return "Duplicate"; }
The exception thrown usually does have error messages along these lines:
Caused by: java.lang.IllegalStateException: Ambiguous mapping. Cannot map 'fooMappingExamplesController' method public java.lang.String org.baeldung.web.controller.FooMappingExamplesController.duplicateEx() to {[/ex/foos/duplicate],methods=[GET]}: There is already 'fooMappingExamplesController' bean method public java.lang.String org.baeldung.web.controller.FooMappingExamplesController.duplicate() mapped.
A careful reading of the error message points to the fact that Spring is unable to map the method org.baeldung.web.controller.FooMappingExamplesController.duplicateEx(), as it has a conflicting mapping with an already mapped org.baeldung.web.controller.FooMappingExamplesController.duplicate().
The code snippet below will not result in ambiguous mapping error because both methods return different content types:
@GetMapping(value = "foos/duplicate", produces = MediaType.APPLICATION_XML_VALUE) public String duplicateXml() { return "Duplicate"; } @GetMapping(value = "foos/duplicate", produces = MediaType.APPLICATION_JSON_VALUE) public String duplicateJson() { return "{\"message\":\"Duplicate\"}"; }
This differentiation allows our controller to return the correct data representation based on the Accepts header supplied in the request.
Another way to resolve this is to update the URL assigned to either of the two methods involved.
7. New Request Mapping Shortcuts
 Spring Framework 4.3 introduced a few new HTTP mapping annotations, all based on @RequestMapping : 
            
             @GetMapping
             @PostMapping
             @PutMapping
             @DeleteMapping
             @PatchMapping
            
 These new annotations can improve the readability and reduce the verbosity of the code. 
 Let's look at these new annotations in action by creating a RESTful API that supports CRUD operations: 
@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); }
 A deep dive into these can be found here. 
8. Spring Configuration
The Spring MVC Configuration is simple enough, considering that our FooController is defined in the following package:
package org.baeldung.spring.web.controller; @Controller public class FooController { ... }
We simply need a @Configuration class to enable the full MVC support and configure classpath scanning for the controller:
@Configuration @EnableWebMvc @ComponentScan({ "org.baeldung.spring.web.controller" }) public class MvcConfig { // }
9. Conclusion
This article focused on the @RequestMapping annotation in Spring, discussing a simple use case, the mapping of HTTP headers, binding parts of the URI with @PathVariable, and working with URI parameters and the @RequestParam annotation.
If you'd like to learn how to use another core annotation in Spring MVC, you can explore the @ModelAttribute annotation here.
The full code from the article is available over on GitHub.

Пролетно запитване на карти

1. Общ преглед

**2. @ RequestMapping Basics**

**2.1. @RequestMapping - по Path**

**2.2. @RequestMapping - HTTP метод**

**3. RequestMapping и HTTP заглавки**

**3.1. @RequestMapping С заглавията атрибут**

**3.2. @RequestMapping консумира и произвежда**

**4. RequestMapping с променливи на пътя**

4.1. Единичен @PathVariable

**6.1. @RequestMapping — Multiple Paths Mapped to the Same Controller Method**

**6.2. @RequestMapping — Multiple HTTP Request Methods to the Same Controller Method**

**6.3. @RequestMapping — a Fallback for All Requests**

6.4. Ambiguous Mapping Error

7. New Request Mapping Shortcuts

8. Spring Configuration

9. Conclusion