Spring MVC

基本使用
@RequestMapping
设置请求方式
- 设置Post请求
- 设置Get请求
请求参数
Post请求乱码问题
DispatcherServlet中的URL匹配问题
请求处理后返回客户端的内容
RestController

官方链接
核心功能：用于拦截和处理客户端的请求

基本使用

新建一个Maven web项目，添加依赖

        <!-- JavaEE基本依赖-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- SpringMVC -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <!-- 日志 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>

Spring-webmvc会依赖其他库

在以前我们需要自己创建Servlet,并且每一个请求都对应一个Servlet。这样就比较麻烦。
我们想在使用SpringMVC提供的Servlet。

首先在web.xml进行配置 ```xml <?xml version=”1.0” encoding=”UTF-8”?>

<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </init-param>
    <!-- 项目部署到服务器，就会创建Servlet，大于等于0就会部署到服务器就创建，值越小越先创建 -->
    <load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>

    <url-pattern>/</url-pattern>
</servlet-mapping>


- 创建controller控制器类，处理客户端请求
```java
@Controller //需要被扫描到，所以可以使用Spring配置文件扫描到该控制器
public class UserController {
    @RequestMapping("/login")
    @ResponseBody
    public String Login(){
        System.out.println("拦截到了/login请求");
        return "/login";
    }
}

在Spring配置文件applicationContext.xml，配置上面的类要被扫描到

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!-- 保证@Controller能够使用扫描到 -->
    <context:component-scan base-package="com.lff"/>
</beans>

请求过程

Spring MVC - 图3

@RequestMapping

可以用在类或者方法上

@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/login")
    @ResponseBody
    public String login(){
        System.out.println("拦截到了/login请求");
        return "/login";
    }
    @RequestMapping("/remove")
    @ResponseBody
    public String remove(){
        System.out.println("拦截到了/user/remove请求");
        return "/user/remove";
    }
    @RequestMapping("/get")
    @ResponseBody
    public String get(){
        System.out.println("拦截到了/user/get请求");
        return "/user/get";
    }
}

设置请求方式

设置Post请求

可以使用@RequestMapping

@RequestMapping(value = "/remove",method = RequestMethod.POST)

也可以使用@PostMapping,这种方式是上面的语法糖格式
```
@PostMapping("/remove")
```
使用@RequestMapping(value = “/remove”）这种方式如果不写method默认post和get都可以

设置Get请求

@RequestMapping

@RequestMapping(value = "/login",method = RequestMethod.GET)

@GetMapping(“/get”)

示例代码

package com.lff;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping(value = "/login",method = RequestMethod.GET)
    @ResponseBody
    public String login(){
        System.out.println("拦截到了/login请求");
        return "/login";
    }
    @RequestMapping(value = "/remove",method = RequestMethod.POST)
    @ResponseBody
    public String remove(){
        System.out.println("拦截到了/user/remove请求");
        return "/user/remove";
    }
    @GetMapping("/get")
    @ResponseBody
    public String get(){
        System.out.println("拦截到了/user/get请求");
        return "/user/get";
    }
    @PostMapping("/removeList")
    @ResponseBody
    public String removeList(){
        System.out.println("拦截到了/user/removeList请求");
        return "/user/removeList";
    }
}

请求参数

Spring MVC会给请求方法里面传递很多参数，比如HttpServletRequest、HttpServletResponse、WebRequest等

    @PostMapping("/login")
    @ResponseBody
    public String login(HttpServletRequest request, WebRequest webRequest, HttpServletResponse response, HttpSession session){
        System.out.println("拦截到了/login请求");
        return "/login";
    }

具体的详细参数信息可以参考官方文档。

示例
新建index.jsp文件


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
欢迎注册，请输入用户名
<form method="POST" action="login">
    <p>姓名：<input type="text" name="name"></input></p>
    <p>年龄：<input type="text" name="age"></input></p>
    <p>密码：<input type="password" name="password"></input></p>
    <p><input type="submit" value="确定"></input></p>
</form>
</body>
</html>

