SpringMVC数据响应和请求

文章目录

1.SpringMVC简介
2. SpringMVC快速入门
3. SpringMVC执行的流程
4.SpringMVC注解解释
5. 视图解析器
6.SpringMVC的数据响应
- 6.1返回ModelView对象
- 6.2直接返回字符串
- 6.3返回json字符串
7.SpringMVC获得请求数据
- 7.1 获得基本类型参数
- 7.2获得POJO类型参数
- 7.3获取数组类型参数
- 7.4获得集合类型参数
- 7.5请求数据乱码问题
- 7.6参数绑定注解@requestParam
- 7.7 获得Restful风格的参数
- 7.8自定义类型转换器
- 7.9 获得Servlet相关API
- 7.10获得请求头
- 7.11获取Cookie的值
- 7.12 文件上传
- - 7.12.1文件上传客户端三要素
  - 7.12.2文件上传原理
  - 7.12.3单文件上传的步骤
  - 7.12.4多文件上传

1.SpringMVC简介

SpringMVC 是一种基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级 Web 框架，属于SpringFrameWork 的后续产品，已经融合在 Spring Web Flow 中。SpringMVC 已经成为目前最主流的MVC框架之一，并且随着Spring3.0 的发布，全面超越 Struts2，成为最优秀的 MVC 框架。它通过一套注解，让一个简单的 Java 类成为处理请求的控制器，而无须实现任何接口。同时它还支持 RESTful 编程风格的请求。

2. SpringMVC快速入门

需求：客户端发起请求，服务器端接收请求，执行逻辑并进行视图跳转
① 导入SpringMVC相关坐标
pom.xml

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>

② 配置SpringMVC核心控制器DispathcerServlet
web.xml

  <servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <!--加载SpringMVC配置文件-->
      <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

③ 创建Controller类和视图页面

package com.zhxd.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

public class UserController {
    public String quick() {
        System.out.println("qucikStart...");
        return "success.jsp";
    }
}

④ 使用注解配置Controller类中业务方法的映射地址

package com.zhxd.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class UserController {
    @RequestMapping("/quick")
    public String quick() {
        System.out.println("qucikStart...");
        return "success.jsp";
    }
}

⑤ 配置SpringMVC核心文件 spring-mvc.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 http://www.springframework.org/schema/context/spring-context.xsd">
    <!--controller组件扫描-->
    <context:component-scan base-package="com.zhxd.controller"></context:component-scan>
    <!--或者-->
    <context:component-scan base-package="com.zhxd">
        <!--包括的注解-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"></context:exclude-filter>
        <!--或者不包括的注解-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"></context:exclude-filter>
    </context:component-scan>
</beans>

⑥ 客户端发起请求测试
在这里插入图片描述

3. SpringMVC执行的流程

在这里插入图片描述

用户发送请求至前端控制器DispatcherServlet。
DispatcherServlet收到请求调用HandlerMapping处理器映射器。
处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
DispatcherServlet调用HandlerAdapter处理器适配器。
HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。
Controller执行完成返回ModelAndView。
HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
ViewReslover解析后返回具体View。
DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。DispatcherServlet响应用户。

4.SpringMVC注解解释

@RequestMapping
作用：用于建立请求 URL 和处理请求方法之间的对应关系
位置：

类上，请求URL 的第一级访问目录。此处不写的话，就相当于应用的根目录
方法上，请求 URL 的第二级访问目录，与类上的使用@ReqquestMapping标注的一级目录一起组成访问虚拟路径
属性：
value:用于指定请求的URL。它和path属性的作用是一样的
method:用于指定请求的方式
params:用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的key和value必须和配置的一模一样
params = {"accountName"}:表示请求参数必须有accountName
params=(money!100):表示请求参数中money不能是100

package com.zhxd.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping(value = "/quick", method = RequestMethod.GET, params = {"username"})
    public String quick() {
        System.out.println("qucikStart...");
        return "success.jsp";
    }
}

