1、请求映射路径的配置

配置映射路径，映射器处理器才能找到Controller的方法资源，目前主流映射路径配置方式就是@RequestMapping

相关注解	作用	使用位置
@RequestMapping	设置控制器方法的访问资源路径，可以接收任何请求	方法和类上
@GetMapping	设置控制器方法的访问资源路径，可以接收 GET 请求	方法和类上
@PostMapping	设置控制器方法的访问资源路径，可以接收 POST 请求	方法和类上

@RequestMapping注解，主要使用在控制器的方法上，用于标识客户端访问资源路径，常用的属性有value、path、method、headers、params等。当@RequestMapping只有一个访问路径需要指定时，使用value属性、path属性或省略value和path，当有多个属性时，value和path不能省略

@RequestMapping(value = "/show")//使用value属性指定一个访问路径
public String show(){}

@RequestMapping(value = {"/show","/haohao","/abc"})//使用value属性指定多个访问路径
public String show(){}

@RequestMapping(path = "/show")//使用path属性指定一个访问路径
public String show(){}

@RequestMapping(path = {"/show","/haohao","/abc"})//使用path属性指定多个访问路径
public String show(){}

@RequestMapping("/show")//如果只设置访问路径时，value和path可以省略
public String show(){}

@RequestMapping({"/show","/haohao","/abc"})
public String show(){}

当@RequestMapping 需要限定访问方式时，可以通过method属性设置

//请求地址是/show,且请求方式必须是POST才能匹配成功
@RequestMapping(value = "/show",method = RequestMethod.POST)
public String show(){}

method的属性值是一个枚举类型，源码如下：

public enum RequestMethod {
    GET,
    HEAD,
    POST,
    PUT,
    PATCH,
    DELETE,
    OPTIONS,
    TRACE;

    private RequestMethod() {
    }
}

@GetMapping，当请求方式是GET时，我们可以使用@GetMapping替代@RequestMapping

@GetMapping("/show")
public String show(){}

@PostMapping，当请求方式是POST时，我们可以使用@PostMapping替代@RequestMapping

@PostMapping("/show")
public String show(){}

@RequestMapping 在类上使用，@RequestMapping 、@GetMapping、@PostMapping还可以使用在Controller类上，使用在类上后，该类所有方法都公用该@RequestMapping设置的属性，访问路径则为类上的映射地址+方法上的映射地址，例如：

@Controller
@RequestMapping("/xxx")
public class UserController implements ApplicationContextAware, ServletContextAware {

    @GetMapping("/aaa")
    public ModelAndView aaa(HttpServletResponse response) 
            throws IOException, ModelAndViewDefiningException {
        return null;
    }

    // 你可能还需要重写 ApplicationContextAware 和 ServletContextAware 的方法
}

此时的访问路径为：/xxx/aaa

2、请求数据的接收

2.1、接收普通请求数据

当客户端提交的数据是普通键值对形式时，直接使用同名形参接收即可username=haohao&age=35

@GetMapping("/show")
public String show(String username, int age){
	System.out.println(username+"=="+age);
	return "/index.jsp";
}

当请求参数有特殊格式数据，如日期时username=haohao&age=35&birthday=1986/01/01

@GetMapping("/show")
public String show(String username,int age,Date birthday){
   System.out.println(username+"=="+age+"=="+birthday);
   return "/index.jsp";
}

Date可以正常接收，因为Spring内置的类型解析器，可以识别的日期格式是 yyyy/MM/dd，但是如果我们提交其他格式，例如：yyyy-MM-dd 时，类型转换会报错，如下：username=haohao&age=35&birthday=1986-01-01

解决方案，使用@DateTimeFormat 指定日期格式，修改UserController如下：

@GetMapping("/show")
public String show(String username,int age,@DateTimeFormat(pattern = "yyyy-MM-dd") Date 
birthday){
   System.out.println(username+"=="+age+"=="+birthday);
   return "/index.jsp";
}

当请求参数的名称与方法参数名不一致时，可以使用@RequestParam注解进行标注username=haohao&age=35