对应的处理方法，可以直接接受上面的参数

    @PostMapping("/login")
    @ResponseBody
    public String login(String name,String age,String password){
        System.out.println("name = " + name);
        System.out.println("age = " + age);
        System.out.println("password = " + password);
        return "/login";
    }

请求方法的参数名和请求过来的参数名称一样就可以了。默认如果客户端没有传，则为null。

有时如果想某一个参数必须传，可以在参数名称前加@RequestParam

    @PostMapping("/login")
    @ResponseBody
    public String login(@RequestParam String name,String age,String password,@RequestParam  String address){
        System.out.println("name = " + name);
        System.out.println("age = " + age);
        System.out.println("password = " + password);
        return "/login";
    }

如果客户端没有传参数会报错

也可在@RequestParam里面指定客户端传来的名称，以及是否为必传参数
如在JSP里面有一个标签name改成my_name

<p>姓名：<input type="text" name="my_name"></input></p>

服务端接收参数时

@PostMapping("/login")
@ResponseBody
public String login(@RequestParam(value = "my_name",required = false) String name,String age,String password){
    System.out.println("name = " + name);
    System.out.println("age = " + age);
    System.out.println("password = " + password);
    return "/login";
}

如果请求参数很多使用上面的方式接收参数就很麻烦，我们可以使用模型接收，只需要模型里面的属性名与传递的参数名称保持一致就可以了
比如提交表单的参数如下

<form method="POST" action="login">
    <p>姓名：<input type="text" name="name"></input></p>
    <p>年龄：<input type="text" name="age"></input></p>
    <p>密码：<input type="password" name="password"></input></p>
    <p><input type="submit" value="确定"></input></p>
</form>

新建模型类

public class Person {
    private  String name;
    private  Integer age;
    private  String password;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}

服务端接收参数

    @PostMapping("/login")
    @ResponseBody
    public String login(Person person){
        System.out.println("name = " + person.getName());
        System.out.println("age = " + person.getAge());
        System.out.println("password = " + person.getPassword());
        return "/login";
    }

直接传对应的模型对象就可以了

PathVariable

如果路径里面有可变参数，比如根据id获取哪一个人，请求参数可能是这样的/get/1、/get/2、/get/3……
我们怎么获取后面的变量参数呢？
可以先定义变量名称：格式{id} 。
获取时通过@PathVariable 变量获取
示例

    @GetMapping("/get/{id1}")
    @ResponseBody
    public String getPerson(@PathVariable("id1") Integer id){
        System.out.println("id = " + id);
        return "getPerson id = " + id;
    }

接收map类型的参数

        @PostMapping("/login")
        @ResponseBody
        public String login(Map<String,Object> map){
            System.out.println("map = " + map);
            return "/login";
        }

默认情况下是不能直接接收map类型参数的，需要参数前面加@RequestParam

@PostMapping("/login")
@ResponseBody
public String login(@RequestParam Map<String,Object> map){
    System.out.println("map = " + map);
    return "/login";
}

如果有相同的参数名呢？

<form method="POST" action="login">
    <p>姓名：<input type="text" name="name"></input></p>
    <p>年龄：<input type="text" name="age"></input></p>
    <p>密码：<input type="password" name="password"></input></p>
    <p>篮球：<input type="checkbox" name="hobby"></input></p>
    <p>足球：<input type="checkbox" name="hobby"></input></p>
    <p>台球：<input type="checkbox" name="hobby"></input></p>
    <p><input type="submit" value="确定"></input></p>
</form>

比如上面的爱好有很多个，由于服务端使用map接收的，key是唯一的，我们可以使用下面的数组方式接收hobby

@PostMapping("/login")
@ResponseBody
public String login(@RequestParam Map<String,Object> map,String[] hobby){
    System.out.println("map = " + map);
    for (String value: hobby
        ) {
        System.out.println(value);
    }
    return "/login";
}