5. 视图解析器

SpringMVC有默认组件配置，默认组件都是DispatcherServlet.properties配置文件中配置的，该配置文件地址org/springframework/web/servlet/DispatcherServlet.properties，该文件中配置了默认的视图解析器，如下：

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

翻看该解析器源码，可以看到该解析器的默认设置，如下：

REDIRECT_URL_PREFIX = "redirect:" --重定向前缀
return "redirct:/jsp/success.jsp"

FORWARD_URL_PREFIX = "forward:" --转发前缀（默认值）
return "forward:/jsp/success.jsp"

prefix = ""; --视图名称前缀
suffix = ""; --视图名称后缀

spring-mvc.xml

    <!--配置内部资源视图解析器-->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--/jsp/success.jsp-->
        <!--访问路径前缀-->
        <property name="prefix" value="/jsp/"></property>
        <!--访问路径后缀-->
        <property name="suffix" value=".jsp"></property>
    </bean>

修改UserController

@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping(value = "/quick", method = RequestMethod.GET, params = {"username"})
    public String quick() {
        System.out.println("qucikStart...");
//        return "/jsp/success.jsp"
        return "success";
    }
}

6.SpringMVC的数据响应

6.1返回ModelView对象

Model:模型作用：封装数据
View:视图作用：展示数据
ModelAndView可以由SpringMVC自动注入，只要在映射方法中加入ModelView的形参

	@RequestMapping("/quick2")
    public ModelAndView quick2() {
        /*
         * Model:模型 作用：封装数据
         * View:视图 作用：展示数据
         * */
        ModelAndView modelAndView = new ModelAndView();
        //设置模型数据
        modelAndView.addObject("username","zhxd");
        //设置视图名称
        modelAndView.setViewName("success");
        return modelAndView;
    }
    @RequestMapping("/quick3")
    //ModelAndView由SpringMVC自动注入
    public ModelAndView quick3(ModelAndView modelAndView) {
        modelAndView.addObject("username","zhxd");
        modelAndView.setViewName("success");
        return modelAndView;
    }

向request域存储数据

    @RequestMapping("/quick5")
    //SpringMVC自动注入request对象
    public String quick5(HttpServletRequest request) {
        request.setAttribute("username","zhxd");
        return "success";
    }

只使用Model属性

    @RequestMapping("/quick4")
    //Model由SpringMVC自动注入
    public String quick4(Model model) {
        model.addAttribute("username","zhxd");
        return "success";
    }

6.2直接返回字符串

Web基础阶段，客户端访问服务器端，如果想直接回写字符串作为响应体返回的话，只需要使y用response.getWriter().print(“hello world”) 即可，那么在Controller中想直接回写字符串该怎样呢？

通过SpringMVC框架注入的response对象，使用response.getWriter().print(“hello world”) 回写数
据，此时不需要视图跳转，业务方法返回值为void。

    @RequestMapping("/quick6")
    //SpringMVC自动注入response对象,回写字符串
    public void quick6(HttpServletResponse response) throws IOException {
        response.getWriter().print("Hello SpringMVC");
    }

将需要回写的字符串直接返回，但此时需要通过@ResponseBody注解告知SpringMVC框架，方法返回的字符串不是跳转是直接在http响应体中返回

    @RequestMapping("/quick7")
    @ResponseBody//告诉SpringMVC不进行页面跳转，直接返回字符串
    public String quick7() {
        return "Hello SpringMVC";
    }

6.3返回json字符串

在异步项目中，客户端与服务器端往往要进行json格式字符串交互，此时我们可以手动拼接json字符串返回。

    @RequestMapping("/quick8")
    @ResponseBody
    public String quick8() {
        //拼接json字符串
        return "{\"username\":\"zhangsan\",\"age\":18}";
    }