@GetMapping("/show")
public String show(@RequestParam(name = "username",required = true) String name, int age){
   System.out.println(name+"=="+age);
   return "/index.jsp";
}

2.2、接收实体JavaBean属性数据

单个JavaBean数据：提交的参数名称只要与Java的属性名一致，就可以进行自动封装username=haohao&age=35&hobbies=eat&hobbies=sleep

public class User {
   private String username;
   private Integer age;
   private String[] hobbies;
   private Date birthday;
   private Address address;
   //... 省略get和set方法 ... 
}

@GetMapping("/show")
public String show(User user){
   System.out.println(user);
   return "/index.jsp";
}

嵌套JavaBean数据：提交的参数名称用 . 去描述嵌套对象的属性关系即a可username=haohao&address.city=tianjin&address.area=jinghai

同上，JavaBean中如果有日期数据，且日期格式不符合yyyy/MM/dd时，需要通过@DateTimeFormat指定日期格式username=haohao&birthday=1986-11-11

@Data
public class User {
    private String username;
    private Integer age;
    private String[] hobbies;
    
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birthday;
    
    private Address address;
}

接收数组或集合数据，客户端传递多个同名参数时，可以使用数组接收hobbies=eat&hobbies=sleep

@GetMapping("/show")
public String show(String[] hobbies) {
    for (String hobby : hobbies) {
        System.out.println(hobby);
    }
    return "/index.jsp";
}

2.3、接收数组或集合数据

客户端传递多个同名参数时，也可以使用单列集合接收，但是需要使用@RequestParam告知框架传递的参数是要同名设置的，不是对象属性设置的

@GetMapping("/show")
public String show(@RequestParam List<String> hobbies) {
    for (String hobby : hobbies) {
        System.out.println(hobby);
    }
    return "/index.jsp";
}

接收数组或集合数据，客户端传递多个不同命参数时，也可以使用Map<String,Object> 进行接收，同样需要用 @RequestParam 进行修饰username=haohao&age=18

@PostMapping("/show")
public String show(@RequestParam Map<String,Object> params){
    params.forEach((key,value) -> {
        System.out.println(key + "==" + value);
    });
    return "/index.jsp";
}

2.4、接收Json数据格式数据

Json数据都是以请求体的方式提交的，且不是原始的键值对格式的，所以我们要使用@RequestBody注解整体接收该数据。

{
  "username": "haohao",
  "age": 18,
  "hobbies": ["eat", "sleep"],
  "birthday": "1986-01-01",
  "address": {
    "city": "tj",
    "area": "binhai"
  }
}

@PostMapping("/show6")
public String show6(@RequestBody String body){
   System.out.println(body);
   return "/index.jsp";
}

使用Json工具（ jackson ）将Json格式的字符串转化为JavaBean进行操作

<dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-databind</artifactId>
   <version>2.9.0</version>
</dependency>

@PostMapping("/show")
public String show(@RequestBody String body) throws IOException {
    System.out.println(body);

    ObjectMapper objectMapper = new ObjectMapper();
    User user = objectMapper.readValue(body, User.class);

    System.out.println(user);
    return "/index.jsp";
}

配置RequestMappingHandlerAdapter，指定消息转换器，就不用手动转换json格式字符串了

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <property name="messageConverters">
        <list>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </list>
    </property>
</bean>

@PostMapping("/show")
public String show(@RequestBody User user){
   System.out.println(user);
   return "/index.jsp";
}

使用Map接收json格式字符串

@PostMapping("/show")
public String show(@RequestBody Map map){
	System.out.println(map);
   return "/index.jsp";
}

2.5、接收Restful风格数据

2.5.1、什么是Rest风格？

Rest（Representational State Transfer）表象化状态转变（表述性状态转变），在2000年被提出，基于HTTP、URI、xml、JSON等标准和协议，支持轻量级、跨平台、跨语言的架构设计。是Web服务的一种新网络应用程序的设计风格和开发方式。

2.5.2、接收Restful风格数据

