@RequestMapping 源码学习

你的名字 2022-05-15 01:46 93阅读 0赞

**目录**

先看一下什么是@RequestMapping ?

它的底层源码

①、注解

②、源码

①、value

②、method 方法：

③、 params：

④、headers：

⑤、consumes：

⑥、produces:

--------------------

# 先看一下什么是@RequestMapping ? #

RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

# 它的底层源码 #

![70][]

这是它的路径。
    
    public @interface RequestMapping{}
    在idea 中可以双击shift 键，输入RequestMapping ，即可！

Note: This annotation can be used both at the class and
 * at the method level. In most cases, at the method level applications will
 * prefer to use one of the HTTP method specific variants
 * {@link GetMapping @GetMapping}, {@link PostMapping @PostMapping},
 * {@link PutMapping @PutMapping}, {@link DeleteMapping @DeleteMapping}, or
 * {@link PatchMapping @PatchMapping}.
 *
 * NOTE: When using controller interfaces (e.g. for AOP proxying),
 * make sure to consistently put all your mapping annotations - such as
 * {@code @RequestMapping} and {@code @SessionAttributes} - on
 * the controller interface rather than on the implementation class.
 *
 * @author Juergen Hoeller
 * @author Arjen Poutsma
 * @author Sam Brannen
 * @since 2.5
 * @see GetMapping
 * @see PostMapping
 * @see PutMapping
 * @see DeleteMapping
 * @see PatchMapping
 * @see org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter
 * @see org.springframework.web.reactive.result.method.annotation.RequestMappingHandlerAdapter

可以看出

@GetMapping
    @PostMapping
    @PutMapping
    @DeleteMapping
    @PatchMapping

为什么这个mapping可以代替@RequestMapping(value="",method = RequestMethod.POST)

## ①、注解 ##