上述方式手动拼接json格式字符串的方式很麻烦，开发中往往要将复杂的java对象转换成json格式的字符串，可以json转换工具jackson进行转换，导入jackson坐标。

    @RequestMapping("/quick9")
    @ResponseBody
    public String quick9() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        User user = new User();
        user.setUsername("zhangsan");
        user.setAge(20);
        String s = mapper.writeValueAsString(user);
        return s;
    }

通过SpringMVC帮助我们对对象或集合进行json字符串的转换并回写，为处理器适配器配置消息转换参数，
指定使用jackson进行对象或集合的转换，因此需要在spring-mvc.xml中进行如下配置：

    <bean id="requestMappingHandlerAdapter" class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <bean class="org.springframework.http.converter.cbor.MappingJackson2CborHttpMessageConverter"></bean>
            </list>
        </property>
    </bean>

在 SpringMVC 的各个组件中，处理器映射器、处理器适配器、视图解析器称为 SpringMVC 的三大组件。使用<mvc:annotation-driven>自动加载 RequestMappingHandlerMapping（处理映射器）和RequestMappingHandlerAdapter（处理适配器），可用在Spring-xml.xml配置文件中使用<mvc:annotation-driven>替代注解处理器和适配器的配置。同时使用<mvc:annotation-driven>默认底层就会集成jackson进行对象或集合的json格式字符串的转换。

<mvc:annotation-driven />

    @RequestMapping("/quick10")
    @ResponseBody
    public User quick10() {
        User user = new User();
        user.setUsername("lisi");
        user.setAge(56);
        return user;
    }

7.SpringMVC获得请求数据

服务器端要获得请求的参数，有时还需要进行数据的封装，SpringMVC可以接收如下类型的参数：

基本类型参数
POJO类型参数
数组类型参数
集合类型参数

7.1 获得基本类型参数

Controller中的业务方法的参数名称要与请求参数的name一致，参数值会自动映射匹配。
http://localhost:8080/itheima_springmvc1/quick9?username=zhangsan&age=12

    @RequestMapping("/quick11")
    @ResponseBody
    public void quick11(String username,int age) {
        System.out.println(username);
        System.out.println(age);
    }

7.2获得POJO类型参数

Controller中的业务方法的POJO参数的属性名与请求参数的name一致，参数值会自动映射匹配。
http://localhost:8080/itheima_springmvc1/quick9?username=zhangsan&age=12
User.java

package com.zhxd.entity;

public class User {
    private String username;
    private int age;

    public User() {
        this.username = username;
        this.age = age;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }
}

    @RequestMapping("/quick12")
    @ResponseBody
    public void quick12(User user) {
        System.out.println(user);
    }

7.3获取数组类型参数

Controller中的业务方法数组名称与请求参数的name一致，参数值会自动映射匹配。
http://localhost:8080/itheima_springmvc1/quick11?strs=111&strs=222&strs=333

    @RequestMapping("/quick13")
    @ResponseBody
    public void quick13(String[] strs) {
        System.out.println(Arrays.asList(strs));
    }

7.4获得集合类型参数

获得集合参数时，要将集合参数包装到一个POJO中才可以。
Vo.java

package com.zhxd.entity;

import java.util.List;

public class Vo {
    private List<User> userList;

    public List<User> getUserList() {
        return userList;
    }

    public void setUserList(List<User> userList) {
        this.userList = userList;
    }

    @Override
    public String toString() {
        return "Vo{" +
                "userList=" + userList +
                '}';
    }
}

提交的表单

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>form</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/user/quick14" method="POST">
        <input type="text" name="userList[0].username" value="" /><br>
        <input type="text" name="userList[0].age" value="" /><br>
        <input type="text" name="userList[1].username" value="" /><br>
        <input type="text" name="userList[1].age" value="" /><br>
        <input type="submit" name="submit" value="提交">
    </form>
</body>
</html>

SpringMVC接收表单数据

    @RequestMapping("/quick14")
    @ResponseBody
    public void quick14(Vo vo) {
        System.out.println(vo.getUserList());
    }

