Spring MVC mapping HTTP requests to Controller

The core of the request map: @RequestMapping annotation

@RequestMappingIt is the most core and general mapping annotation in Spring MVC. It can be used for class-level and method-level.

1. Class-level Mapping:

   • when@RequestMappingWhen applied to a class, it defines the base class URL path for the Controller to handle all requests.
   • This avoids adding duplicate same path prefix on each method.

2. Method-level Mapping:

   • when@RequestMappingWhen applied to a method, it specifies which (or which) URL path the method handles specifically.
   • This path is relative to the class level path (if it exists).

@RequestMapping’s main properties:

• valueorpath:

  • Specifies the mapped URL path. It can be an array of strings that represent mapping multiple paths to the same method.
  • Support Ant-style path modes (e.g.*, **, ?) and URI template variables (path variables, such as{userId}）。
  • valueandpathIt is a synonym and can be used interchangeably.

• method:

  • Specifies the HTTP request method (GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD, TRACE) processed by this method.
  • It can be oneRequestMethodAn array of enumerated values ​​indicates that multiple HTTP methods are processed.
  • If not specified, the default match will be matched.allHTTP method.

• params:

  • Map based on request parameters (Query Parameters or Form Data). The match will be successful only if the specified parameter is included (or does not contain, or has a specific value) in the request.
  • Expression syntax:
    • "myParam": ParametersmyParamMust exist.
    • "!myParam": ParametersmyParamIt must not exist.
    • "myParam=myValue": ParametersmyParamMust exist and the value ismyValue。
    • "myParam!=myValue": ParametersmyParamMust exist and the value is notmyValue。
    • Multiple conditions can be combined, such as{"myParam=val", "otherParam"}(AND relationship).

• headers:

  • Map according to request headers. The match will be successful only if the request contains (or does not contain, or has a specific value) the header specified.
  • Syntax andparamsSimilar, such as"Accept=application/json", "!User-Agent", "X-Custom-Header=value"。

• consumes:

  • Specify the request that this method can handleContent-Type(i.e. the data type sent by the client). Only when requestedContent-TypeThe mapping will be successful only when the header matches the specified value.
  • For example:consumes = "application/json"orconsumes = MediaType.APPLICATION_JSON_VALUE. Multiple options can be specified, such as{"application/json", "application/xml"}。

• produces:

  • Specify the response that this method can generateContent-Type(i.e. the data type returned by the server). Spring will requestAcceptHeader conducts content negotiation with this property (Content Negotiation) and select the most suitable oneHttpMessageConverterSerialize the return value.
  • For example:produces = "application/json"orproduces = MediaType.APPLICATION_JSON_VALUE. Multiple can be specified.

Example: Use @RequestMapping

import ;
import .*;
import ;

@Controller
@RequestMapping("/users") // Class-level mapping, all methods are in the /users pathpublic class UserController {

    // Map GET /users/{id}    @RequestMapping(value = "/{id}", method = , produces = MediaType.APPLICATION_JSON_VALUE)
    @ResponseBody // If you use @Controller, you need to add this to return the data    public User getUser(@PathVariable Long id) {
        // ... Get user logic ...        return new User(id, "Example User");
    }

    // Mapping POST /users    @RequestMapping(method = , consumes = MediaType.APPLICATION_JSON_VALUE)
    @ResponseBody
    public String createUser(@RequestBody User newUser) {
        // ... Create user logic ...        return "User created";
    }

    // Map GET /users?admin=true (requires admin parameter)    @RequestMapping(method = , params = "admin=true")
    @ResponseBody
    public String getAdminUsers() {
        // ... Get the administrator user list ...        return "List of Admin Users";
    }

    // Map GET /users (only accepts JSON requests)    @RequestMapping(method = , headers = "Accept=application/json")
    @ResponseBody
    public String getUsersAcceptingJson() {
        // ... Get the user list ...        return "List of Users (JSON requested)";
    }
}

@RequestMapping Variation (Shortcut Annotation)