上面是使用数组的方式接收，也可以使用List接收

        @PostMapping("/login")
        @ResponseBody
        public String login(@RequestParam Map<String,Object> map,@RequestParam List<String> hobby){
            System.out.println("map = " + map);
            for (String value: hobby
                 ) {
                System.out.println(value);
            }
            return "/login";
        }

使用List要加@RequestParam 否则会如下错误

nested exception is java.lang.IllegalStateException: No primary or default constructor found for interface java.util.List

Multipart参数

如果客户端使用的是multipart/form-data的方式上传参数，服务端怎么接收参数？

<form method="POST" action="login" enctype="multipart/form-data">
    <p>姓名：<input type="text" name="name"></input></p>
    <p>年龄：<input type="text" name="age"></input></p>
    <p><input type="submit" value="确定"></input></p>
</form>

因为multipart/form-data上传的参数在发送HTTP请求时会有分割线，需要手动去解析该类型的参数。我们使用第三方库解析

Maven依赖

<!-- 解析Multipart类型参数 -->
<dependency>
 <groupId>commons-fileupload</groupId>
 <artifactId>commons-fileupload</artifactId>
 <version>1.4</version>
</dependency>

将CommonsMultipartResolver 添加到IOC容器里面，id值固定为multipartResolver

 <!-- 解析Multipart参数 -->
 <bean id="multipartResolver"
       class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!--        设置编码-->
     <property name="defaultEncoding" value="UTF-8"/>
<!--        限制每个文件上传大小-->
     <property name="maxUploadSizePerFile" value="20480" />
<!--        限制总的上传大小，以字节为单位，默认-1表示无限制-->
     <property name="maxUploadSize" value="20480" />
 </bean>

服务端直接处理即可

@PostMapping("/login")
@ResponseBody
public String login(String name,Integer age){
System.out.println("name = " + name);
System.out.println("age = " + age);
return "/login";
}

文件参数

如果客户端传的是文件参数，服务端该如何能接受到？

<form method="POST" action="login" enctype="multipart/form-data">
    <p>姓名：<input type="text" name="name"></input></p>
    <p>年龄：<input type="text" name="age"></input></p>
    <p>文件：<input type="file" name="headerImg1"></input></p>
    <p><input type="submit" value="确定"></input></p>
</form>

在上面Multipart参数配置的基础上，服务端使用MultipartFile类型的参数接受

@PostMapping("/login")
@ResponseBody
public String login(String name, Integer age, MultipartFile headerImg1,HttpServletRequest request) throws IOException {
    System.out.println("name = " + name);
    System.out.println("age = " + age);
    String fileName = headerImg1.getOriginalFilename();
    String path = request.getServletContext().getRealPath("/upload/img/" +fileName);
    System.out.println("path = " + path);
    File file = new File(path);
    //把上传的文件写到硬盘上
    headerImg1.transferTo(file);
    return "/login";
}

多个文件上传

<form method="POST" action="login" enctype="multipart/form-data">
    <p>姓名：<input type="text" name="name"></input></p>
    <p>年龄：<input type="text" name="age"></input></p>
    <p>文件1：<input type="file" name="headerImg1"></input></p>
    <p>文件2：<input type="file" name="headerImg2"></input></p>
    <p><input type="submit" value="确定"></input></p>
</form>

服务端处理,只需多添加一个参数即可

        @PostMapping("/login")
        @ResponseBody
        public String login(String name, Integer age, MultipartFile headerImg1,MultipartFile headerImg2,HttpServletRequest request) throws IOException {
            System.out.println("name = " + name);
            System.out.println("age = " + age);
            String fileName1 = headerImg1.getOriginalFilename();
            String fileName2 = headerImg2.getOriginalFilename();
            String path1 = request.getServletContext().getRealPath("/upload/img/" +fileName1);
            String path2 = request.getServletContext().getRealPath("/upload/img/" +fileName2);
            File file = new File(path1);
            //把上传的文件写到硬盘上
            headerImg1.transferTo(file);
            file = new File(path2);
            headerImg2.transferTo(file);
            return "/login";
        }

也有可能客户端使用相同的名称传递多个文件参数