当使用ajax提交时，可以指定contentType为json形式，那么在方法参数位置使用@RequestBody可以
直接接收集合数据而无需使用POJO进行包装。

    @RequestMapping("/quick15")
    @ResponseBody
    public void quick15(@RequestBody List<User> userList) {//@RequestBody可以直接接收集合数据
        System.out.println(userList);
    }

使用ajax访问quick15

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script type="application/javascript" src="./js/axios.js"></script>
    <script type="application/javascript">
        var userList = new Array();
        userList.push({username:"zhangsan",age:18});
        userList.push({username:"lisi",age:28});
        console.log("${pageContext.request.contextPath}/user/quick15")
        axios({
            url:"${pageContext.request.contextPath}/user/quick15",
            method:"POST",
            headers:{
                "Content-Type":"application/json;charset=utf-8"
            },
            data:JSON.stringify(userList)
        }).then(res => {console.log(res.data)}).catch(e => {console.log(e)})
    </script>
</head>
<body>

</body>
</html>

注意：通过谷歌开发者工具抓包发现，没有加载到axios文件，原因是SpringMVC的前端控制器
DispatcherServlet的url-pattern配置的是/,代表对所有的资源都进行过滤操作，我们可以通过以下两种:

在spring-mvc.xml配置文件中指定放行的资源

<mvc:resources mapping="/js/**" location="/js/"/>

使用<mvc:default-servlet-handler/>标签：找不到对应映射地址就交由原始容器（tomcat）进行处理

7.5请求数据乱码问题

当t请求含有中文时，数据会出现乱码，我们可以设置一个过滤器来进行编码的过滤，在web.xml中进行配置

  <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>

7.6参数绑定注解@requestParam

当请求的参数名称与Controller的业务方法参数名称不一致时，就需要通过@RequestParam注解显示的绑定

http://localhost:8080/user/quick11?name=zhangsan&&age=18

    @RequestMapping("/quick11")
    @ResponseBody
    public void quick11(@RequestParam(value="name") String username, int age) {
        System.out.println(username);
        System.out.println(age);
    }

注解@RequestParam还有如下参数可以使用：

value：与请求参数名称
required：此在指定的请求参数是否必须包括，默认是true，提交时如果没有此参数则报错
defaultValue：当没有指定请求参数时，则使用指定的默认值赋值

7.7 获得Restful风格的参数

Restful是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。主要用于客户端和服务
器交互类的软件，基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存机制等。Restful风格的请求是使用“url+请求方式”表示一次请求目的的，HTTP 协议里面四个表示操作方式的动词如下：
GET：用于获取资源
POST：用于新建资源
PUT：用于更新资源
DELETE：用于删除资源
例如：
/user/1 GET ：得到 id = 1 的 user
/user/1 DELETE：删除 id = 1 的 user
/user/1 PUT：更新 id = 1 的 user
/user POST：新增 user

上述url地址/user/1中的1就是要获得的请求参数，在SpringMVC中可以使用占位符进行参数绑定。地址/user/1可以写成
/user/{id}，占位符{id}对应的就是1的值。在业务方法中我们可以使用@PathVariable注解进行占位符的匹配获取工作。
http://localhost:8080/user/quick19/zhangsan
在这里插入图片描述

7.8自定义类型转换器

SpringMVC 默认已经提供了一些常用的类型转换器，例如客户端提交的字符串转换成int型进行参数设置。
但是不是所有的数据类型都提供了转换器，没有提供的就需要自定义转换器，例如：日期类型的数据就需要自
定义转换器。

自定义类型转换器的开发步骤：

定义转换器类实现Converter接口

package com.zhxd.converter;


import org.springframework.core.convert.converter.Converter;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateConverter implements Converter<String, Date>{
    public Date convert(String dateStr) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd");
        Date date = null;
        try {
            date = simpleDateFormat.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }finally {
            return date;
        }
    }
}

在配置文件中声明转换器

    <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <list>
                <bean class="com.zhxd.converter.DateConverter"></bean>
            </list>
        </property>
    </bean>