@Target({ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Mapping
    public @interface RequestMapping {}

## ②、源码 ##

/**
 	 * Assign a name to this mapping.
 	 * Supported at the type level as well as at the method level!
 	 * When used on both levels, a combined name is derived by concatenation
 	 * with "#" as separator.
 	 * @see org.springframework.web.servlet.mvc.method.annotation.MvcUriComponentsBuilder
 	 * @see org.springframework.web.servlet.handler.HandlerMethodMappingNamingStrategy
 	 */
 	String name() default "";

为该映射分配名称，在类型级别和方法级别支持！当在两个级别上使用时，组合名称是通过“和”作为分隔符来导出的。

/**
 	 * The primary mapping expressed by this annotation.
 	 * This is an alias for {@link #path}. For example
 	 * {@code @RequestMapping("/foo")} is equivalent to
 	 * {@code @RequestMapping(path="/foo")}.
 	 * Supported at the type level as well as at the method level!
 	 * When used at the type level, all method-level mappings inherit
 	 * this primary mapping, narrowing it for a specific handler method.
 	 */
 	@AliasFor("path")
 	String[] value() default {};

通过这种注释表达的主要映射。在类型级别和方法级别支持，当在类型级别使用时，所有方法级别的映射都继承这个主映射，为特定的处理程序方法缩小其范围。

/**
 	 * The path mapping URIs (e.g. "/myPath.do").
 	 * Ant-style path patterns are also supported (e.g. "/myPath/*.do").
 	 * At the method level, relative paths (e.g. "edit.do") are supported
 	 * within the primary mapping expressed at the type level.
 	 * Path mapping URIs may contain placeholders (e.g. "/${connect}").
 	 * Supported at the type level as well as at the method level!
 	 * When used at the type level, all method-level mappings inherit
 	 * this primary mapping, narrowing it for a specific handler method.
 	 * @see org.springframework.web.bind.annotation.ValueConstants#DEFAULT_NONE
 	 * @since 4.2
 	 */
 	@AliasFor("value")
 	String[] path() default {};

### ①、value ###

这个是value  值，怎么去写地址 -- 指定请求的实际地址，指定的地址可以是URI Template 模式

/**
 	 * The HTTP request methods to map to, narrowing the primary mapping:
 	 * GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE.
 	 * Supported at the type level as well as at the method level!
 	 * When used at the type level, all method-level mappings inherit
 	 * this HTTP method restriction (i.e. the type-level restriction
 	 * gets checked before the handler method is even resolved).
 	 */
 	RequestMethod[] method() default {};

### ②、method 方法： ###

是指method请求类型 ，GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE  等

主要是在前后端分离的时候，采用restful API 接口。

1，GET ：安全、幂等；用于获取资源；
    2，HEAD：安全、幂等；与get方法类似，但不返回message body内容，仅仅是获得获取资源的部分信息（content-type、content-length）；restful框架中较少使用
    3，POST：非安全、非幂等；用于创建子资源
    4，PUT：非安全、幂等；用于创建、更新资源；
    5，DELETE：非安全、幂等；删除资源；
    6，OPTIONS：安全、幂等；用于url验证，验证接口服务是否正常；
    7，TEACE：安全、幂等；维基百科“回显服务器收到的请求，这样客户端可以看到（如果有）哪一些改变或者添加已经被中间服务器实现。”restful框架中较少使用
    8，PATCH：非安全、幂等；用于创建、更新资源，于PUT类似，区别在于PATCH代表部分更新；后来提出的接口方法，使用时可能去要验证客户端和服务端是否支持；

/**
 	 * The parameters of the mapped request, narrowing the primary mapping.
 	 * Same format for any environment: a sequence of "myParam=myValue" style
 	 * expressions, with a request only mapped if each such parameter is found
 	 * to have the given value. Expressions can be negated by using the "!=" operator,
 	 * as in "myParam!=myValue". "myParam" style expressions are also supported,
 	 * with such parameters having to be present in the request (allowed to have
 	 * any value). Finally, "!myParam" style expressions indicate that the
 	 * specified parameter is not supposed to be present in the request.
 	 * Supported at the type level as well as at the method level!
 	 * When used at the type level, all method-level mappings inherit
 	 * this parameter restriction (i.e. the type-level restriction
 	 * gets checked before the handler method is even resolved).
 	 * Parameter mappings are considered as restrictions that are enforced at
 	 * the type level. The primary path mapping (i.e. the specified URI value)
 	 * still has to uniquely identify the target handler, with parameter mappings
 	 * simply expressing preconditions for invoking the handler.
 	 */
 	String[] params() default {};

### ③、 params： ###

指定request中必须包含某些参数值是，才让该方法处理。  映射请求的参数，缩小主映射。

@RequestMapping(value = "/pets/{petId}", method = RequestMethod.GET, params="myParam=myValue")
    表示：仅处理请求中包含了名为“myParam”，值为“myValue”的请求；

/**
 	 * The headers of the mapped request, narrowing the primary mapping.
 	 * Same format for any environment: a sequence of "My-Header=myValue" style
 	 * expressions, with a request only mapped if each such header is found
 	 * to have the given value. Expressions can be negated by using the "!=" operator,
 	 * as in "My-Header!=myValue". "My-Header" style expressions are also supported,
 	 * with such headers having to be present in the request (allowed to have
 	 * any value). Finally, "!My-Header" style expressions indicate that the
 	 * specified header is not supposed to be present in the request.
 	 * Also supports media type wildcards (*), for headers such as Accept
 	 * and Content-Type. For instance,
 	 * <pre class="code">
 	 * @RequestMapping(value = "/something", headers = "content-type=text/*")
 	 * </pre>
 	 * will match requests with a Content-Type of "text/html", "text/plain", etc.
 	 * Supported at the type level as well as at the method level!
 	 * When used at the type level, all method-level mappings inherit
 	 * this header restriction (i.e. the type-level restriction
 	 * gets checked before the handler method is even resolved).
 	 * @see org.springframework.http.MediaType
 	 */
 	String[] headers() default {};

### ④、headers： ###

指定request中必须包含某些指定的header值，才能让该方法处理请求。 映射请求的标头，缩小主映射。

@RequestMapping(value = "/pets", method = RequestMethod.GET, headers="Referer=http://www.ifeng.com/")
    表示：仅处理request的header中包含了指定“Refer”请求头和对应值为“http://www.ifeng.com/”的请求；

/**
 	 * The consumable media types of the mapped request, narrowing the primary mapping.
 	 * The format is a single media type or a sequence of media types,
 	 * with a request only mapped if the {@code Content-Type} matches one of these media types.
 	 * Examples:
 	 * <pre class="code">
 	 * consumes = "text/plain"
 	 * consumes = {"text/plain", "application/*"}
 	 * </pre>
 	 * Expressions can be negated by using the "!" operator, as in "!text/plain", which matches
 	 * all requests with a {@code Content-Type} other than "text/plain".
 	 * Supported at the type level as well as at the method level!
 	 * When used at the type level, all method-level mappings override
 	 * this consumes restriction.
 	 * @see org.springframework.http.MediaType
 	 * @see javax.servlet.http.HttpServletRequest#getContentType()
 	 */
 	String[] consumes() default {};

### ⑤、consumes： ###

指定处理请求的提交内容类型（Content-Type），例如application/json, text/html;

在SpringBoot 这个框架中，它是默认使用 Jackson 作为 *Json*序列化工具。

@RequestMapping(value = "/acb", method = RequestMethod.POST, consumes="application/json")  
    表示：方法仅处理request Content-Type为“application/json”类型的请求。

/**
 	 * The producible media types of the mapped request, narrowing the primary mapping.
 	 * The format is a single media type or a sequence of media types,
 	 * with a request only mapped if the {@code Accept} matches one of these media types.
 	 * Examples:
 	 * <pre class="code">
 	 * produces = "text/plain"
 	 * produces = {"text/plain", "application/*"}
 	 * produces = MediaType.APPLICATION_JSON_UTF8_VALUE
 	 * </pre>
 	 * It affects the actual content type written, for example to produce a JSON response
 	 * with UTF-8 encoding, {@link org.springframework.http.MediaType#APPLICATION_JSON_UTF8_VALUE} should be used.
 	 * Expressions can be negated by using the "!" operator, as in "!text/plain", which matches
 	 * all requests with a {@code Accept} other than "text/plain".
 	 * Supported at the type level as well as at the method level!
 	 * When used at the type level, all method-level mappings override
 	 * this produces restriction.
 	 * @see org.springframework.http.MediaType
 	 */
 	String[] produces() default {};

### ⑥、produces:  ###

指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回；映射的请求的可生成媒体类型，缩小主映射。

@RequestMapping(value = "/abc/{abcId}", method = RequestMethod.GET, produces="application/json")
    表示:方法仅处理request请求中Accept头中包含了"application/json"的请求，同时暗示了返回的内容类型为application/json;

参考：[@RequestMapping 用法详解之地址映射(转)][RequestMapping]

[70]: /images/20220515/ba7049fd173f4a409a71821f35be1a52.png
[RequestMapping]: https://www.cnblogs.com/qq78292959/p/3760560.html