<form method="POST" action="login" enctype="multipart/form-data">
    <p>姓名：<input type="text" name="name"></input></p>
    <p>年龄：<input type="text" name="age"></input></p>
    <p>文件1：<input type="file" name="headerImg"></input></p>
    <p>文件2：<input type="file" name="headerImg"></input></p>
    <p><input type="submit" value="确定"></input></p>
</form>

服务端可以使用数组接受

        @PostMapping("/login")
        @ResponseBody
        public String login(String name, Integer age, MultipartFile[] headerImg,HttpServletRequest request) throws IOException {
            for (MultipartFile file: headerImg
                 ) {
                System.out.println(file.getOriginalFilename());
            }
            return "/login";
        }

Post请求乱码问题

当客户端发送post请求有中文字符时，会出现乱码问题。我们可以做如下处理

request.setCharacterEncoding("UTF-8");

但是每一个请求方法里面都设置就不高级。我们可以自定义过滤器处理。springMVC已经考虑了这个问题，可以使用springMVC自带的过滤器进行处理。在web.xml中配置如下信息

<!--    使用springMVC自带的过滤器处理post请求乱码问题-->
    <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>

上面解决了客户端发送请求到达服务端乱码的问题。

服务端响应给客户端后也可能乱码，比如下面

    @PostMapping("/login")
    @ResponseBody
    public String login(Person person){
        System.out.println("name = " + person.getName());
        System.out.println("age = " + person.getAge());
        System.out.println("password = " + person.getPassword());
        return "/login 哈哈哈哈";
    }

返回客户端是“/login 哈哈哈哈”

以前我们是这样处理响应到客户端乱码问题的

response.setContentType("text/plain; charset=UTF-8");

在Shpring中处理乱码有很多种方案。
第一种方式

@PostMapping(value = "/login",produces = "text/plain; charset=UTF-8")

第二种方式
在applicationContext.xml文件里面配置如下信息

    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <property name="defaultCharset" value="UTF-8" />
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

注意annotation-driven标签的所在的位置，以mvc结尾的。

DispatcherServlet中的URL匹配问题

我们在web.xml配置的url匹配模式如下

<!--    使用SpringMVC提供的DispatcherServlet进行处理拦截客户端的请求-->
<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--        加载Spring的配置文件，配置文件里面配置要扫描的类等-->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </init-param>
    <!-- 项目部署到服务器，就会创建Servlet，大于等于0就会部署到服务器就创建，值越小越先创建 -->
    <load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <!-- 要拦截的客户端请求路径-->
    <url-pattern>/</url-pattern>
</servlet-mapping>

在这里我们匹配模式写的是

<!-- 要拦截的客户端请求路径-->
<url-pattern>/</url-pattern>

这种方式会拦截静态资源比如.html、.js 等，不会拦截动态资源比如*.jsp
比如当访问HTML等静态资源时，报如下错误，说明HTML静态资源被拦截到了，在控制器里面又找不到以test.html匹配的路径于是报如下错误，其实我们是不想被拦截到的，希望交给Tomact容器去处理，然后返回给客户端。

当访问JSP时，没有问题，说明没有拦截到JSP

有些公司进行URL匹配时，还会这样写

<!--   要拦截的客户端请求路径-->
<url-pattern>*.do</url-pattern>

这样表示，只要当请求路径是.do结尾的请求才会被拦截。也就是说，无论是静态资源(html、CSS、JS、PNG、JPG等)、还是动态资源(JSP)都不会被拦截。
比如访问HTML

访问JSP

其实这种结果才是我们想要的，也就是当访问静态资源或者动态资源JSP时，还交给容器处理。只有以.do结尾的请求才交给控制器处理。

还有一种匹配模式是这样写的