To improve the readability and simplicity of your code, Spring provides shortcut annotations for specific HTTP methods. They are essentially@RequestMappingPresetmethodAliases for attributes.

• @GetMapping: Map HTTP GET requests. Equivalent to@RequestMapping(method = )。
• @PostMapping: Map HTTP POST requests. Equivalent to@RequestMapping(method = )。
• @PutMapping: Map HTTP PUT requests. Equivalent to@RequestMapping(method = )。
• @DeleteMapping: Map HTTP DELETE requests. Equivalent to@RequestMapping(method = )。
• @PatchMapping: Map HTTP PATCH requests. Equivalent to@RequestMapping(method = )。

These shortcut annotations are also supported@RequestMappingofvalue/path, params, headers, consumes, producesAttributes.

Advantages of using shortcut annotations:

• More concise: The code is shorter.
• More clear: You can see at a glance what kind of HTTP request the method is dealing with.

Example: Use shortcut annotation (@RestController simplified)

import .*;
import ;

@RestController // Using @RestController, no need to add @ResponseBody to each method@RequestMapping("/api/items") // Class level mappingpublic class ItemController {

    // Map GET /api/items/{itemId}    // producers can also write strings directly    @GetMapping(value = "/{itemId}", produces = MediaType.APPLICATION_JSON_VALUE)
    public Item getItem(@PathVariable String itemId) {
        // ... Get item logic ...        return new Item(itemId, "Sample Item");
    }

    // Mapping POST /api/items    // consumers can specify multiple    @PostMapping(consumes = {MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE})
    public String createItem(@RequestBody Item newItem) {
        // ... Create item logic ...        return "Item created: " + ();
    }

    // Mapping PUT /api/items/{itemId}    @PutMapping("/{itemId}")
    public Item updateItem(@PathVariable String itemId, @RequestBody Item updatedItem) {
        // ... Update item logic ...        (itemId); // Assume that the update is successful        return updatedItem;
    }

    // Mapping DELETE /api/items/{itemId}    @DeleteMapping("/{itemId}")
    public String deleteItem(@PathVariable String itemId) {
        // ... Delete item logic ...        return "Item deleted: " + itemId;
    }

    // Mapping GET /api/items?type=gadget    @GetMapping(params = "type=gadget")
    public String getGadgets() {
        return "List of Gadgets";
    }

    // Map GET /api/items (requires specific header)    @GetMapping(headers = "X-API-Version=2")
    public String getItemsV2() {
        return "List of Items (API V2)";
    }
}

// Example Pojoclass Item {
    private String id;
    private String name;
    // constructors, getters, setters...
    public Item(String id, String name) {  = id;  = name; }
    public String getId() { return id; }
    public void setId(String id) {  = id; }
    public String getName() { return name; }
    public void setName(String name) {  = name; }
}

class User {
    private Long id;
    private String username;
    // constructors, getters, setters...
    public User(Long id, String username) {  = id;  = username; }
    public Long getId() { return id; }
    public String getUsername() { return username; }
}

Summarize

• @RequestMappingis the basics, can map any HTTP method and provide the most comprehensive configuration options (path, method, params, headers, consumes, produces）。
• @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, @PatchMappingIt is a shortcut for specific HTTP methods, making the code more concise and clear. It is currently under Spring MVC/WebFlux development.recommendusage.
• Can beClass LevelandMethod LevelAt the same time, using mapping annotations, the basic path is defined at the class level and the relative path is defined at the method level.
• URL pathpassvalueorpathAttribute matching, support pattern and path variables ({var})。
• HTTP MethodspassmethodAttributes (in@RequestMapping) or select a specific shortcut annotation (such as@GetMapping) to match.
• Request parameterspassparamsMake attributes to match.
• Request headerpassheadersMake attributes to match.
• Request body type (Content-Type)passconsumesMake attributes to match.
• Acceptable response type (Accept)passproducesAttributes participate in content negotiation.

The above is the detailed content of the Spring MVC mapping HTTP request to Controller. For more information about Spring MVC mapping HTTP to Controller, please pay attention to my other related articles!

Latest Comments