Restful风格的请求，常见的规则有如下三点：

• 用URI表示某个模块资源，资源名称为名词；

  模块	说明	基础 URI
  用户模块	user	http://localhost/user
  商品模块	product	http://localhost/product
  账户模块	account	http://localhost/account
  日志模块	log	http://localhost/log

• 用请求方式表示模块具体业务动作，例如：GET表示查询、POST表示插入、PUT表示更新、DELETE表示删除

  URI 资源	请求方式	参数位置	示例参数（或说明）	操作说明
  http://localhost/user/100	GET	URL 路径变量	100	查询 ID=100 的用户信息
  http://localhost/user	POST	请求体 JSON	{"username":"haohao","age":18}	插入用户信息
  http://localhost/user	PUT	请求体 JSON	{"id":100,"username":"haohao","age":18}	修改 ID=100 的用户信息
  http://localhost/user/100	DELETE	URL 路径变量	100	删除 ID=100 的用户信息
  http://localhost/product/5	GET	URL 路径变量	5	查询 ID=5 的商品信息
  http://localhost/product	POST	请求体 JSON	{"proName":"小米手机","price":1299}	插入商品信息
  http://localhost/product	PUT	请求体 JSON	{"id":5,"proName":"小米手机","price":1299}	修改 ID=5 的商品信息
  http://localhost/product/5	DELETE	URL 路径变量	5	删除 ID=5 的商品信息

• 用HTTP响应状态码表示结果，国内常用的响应包括三部分：状态码、状态信息、响应数据

  {
    "code": 200,
    "message": "成功",
    "data": {
      "username": "haohao",
      "age": 18
    }
  }
  

接收Restful风格数据，Restful请求数据一般会在URL地址上携带，可以使用注解 @PathVariable(占位符参数名称)http://localhost/user/100

@PostMapping("/user/{id}")
public String findUserById(@PathVariable("id") Integer id){
   System.out.println(id);
   return "/index.jsp";
}

请求URL资源地址包含多个参数情况http://localhost/user/haohao/18

@PostMapping("/user/{username}/{age}")
public String findUserByUsernameAndAge(@PathVariable("username") String username,@PathVariable("age") Integer age){
   System.out.println(username+"=="+age);
   return "/index.jsp";
}

2.6、接收文件上传的数据

文件上传的表单需要一定的要求，如下：

• 表单的提交方式必须是POST

• 表单的enctype属性必须是multipart/form-data

• 文件上传项需要有name属性

<form action="" enctype="multipart/form-data">
   <input type="file" name="myFile">
</form>

服务器端，由于映射器适配器需要文件上传解析器，而该解析器默认未被注册，所以手动注册

<bean id="multipartResolver" 
      class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    
    <!-- 设置文件的编码格式，建议使用 UTF-8 -->
    <property name="defaultEncoding" value="UTF-8"/>
    
    <!-- 设置单个上传文件的最大大小，单位为字节（此处为 1MB）-->
    <property name="maxUploadSizePerFile" value="1048576"/>

    <!-- 设置所有上传文件的总大小上限（此处为 3MB）-->
    <property name="maxUploadSize" value="3145728"/>

    <!-- 设置文件上传时的内存缓存大小，超出则写入磁盘临时文件（此处为 1MB）-->
    <property name="maxInMemorySize" value="1048576"/>
</bean>

而CommonsMultipartResolver底层使用的Apache的是Common-fileuplad等工具API进行的文件上传

<dependency>
  <groupId>commons-fileupload</groupId>
  <artifactId>commons-fileupload</artifactId>
  <version>1.4</version>
</dependency>

<dependency>
  <groupId>commons-io</groupId>
  <artifactId>commons-io</artifactId>
  <version>2.7</version>
</dependency>

使用MultipartFile类型接收上传文件