<!-- 拦截客户端所有请求路径-->
<url-pattern>/*</url-pattern>

这种方式会拦截所有的请求路径，包括静态资源(html、CSS、JS、PNG、JPG等)、动态资源(*.jsp)
访问JSP

说明被拦截到了，交给控制器处理，由于控制器也没有对其进行处理报错了。

请求静态资源时

说明被拦截到了，交给控制器处理，由于控制器也没有对其进行处理报错了。
这才是要拦截所有的请求。这种写法通常用在Filter里面，比如设置编码，设置完后调用chain.doFilter过掉。

终上所述，最好的方案还是以*.do方式匹配的比较好。但是每次请求路径都要写.do还是比较烦的。比如

https://example.com/user/add.do

如果可以直接能办到这样写，把.do去掉就好了

https://example.com/user/add

我们在URL匹配中还是要这样写

<url-pattern>/</url-pattern>

但这种方式会拦截到静态资源，我们只需把静态资源放开就可以了。
在applicationContext.xml文件里面配置如下信息

<!--   DIspatcherServlet不想处理的请求都交给容器里面默认Servlet去处理，比如HTML等静态资源-->
    <mvc:default-servlet-handler />
<!--    保证所有的注解都能够使用，如果不加这句controller里面的注解都会失效-->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <property name="defaultCharset" value="UTF-8" />
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

这样写就搞定啦。
当访问静态资源时，也没有问题了

补充：如果我们把web.xml里面的DIspatcherServlet去掉。当我们访问静态资源HTML时，Tomact里面会有一个DefaultServlet去处理对应的html文件，然后把静态资源文件返回给客户端。如果放问的是JSP，Tomact里面会有一个JspServlet处理JSP把对应的JSP资源处理返回给客户端，上面的配置就是说如果Controller里面没有写处理代码会转发到容器里面的Servlet处理。

把静态资源放开还有一种方式
在URL匹配中还是要这样写

<url-pattern>/</url-pattern>

在applicationContext.xml文件里面配置如下信息

<!--    mapping代表请求的路径。**表示所有的子目录都可以匹配-->
<!--    Location表示：资源文件的位置-->
<mvc:resources mapping="/asset/**" location="/asset/"/>
<!--    保证所有的注解都能够使用，如果不加这句controller里面的注解都会失效-->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <property name="defaultCharset" value="UTF-8" />
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

请求处理后返回客户端的内容

请求处理后可以返回给客户端以下内容

普通文本
HTML
JSON格式返回客户端
XML格式返回客户端
转发到JSP返回
重定向等
文件（图片等），不需要处理已经交给默认的Servlet处理

普通文本、HTML

如果方法没有返回值,这种方式是我们以前搞Servlet处理方式

    @RequestMapping("testVoid")
    public void testVoid(HttpServletResponse response) throws IOException {
        response.setContentType("text/plain; charset=UTF-8");
        response.getWriter().write("哈哈哈");
    }

直接使用SpringMVC的方式

    @RequestMapping("testVoid1")
    @ResponseBody
    public String testVoid1(){
        return "哈哈哈哈";
    }

而且响应类型默认是text/html

如果返回的内容有HTML标签

    @RequestMapping("testVoid2")
    @ResponseBody
    public String testVoid2(){
        return "<h1>哈哈哈哈</h1>";
    }

浏览器会自动处理解析，因为响应类型默认是text/html

返回XML格式内容

添加依赖

<!-- domain模型转XML字符串 -->
<!--  XML 接口-->
<dependency> 
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.4.0-b180830.0359</version>
</dependency>
<!--  XML 接口的实现-->
<dependency>
<groupId>javax.xml</groupId>
<artifactId>jaxb-impl</artifactId>
<version>2.1</version>
</dependency>

注意：当然也必须有标签
新建模型类 ```java import javax.xml.bind.annotation.XmlAttribute; import javax.xml.bind.annotation.XmlElement; import javax.xml.bind.annotation.XmlRootElement; import java.util.List;

//根元素 @XmlRootElement(name = “person”) public class Person { private String name; private Integer age; private Dog dog; private List goodDogs;

// 属性 @XmlAttribute(name = “name”) public String getName() { return name; }

public void setName(String name) {
    this.name = name;
}
@XmlAttribute
public Integer getAge() {
    return age;
}
public void setAge(Integer age) {
    this.age = age;
}
@XmlElement
public Dog getDog() {
    return dog;
}
public void setDog(Dog dog) {
    this.dog = dog;
}

// 引用类型要用 @XmlElement @XmlElement public List getGoodDogs() { return goodDogs; }

public void setGoodDogs(List<Dog> goodDogs) {
    this.goodDogs = goodDogs;
}

}

```java
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement  
public class Dog {
    private  String name;
    private  Integer age;
    @XmlAttribute
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @XmlAttribute
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
}

返回方法

    @RequestMapping("/xml")
    @ResponseBody
    public Person login(){
        Person person = new Person();
        person.setName("lff");
        person.setAge(18);
        Dog dog = new Dog();
        dog.setAge(1);
        dog.setName("dog");
        Dog dog1 = new Dog();
        dog1.setAge(2);
        dog1.setName("dog2");
        ArrayList list = new ArrayList();
        list.add(dog);
        list.add(dog1);
        person.setGoodDogs(list);
        person.setDog(dog);
        return person;
    }

返回JSON格式给客户端

配置依赖

<!-- domain模型转JSON字符串 -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.11.0</version>
</dependency>

新建模型类

package com.lff.domain;
import java.util.List;
public class Person {
    private  String name;
    private  Integer age;
    private Dog dog;
    private List<Dog> goodDogs;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Dog getDog() {
        return dog;
    }
    public void setDog(Dog dog) {
        this.dog = dog;
    }
    public List<Dog> getGoodDogs() {
        return goodDogs;
    }
    public void setGoodDogs(List<Dog> goodDogs) {
        this.goodDogs = goodDogs;
    }
}

package com.lff.domain;
public class Dog {
    private  String name;
    private  Integer age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
}

方法调用

    @RequestMapping("/json")
    @ResponseBody
    public Person json(){
        Person person = new Person();
        person.setName("lff");
        person.setAge(18);
        Dog dog = new Dog();
        dog.setAge(1);
        dog.setName("dog");
        Dog dog1 = new Dog();
        dog1.setAge(2);
        dog1.setName("dog2");
        ArrayList list = new ArrayList();
        list.add(dog);
        list.add(dog1);
        person.setGoodDogs(list);
        person.setDog(dog);
        return person;
    }

上面无论返回的是JSON格式还是XML格式，如果返回有中文就会乱码，我们可以统一在applicationContext.xml设置。找一个比较全的设置乱码方式

    <mvc:annotation-driven>
        <mvc:message-converters>
            <!-- 如果控制器方法里面返回值是String类型的内容，就会设置UTF-8编码 -->
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <property name="defaultCharset" value="UTF-8"/>
            </bean>
 <!-- 如果控制器方法里面返回值是domain模型对象并且通过Jackson转成JSON字符串，就会设置UTF-8编码 -->
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="defaultCharset" value="UTF-8"/>
            </bean>
 <!-- 如果控制器方法里面返回值是domain模型对象并且通过JAXB转成XML字符串，就会设置UTF-8编码 -->
            <bean class="org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter">
                <property name="defaultCharset" value="UTF-8"/>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

a) 返回JSP给客户端

使用ModelAndViev将数据和视图绑定在一起返回给客户端

新建测试JSP页面路径为/page/test1.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
this is test1.jsp
person name:${person.name}
person age :${person.age}
</body>
</html>

处理客户端请求

    @RequestMapping("/jsp1") //注意次路径不要写以*.jsp结尾否则会被容器里面的Servlet处理
    public ModelAndView test1Jsp(){
        ModelAndView modelAndView = new ModelAndView();
        Person person = new Person();
        person.setName("lff");
        person.setAge(18);
//        内部还是通过request.setAttribute的方式设置
        modelAndView.addObject("person",person);
//        设置转发路径
        modelAndView.setViewName("/page/test1.jsp");
        return modelAndView;
    }

关于请求路径以及转发路径的问题
我们在RequestMapping里面写的是/jsp1。以/开头表示请求路径从http(s)://ip:端口/context_path/jsp1作为客户端请求路径

关于请求路径

在Java代码中，路径问题
假设请求路径是：”http://IP地址:端口/context_path/path1/path2/path3“
我们设置转发路径为

// 设置转发路径
modelAndView.setViewName("/page/test1.jsp");

上面以/开头，表示转发时以context_path作为转发路径。所以最终的转发路径为：
http://IP地址:端口/context_path/page/test1.jsp
如果设置的转发路径为：

// 设置转发路径
modelAndView.setViewName("page/test1.jsp");

�不以/开头，在转发时会把当前请求路径的上一层路径作为参考路径。所以最终的转发路径为：
http://IP地址:端口/context_path/path1/path2/page/test1.jsp

�上面是在Java代码里面设置路径问题，如果是在JSP、HTML中呢？又有点区别：
假设请求路径还是是：”http://IP地址:端口/context_path/path1/path2/path3“
在HTML中是这样设置请求路径的/page/test1.jsp

欢迎注册，请输入用户名
<form method="POST" action="/page/test1.jsp">
    <p>姓名：<input type="text" name="name"></input></p>
    <p>年龄：<input type="text" name="age"></input></p>
    <p>密码：<input type="password" name="password"></input></p>
    <p><input type="submit" value="确定"></input></p>
</form>

在HTML或者JSP中，以/开头，上面的表单会以http://IP地址:端口作为参考路径，所以最终的请求路径为：
http://IP地址:端口/page/test1.jsp
如果form表单请求路径为：page/test1.jsp。则请求路径会以当前请求路径的上一层路径作为参考路径。最终的请求路径为：http://IP地址:端口/context_path/path1/path2/page/test1.jsp。

b) 返回JSP给客户端

当请求方法返回字符串且请求方法上没有@ResponseBody时，返回的字符串作为转发路径

    @RequestMapping("/jsp1") //注意次路径不要写以*.jsp结尾否则会被容器里面的Servlet处理
//    @ResponseBody //注意不要加ResponseBody，如果加就会直接把返回的字符串返回到客户端
    public String test1Jsp(HttpServletRequest request){
        Person person = new Person();
        person.setName("lff");
        person.setAge(18);
//        保存数据
        request.setAttribute("person",person);
        return "/page/test1.jsp"; //返回转发路径
    }

b) 重定向给客户端

    @RequestMapping("/jsp1") //注意次路径不要写以*.jsp结尾否则会被容器里面的Servlet处理
    public String test1Jsp(HttpServletRequest request){
        Person person = new Person();
        person.setName("lff");
        person.setAge(18);
//        保存数据
        request.setAttribute("person",person); //这种方式是不能把数据传递给jsp的，因为是重定向会创建新的Request
        return "redirect:/page/test1.jsp"; //返回转发路径
    }

上面是获取不到保存的数据的，可以使用如下方式

    @RequestMapping("/jsp1") //注意次路径不要写以*.jsp结尾否则会被容器里面的Servlet处理
    public String test1Jsp(){
        return "redirect:/page/test1.jsp?name='lff'&age=18"; //返回转发路径
    }

也可以通过如下配置，配置请求路径和要找的资源位置

<mvc:view-controller path="/jsp1" view-name="/page/test1.jsp" />

只有在控制器里面没有处理/jsp1路径时，才会走上面的配置，否则还是走控制器配置的路径。也就是控制器里面的优先级更高。

RestController

修饰控制器类的注解
@RestController //相当于@Controller + @ResponseBody。加这个注解相当于在控制器上加@Controller ，控制器的每个方法上加@ResponseBody。如果需要跳转页面就返回ModelAndViev

基本使用

@RequestMapping

设置请求方式

设置Post请求

设置Get请求

请求参数

PathVariable

接收map类型的参数

Multipart参数

文件参数

多个文件上传

Post请求乱码问题

DispatcherServlet中的URL匹配问题

请求处理后返回客户端的内容

普通文本、HTML

返回XML格式内容

返回JSON格式给客户端

a) 返回JSP给客户端

关于请求路径

b) 返回JSP给客户端

b) 重定向给客户端

RestController