知識庫 / Spring / Spring MVC RSS 訂閱

1. 概述

在本教程中，我們將重點介紹 Spring MVC 中一個主要註解：@RequestMapping。

簡單來説，該註解用於將 Web 請求映射到 Spring Controller 方法。

2. <em/>RequestMapping 基礎

我們從一個簡單的例子開始：使用基本條件將 HTTP 請求映射到方法。 假設 Spring 默認在根上下文路徑 (“/”) 上提供內容。 本文中的所有 CURL 請求都依賴於默認的根上下文路徑。

2.1. RequestMapping — 按路徑定義

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

要測試此映射，可以使用簡單的 curl 命令：

curl -i http://localhost:8080/ex/foos

2.2. @RequestMapping — HTTP 方法

HTTP 方法 參數沒有默認值。因此，如果我們不指定值，它將映射到任何 HTTP 請求。

以下是一個簡單的例子，類似於之前的例子，但這次映射到 HTTP POST 請求：

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

要通過 curl 命令測試 POST 請求：

curl -i -X POST http://localhost:8080/ex/foos

3. RequestMapping 和 HTTP Headers

This section explains how Spring MVC uses HTTP headers to determine how to handle requests. HTTP headers are key to routing requests to the correct controller method.

Here's a breakdown of important headers:

• Content-Type: This header specifies the media type of the request body. Common values include application/json, application/xml, and text/plain.
• Accept: This header indicates the types of content the client is willing to accept in the response.
• Cookie: Used to store session information and other client-side data.
• Authorization: Used to authenticate the client.

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" http://localhost:8080/ex/foos

並且可以通過 headers 屬性使用多個標題，應用於 @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" http://localhost:8080/ex/foos

請注意，對於 curl 語法，冒號用於分隔 header 鍵和 header 值，與 HTTP 規範相同，而 Spring 中則使用等號。

3.2. <em @RequestMapping</em> 的 Consumes 和 Produces

對控制器方法產生的 媒體類型 進行映射值得特別關注。

可以通過上述引入的 <em @RequestMapping</em> 的 headers 屬性，根據請求的 Accept 頭部來映射請求。

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

這種定義 Accept 頭的做法，匹配方式具有靈活性——它使用 contains 代替 equals，因此像下面這樣的請求仍然會正確映射：

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

從 Spring 3.1 開始，<strong ><em >@RequestMapping</em> <em ></strong> 註解現在具有 <em >produces</em> 和 <em >consumes</em> 屬性，專門用於此目的：

@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 版本及更高版本中自動轉換為新的 produces 機制，因此結果將完全相同。

同樣，通過 curl 消耗的方式也相同：

curl -H "Accept:application/json" 
  http://localhost:8080/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.

最後，關於新的 產生 和 消耗 機制，需要特別説明，它們的行為與大多數其他註解不同：當以類型級別指定時，方法級別的註解不會補充，而是會覆蓋 類型級別的信息。

當然，如果您想深入瞭解如何使用 Spring 構建 REST API，請查看 新的 Spring REST 課程。

4. 使用 Path 變量的 RequestMapping</em/>

@RequestMapping(value = "/ex/foos/{id}", method = GET)
@ResponseBody
public String getFoosBySimplePathWithPathVariable(
  @PathVariable("id") long id) {
    return "Get a specific Foo with id=" + id;
}

curl http://localhost:8080/ex/foos/1

@RequestMapping(value = "/ex/foos/{id}", method = GET)
@ResponseBody
public String getFoosBySimplePathWithPathVariable(
  @PathVariable String id) {
    return "Get a specific Foo with id=" + id;
}

@PathVariable long id

@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 id=" + barid + 
      " from a Foo with id=" + fooid;
}

curl http://localhost:8080/ex/foos/1/bar/2

@RequestMapping(value = "/ex/bars/{numericId:[\\d]+}", method = GET)
@ResponseBody
public String getBarsBySimplePathWithPathVariable(
  @PathVariable long numericId) {
    return "Get a specific Bar with id=" + numericId;
}

http://localhost:8080/ex/bars/1

http://localhost:8080/ex/bars/abc

http://localhost:8080/ex/bars?id=100

@RequestMapping(value = "/ex/bars", method = GET)
@ResponseBody
public String getBarBySimplePathWithRequestParam(
  @RequestParam("id") long id) {
    return "Get a specific Bar with id=" + id;
}

curl -i http://localhost:8080/ex/bars --get -d id=100

@RequestMapping(value = "/ex/bars", params = "id", method = GET)
@ResponseBody
public String getBarBySimplePathWithExplicitRequestParam(
  @RequestParam("id") long id) {
    return "Get a specific Bar with id=" + id;
}

@RequestMapping(
  value = "/ex/bars", 
  params = { "id", "second" }, 
  method = GET)
@ResponseBody
public String getBarBySimplePathWithExplicitRequestParams(
  @RequestParam("id") long id) {
    return "Narrow Get a specific Bar with id=" + id;
}

http://localhost:8080/ex/bars?id=100&second=something

@RequestMapping(
  value = { "/ex/advanced/bars", "/ex/advanced/foos" }, 
  method = GET)
@ResponseBody
public String getFoosOrBarsByPath() {
    return "Advanced - Get some Foos or Bars";
}

curl -i http://localhost:8080/ex/advanced/foos
curl -i http://localhost:8080/ex/advanced/bars

@RequestMapping(
  value = "/ex/foos/multiple", 
  method = { RequestMethod.PUT, RequestMethod.POST }
)
@ResponseBody
public String putAndPostFoos() {
    return "Advanced - PUT and POST within single method";
}

curl -i -X POST http://localhost:8080/ex/foos/multiple
curl -i -X PUT http://localhost:8080/ex/foos/multiple

@RequestMapping(value = "*", method = RequestMethod.GET)
@ResponseBody
public String getFallback() {
    return "Fallback for GET Requests";
}

@RequestMapping(
  value = "*", 
  method = { RequestMethod.GET, RequestMethod.POST ... })
@ResponseBody
public String allFallback() {
    return "Fallback for All Requests";
}

@GetMapping(value = "foos/duplicate" )
public String duplicate() {
    return "Duplicate";
}

@GetMapping(value = "foos/duplicate" )
public String duplicateEx() {
    return "Duplicate";
}

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.

@GetMapping(value = "foos/duplicate", produces = MediaType.APPLICATION_XML_VALUE)
public String duplicateXml() {
    return "<message>Duplicate</message>";
}
    
@GetMapping(value = "foos/duplicate", produces = MediaType.APPLICATION_JSON_VALUE)
public String duplicateJson() {
    return "{\"message\":\"Duplicate\"}";
}

@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);
}

package org.baeldung.spring.web.controller;

@Controller
public class FooController { ... }

@Configuration
@EnableWebMvc
@ComponentScan({ "org.baeldung.spring.web.controller" })
public class MvcConfig {
    //
}