@PostMapping("/fileUpload")
public String fileUpload(@RequestParam("myFile") MultipartFile myFile) throws IOException {
    System.out.println("上传文件名：" + myFile.getOriginalFilename());
    
    // 目标文件路径，注意创建目录和权限
    String destPath = "C:\\Users\\haohao\\" + myFile.getOriginalFilename();
    
    // 使用 try-with-resources 自动关闭流
    try (InputStream inputStream = myFile.getInputStream();
         FileOutputStream outputStream = new FileOutputStream(destPath)) {
        IOUtils.copy(inputStream, outputStream);
    }
    
    return "/index.jsp";
}

如果进行多文件上传的话，则使用MultipartFile数组即可

2.7、接收Http请求头数据

接收指定名称的请求头

@GetMapping("/headers")
public String headers(@RequestHeader("Accept-Encoding") String acceptEncoding){
	System.out.println("Accept-Encoding:"+acceptEncoding);
   return "/index.jsp";
}

接收所有的请求头信息

@GetMapping("/headersMap")
public String headersMap(@RequestHeader Map<String,String> map){
	map.forEach((k,v)->{
	   System.out.println(k+":"+v);
   });
   return "/index.jsp";
}

获得客户端携带的Cookie数据

@GetMapping("/cookies")
public String cookies(@CookieValue(value = "JSESSIONID",defaultValue = "") String jsessionid){
   System.out.println(jsessionid);
   return "/index.jsp";
}

获得转发Request域中数据，在进行资源之间转发时，有时需要将一些参数存储到request域中携带给下一个资源

@GetMapping("/request1")
public String request1(HttpServletRequest request){
    // 存储数据到请求域
    request.setAttribute("username", "haohao");
    // 请求转发到 /request2
    return "forward:/request2";
}

@GetMapping("/request2")
public String request2(@RequestAttribute("username") String username){
    System.out.println(username);  // 输出 "haohao"
    return "/index.jsp";
}

2.8、请求参数乱码的解决方案

Spring已经提供好的CharacterEncodingFilter来进行编码过滤

<!--配置全局的编码过滤器-->
<filter>
  <filter-name>CharacterEncodingFilter</filter-name>
  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  <init-param>
    <param-name>encoding</param-name>
    <param-value>UTF-8</param-value>
  </init-param>
</filter>

<filter-mapping>
  <filter-name>CharacterEncodingFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

3、Javaweb常用对象获取

获得Javaweb常见原生对象，有时在我们的Controller方法中需要用到Javaweb的原生对象，例如：Request、Response等，我们只需要将需要的对象以形参的形式写在方法上，SpringMVC框架在调用Controller方法时，会自动传递实参：

@GetMapping("/javawebObject")
public String javawebObject(HttpServletRequest request, HttpServletResponse response, 
HttpSession session){
   System.out.println(request);
   System.out.println(response);
   System.out.println(session);
   return "/index.jsp";
}

4、请求静态资源

静态资源请求失效的原因，当DispatcherServlet的映射路径配置为 / 的时候，那么就覆盖的Tomcat容器默认的缺省Servlet，在Tomcat的config目录下有一个web.xml 是对所有的web项目的全局配置，其中有如下配置：

<servlet>
  <servlet-name>default</servlet-name>
  <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
  <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
  <servlet-name>default</servlet-name>
  <url-pattern>/</url-pattern>
</servlet-mapping>

url-pattern配置为 / 的Servlet我们称其为缺省的Servlet，作用是当其他Servlet都匹配不成功时，就找缺省的Servlet，静态资源由于没有匹配成功的Servlet，所以会找缺省的DefaultServlet，该DefaultServlet具备二次去匹配静态资源的功能。但是我们配置DispatcherServlet后就将其覆盖掉了，而DispatcherServlet会将请求的静态资源的名称当成Controller的映射路径去匹配，即静态资源访问不成功了！

静态资源请求的三种解决方案：

第一种方案，可以再次激活Tomcat的DefaultServlet，Servlet的url-pattern的匹配优先级是：精确匹配>目录匹配>扩展名匹配>缺省匹配，所以可以指定某个目录下或某个扩展名的资源使用DefaultServlet进行解析：