在<annotation-driven>中引用转换器

<mvc:annotation-driven conversion-service="conversionService" />

7.9 获得Servlet相关API

SpringMVC支持使用原始ServletAPI对象作为控制器方法的参数进行注入，常用的对象如下：

HttpServletRequest
HttpServletResponse
HttpSession

    @RequestMapping("/quick18")
    public void quick18(HttpServletRequest request, HttpServletResponse response, HttpSession session) {
        System.out.println(request);
        System.out.println(response);
        System.out.println(session);
    }

7.10获得请求头

使用@RequestHeader可以获得请求头信息，相当于web阶段学习的request.getHeader(name)，@RequestHeader注解的属性如下：

value：请求头的名称
-required：是否必须携带此请求头

    @RequestMapping("/quick19")
    @ResponseBody
    public void quick19(@RequestHeader(value="User-Agent", required = true)String userAgent) {
        System.out.println(userAgent);
    }

7.11获取Cookie的值

使用@CookieValue可以获得指定Cookie的值，@CookieValue注解的属性如下：

value：指定cookie的名称
required：是否必须携带此cookie

    @RequestMapping("/quick20")
    @ResponseBody
    public void quick20(@CookieValue(value="JSESSIONID", required = false)String jsessionid) {
        System.out.println(jsessionid);
    }

7.12 文件上传

7.12.1文件上传客户端三要素

表单项type=“file”
表单的提交方式是post
表单的enctype属性是多部分表单形式，及enctype=“multipart/form-data

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>upload</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/user/qucik21" method="POST" enctype="multipart/form-data">
        名称：<input type="text" name="name" value="" /><br>
        文件：<input type="file" name="file" value="" /><br>
        <input type="submit" name="submit" value="submit" />
    </form>
</body>
</html>

7.12.2文件上传原理

当form表单修改为多部分表单时，request.getParameter()将失效。
enctype=“application/x-www-form-urlencoded”时，form表单的正文内容格式是：key=value&key=value&key=value
当form表单的enctype取值为Mutilpart/form-data时，请求正文内容就变成多部分形式：

7.12.3单文件上传的步骤

导入fileupload和io坐标

    <!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.2.2</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.4</version>
    </dependency>

配置文件上传解析器

    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!--上传文件总大小-->
        <property name="maxUploadSize" value="52428000"></property>
        <!--上传单个文件大小-->
        <property name="maxUploadSizePerFile" value="5242800"></property>
        <!--上传文件编码类型-->
        <property name="defaultEncoding" value="UTF-8"></property>
    </bean>

编写文件上传代码

    @RequestMapping("/quick21")
    @ResponseBody
    public void quick21(String name, MultipartFile file) {
        System.out.println(name);
        System.out.println(file);
    }

保存文件：

    @RequestMapping("/quick21")
    @ResponseBody
    public void quick21(String name, MultipartFile file) throws IOException {
        //获得文件名称
        String originalFilename = file.getOriginalFilename();
        //保存文件
        file.transferTo(new File( "D:\\data\\uplaod\\files/" + originalFilename));
    }

7.12.4多文件上传

多文件上传，只需要将页面修改为多个文件上传项，将方法参数MultipartFile类型修改为MultipartFile[]即可

    <form action="${pageContext.request.contextPath}/user/quick21" method="POST" enctype="multipart/form-data">
        名称：<input type="text" name="name" value="" /><br>
        文件：<input type="file" name="files" value="" multiple/><br>
        <input type="submit" name="submit" value="submit" />
    </form>

 @RequestMapping("/quick21")
 @ResponseBody
 public void quick21(String name, MultipartFile[] files) throws IOException {
     for (MultipartFile file : files) {
         //获得文件名称
         String originalFilename = file.getOriginalFilename();
         //保存文件
         file.transferTo(new File("D:\\data\\uplaod\\files\\" + originalFilename));
     }
 }