<servlet-mapping>
  <servlet-name>default</servlet-name>
  <url-pattern>/img/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
  <servlet-name>default</servlet-name>
  <url-pattern>*.html</url-pattern>
</servlet-mapping>

第二种方式，在spring-mvc.xml中去配置静态资源映射，匹配映射路径的请求到指定的位置去匹配资源

<!-- mapping是映射资源路径，location是对应资源所在的位置 -->
<mvc:resources mapping="/img/*" location="/img/"/>
<mvc:resources mapping="/css/*" location="/css/"/>
<mvc:resources mapping="/css/*" location="/js/"/>
<mvc:resources mapping="/html/*" location="/html/"/>

第三种方式，在spring-mvc.xml中去配置< mvc:default-servlet-handler >，该方式是注册了一个DefaultServletHttpRequestHandler 处理器，静态资源的访问都由该处理器去处理，这也是开发中使用最多的

<mvc:default-servlet-handler/>

5、注解驱动 <mvc:annotation-driven> 标签

静态资源配置的第二第三种方式我们可以正常访问静态资源了，但是Controller又无法访问了，报错404，即找不到对应的资源

第二种方式是通过SpringMVC去解析mvc命名空间下的resources标签完成的静态资源解析，第三种方式式通过SpringMVC去解析mvc命名空间下的default-servlet-handler标签完成的静态资源解析，根据前面所学习的自定义命名空间的解析的知识，可以发现不管是以上哪种方式，最终都会注册SimpleUrlHandlerMapping

public BeanDefinition parse(Element element, ParserContext context) {
   //创建SimpleUrlHandlerMapping类型的BeanDefinition
   RootBeanDefinition handlerMappingDef = new RootBeanDefinition(SimpleUrlHandlerMapping.class);
   //注册SimpleUrlHandlerMapping的BeanDefinition
    context.getRegistry().registerBeanDefinition(beanName, handlerMappingDef);
}

又结合组件浅析知识点，一旦SpringMVC容器中存在 HandlerMapping 类型的组件时，前端控制器DispatcherServlet在进行初始化时，就会从容器中获得HandlerMapping ，不在加载 dispatcherServlet.properties中默认处理器映射器策略，那也就意味着RequestMappingHandlerMapping不会被加载到了。

手动将RequestMappingHandlerMapping也注册到SpringMVC容器中就可以了，这样DispatcherServlet在进行初始化时，就会从容器中同时获得RequestMappingHandlerMapping存储到DispatcherServlet中名为handlerMappings的List集合中，对@RequestMapping 注解进行解析。

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>

根据上面的讲解，可以总结一下，要想使用@RequestMapping正常映射到资源方法，同时静态资源还能正常访问，还可以将请求json格式字符串和JavaBean之间自由转换，我们就需要在spring-mvc.xml中尽心如下配置：

<!-- 显式配置 RequestMappingHandlerMapping -->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping" />

<!-- 显式配置 RequestMappingHandlerAdapter -->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <property name="messageConverters">
        <list>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" />
        </list>
    </property>
</bean>

<!-- 配置 DefaultServletHttpRequestHandler，用于处理静态资源 -->
<mvc:default-servlet-handler />

这么复杂繁琐的配置，是不是看上去有点头大？Spring是个"暖男"，将上述配置浓缩成了一个简单的配置标签，那就是mvc的注解驱动，该标签内部会帮我们注册RequestMappingHandlerMapping、注册RequestMappingHandlerAdapter并注入Json消息转换器等，上述配置就可以简化成如下：

<!--mvc注解驱动-->
<mvc:annotation-driven/>
<!--配置DefaultServletHttpRequestHandler-->
<mvc:default-servlet-handler/>

PS：<mvc:annotation-driven> 标签在不同的版本中，帮我们注册的组件不同，Spring 3.0.X 版本注册是DefaultAnnotationHandlerMapping 和 AnnotationMethodHandlerAdapter，由于框架的发展，从Spring 3.1.X 开始注册组件变为 RequestMappingHandlerMapping和RequestMappingHandlerAdapter