SpringMVC与JSON数据开发

夂992

于 2023-04-14 22:12:58 发布

阅读量193

点赞数

文章标签： spring java

本文链接：https://blog.csdn.net/weixin_67969747/article/details/130160514

版权

SpringMVC 与 JSON数据开发

1. 学习目标

在这里插入图片描述

2. Spring思想 & SpringMVC框架概念与特点

2.1. 什么叫MVC?

模型-视图-控制器（mvc）是一个众所周知的以设计为基础的设计思想。它主要通过分离模型、视图及控制器在应用程序中的角色将业务逻辑从界面中解耦。通常，模型负责封装应用程序数据在视图层显示。视图仅仅只是展示这些数据，不包含任何业务逻辑。处理后后台业务层可能会返回了一些数据在视图层展示。控制器收集这些数据及准备模型在视图层展示。mvc模式的核心思想是将业务逻辑从界面中分离出来，允许它们单独改变而不会互相影响。
在这里插入图片描述

2.2. 常见MVC框架运行性能比较

Jsp+servlet > struts1 > spring mvc > struts2+freemarker > struts2,ognl,值栈。
开发效率上,基本正好相反。值得强调的是，spring mvc开发效率和struts2不相上下，但从目前来看，
spring mvc 的流行度已远远超过struts2。

2.3. Spring MVC是什么？

Spring MVC是Spring家族中的一个web成员，它是一种基于Java的实现了Web MVC设计思想的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模式，框架的目的就是帮助我们简化开发，Spring MVC也是要简化我们日常web开发的。
Spring MVC是服务到工作者思想的实现。前端控制器是DispatcherServlet；应用控制器拆为处理器映射
器(Handler Mapping)进行处理器管理和视图解析器(View Resolver)进行视图管理；支持本地化/国际化
（Locale）解析及文件上传等；提供了非常灵活的数据验证、格式化和数据绑定机制；提供了强大的约
定大于配置（惯例优先原则）的契约式编程支持。

2.4. Spring MVC能帮我们做什么？

让我们能非常简单的设计出干净的Web层；
进行更简洁的Web层开发
天生与Spring框架集成（如IOC容器、AOP等）
提供强大的约定大于配置的契约式编程支持
能简单的进行Web层的单元测试
支持灵活的URL到页面控制器的映射
非常容易与其他视图技术集成，如jsp、Velocity、
FreeMarker等等，因为模型数据不放在特定的API
里，而是放在一个Model里
非常灵活的数据验证、格式化和数据绑定机制，能使用任何对象进行数据绑定，不必实现特定框架的API
支持灵活的本地化等解析
更加简单的异常处理
对静态资源的支持
支持Restful风格

3. SpringMVC请求流程 & 环境搭建

3.1. Spring MVC请求处理流程分析

在这里插入图片描述
Spring MVC框架也是一个基于请求驱动的Web框架，并且使用了前端控制器模式（是用来提供一个集中
的请求处理机制，所有的请求都将由一个单一的处理程序处理来进行设计，再根据请求映射规则分发给
相应的页面控制器（动作/处理器）进行处理。首先让我们整体看一下Spring MVC处理请求的流程：

首先用户发送请求,请求被SpringMvc前端控制器（DispatherServlet）捕获；
前端控制器(DispatherServlet)对请求URL解析获取请求URI,根据URI, 调用HandlerMapping；
前端控制器(DispatherServlet)获得返回的HandlerExecutionChain（包括Handler对象以及Handler对
象对应的拦截器）；
DispatcherServlet 根据获得的HandlerExecutionChain，选择一个合适的HandlerAdapter。（附注：
如果成功获得HandlerAdapter后，此时将开始执行拦截器的preHandler(…)方法）；
HandlerAdapter根据请求的Handler适配并执行对应的Handler；HandlerAdapter(提取Request中的模
型数据，填充Handler入参，开始执行Handler（Controller)。在填充Handler的入参过程中，根据配
置，Spring将做一些额外的工作：
HttpMessageConveter：将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定
的响应信息。
数据转换：对请求消息进行数据转换。如String转换成Integer、Double等数据格式化：
数据格式化。如将字符串转换成格式化数字或格式化日期等
数据验证：验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中）
Handler执行完毕，返回一个ModelAndView(即模型和视图)给HandlerAdaptor
HandlerAdaptor适配器将执行结果ModelAndView返回给前端控制器。
前端控制器接收到ModelAndView后，请求对应的视图解析器。
视图解析器解析ModelAndView后返回对应View;
渲染视图并返回渲染后的视图给前端控制器。
11、最终前端控制器将渲染后的页面响应给用户或客户端

3.2. Spring MVC优势

清晰的角色划分：前端控制器（DispatcherServlet）、请求到处理器映射（HandlerMapping）、处
理器适配器（HandlerAdapter）、视图解析器（ViewResolver）、处理器或页面控制器
（Controller）、验证器（ Validator）、命令对象（Command 请求参数绑定到的对象就叫命令对
象）、表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象）。
分工明确，而且扩展点相当灵活，可以容易扩展，虽然几乎不需要
和Spring其他框架无缝集成，是其他Web框架所不具备的
可适配，通过HandlerAdapter可以支持任意的类作为处理器
可定制型，HandlerMapping ViewResolver等能够非常简单的定制
功能强大的数据验证、格式化、绑定机制
利用Spring提供的Mock对象能够非常简单的进行Web层单元测试
本地化、主题的解析的支持，使我们更容易进行国际化和主题的切换
强大的JSP标签，使JSP编写更容易

3.3. Spring MVC环境搭建

3.3.1. 开发环境

Idea + Maven + Jdk1.8 + Jeetty

3.3.2. 新建 Maven WebApp

Idea 下创建 springmvc工程

3.3.3. pom.xml坐标添加

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.liuxidong</groupId>
  <artifactId>Spring_mvc01</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>Spring_mvc01 Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

    <!-- spring web -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>
    <!-- spring mvc -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>
    <!-- web servlet -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
    </dependency>

    <!-- 添加json 依赖jar包 -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.14.2</version>
    </dependency>

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

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.14.2</version>
    </dependency>

  </dependencies>
  <build>
    <finalName>Spring_mvc01</finalName>
    <plugins>
      <!-- 编译环境插件 -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.3.2</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
      <!-- jetty插件 -->
      <plugin>
        <groupId>org.eclipse.jetty</groupId>
        <artifactId>jetty-maven-plugin</artifactId>
        <version>9.4.27.v20200227</version>
        <configuration>
          <scanIntervalSeconds>10</scanIntervalSeconds>
          <!-- 设置端口 -->
          <httpConnector>
            <port>8083</port>
          </httpConnector>
          <!-- 设置项目路径 -->
          <webAppConfig>
            <contextPath>/</contextPath>
          </webAppConfig>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

3.3.4. 配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="3.0"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
  <!-- 编码过滤 utf-8 -->
  <filter>
    <description>char encoding filter</description>
    <filter-name>encodingFilter</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>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
        <!-- servlet请求分发器 -->
<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:servlet-context.xml</param-value>
</init-param>
<!-- 表示启动容器时初始化该Servlet -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springMvc</servlet-name>
<!-- 这是拦截请求， "/"代表拦截所有请求，"*.do"拦截所有.do请求 -->
 <url-pattern>/</url-pattern>
<!--<url-pattern>*.do</url-pattern>-->
</servlet-mapping>
        </web-app>

3.3.5. servlet-context.xml配置

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
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">
    <!-- 开启扫描器 -->
    <context:component-scan base-package="com.liuxidong.springmvc.controller"/>
    <!-- 使用默认的 Servlet 来响应静态文件 -->
    <mvc:default-servlet-handler/>
    <!-- 开启注解驱动-->
    <mvc:annotation-driven/>
    <!-- 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 前缀：在WEB-INF目录下的jsp目录下 -->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!-- 后缀：以.jsp结尾的资源 -->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- mvc 请求映射 处理器与适配器配置 -->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter" />
            <bean
                    class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" />
        </mvc:message-converters>
    </mvc:annotation-driven>
</beans>

3.3.6. 页面控制器的编写

/**
 * @author lxd
 *  页面控制器
 * #Description HelloController
 * #Date: 2023/4/14 10:36
 */
@Controller
public class HelloController {

    /** @Author lxd
     *  请求映射地址
     * @Param
     * @return
     **/
    @RequestMapping("/hello")
    public ModelAndView hello(){
        ModelAndView modelAndView = new ModelAndView();
        // 设置数据
        modelAndView.addObject("hello","Hello Spring MVC");
        // 设置视图名称
        modelAndView.setViewName("hello");
        return modelAndView;
    }
}

3.3.7. 添加视图页面

<%--
  Created by IntelliJ IDEA.
  User: 86131
  Date: 2023/4/14
  Time: 10:41
  To change this template use File | Settings | File Templates.
--%>
<%@page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
    String path = request.getContextPath();
    String basePath =
            request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML>
<html>
<head>
    <base href="<%=basePath %>">
    <title>My JSP 'hello.jsp' starting page</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
</head>
<body>
<!-- el表达式接收参数值 -->
${hello}
</body>
</html>

3.3.8. 启动jetty服务器

在这里插入图片描述

4. URL地址映射配置 & 参数绑定

4.1. URL地址映射配置之@RequestMapping

通过注解@RequestMaooing将请求与方法进行绑定，可以在类级别和方法级别声明。类基本的注解负责将一个特定的请求路径映射到一个控制器上，将url和类绑定；通过方法级别的注解可以细化映射，能够将一个特定的请求路径映射到某个具体的方法上，将url和类的方法绑定。

4.1.1. 映射单个URL

@RequestMapping(“”)&@RequestMapping(value = “”)

    /**
     * 路径开头是否加 斜杠"/" 均可
     *       @RequestMapping("/请求路径") 与 @RequestMapping("请求路径")均可
     *       建议加上，如：@RequestMapping("/test02")
     *               访问地址：（如果有类路径需要写在方法路径前面）
     *                  http://ip:port/springmvc01/test02
     * @return
     */
    @RequestMapping("test01")
    public ModelAndView test01(){
        ModelAndView modelAndView = new ModelAndView();
        // 设置数据
        modelAndView.addObject("hello","test01");
        // 设置视图名称
        modelAndView.setViewName("hello");
        return modelAndView;
    }

4.1.2. 映射多个URL

@RequestMapping({“”,“”}) 或 @RequestMapping(value={“”,“”})

/**
     *   @RequestMapping 声明在方法上面，映射多个 URL
     *      支持一个方法绑定多个 url 的操作
     *          访问地址：（如果有类路径需要写在方法路径前面）
     *              http://ip:port/springmvc01/test03_01
     *              http://ip:port/springmvc01/test03_02
     * @return
     */
/*
    @RequestMapping({"test02_01", "test02_02"})
*/
    @RequestMapping(value = {"test02_01", "test02_02"})
    public ModelAndView test02(){
        ModelAndView modelAndView = new ModelAndView();
        // 设置数据
        modelAndView.addObject("hello","test02");
        // 设置视图名称
        modelAndView.setViewName("hello");
        return modelAndView;
    }

4.1.3. 映射URL在控制器上

用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径

@Controller
@RequestMapping("/url")
public class UrlController {
/**
* @RequestMapping 声明在类上面，类中的的方法都是以该地址作为父路径
* 声明级别：
* 类级别 + 方法级别 （/类路径/方法路径）
* 访问地址：
* http://ip:port/springmvc01/url/test04
* @return
*/
@RequestMapping("/test04")
public ModelAndView test04(){
ModelAndView modelAndView = new ModelAndView();
modelAndView.addObject("hello","test04");
modelAndView.setViewName("hello");
return modelAndView;
}
}

4.1.4. 设置URL映射的请求方式

默认没有设置请求方式，在HTTP请求中最常用的请求方法是GET,POST，还有其他的一些方法，如：DELET,PUT,HEAD等。
可以通过method属性设置支持的请求方式，如method-RequestMethod.POST；如果设置多种请求方式，以大括号包围，逗号隔开即可。

/**
     *       设置请求方式
     *          通过 method 属性设置方法支持的请求方式，默认 GET请求和 POST等请求都支持。
     *          设置了请求方式，则只能按照指定的请求方式请求。
     *              访问地址：（只能使用POST请求访问）
     *              http://ip:port/springmvc01/url/test05
     * @return
     */
    @RequestMapping(value = "test04",method = RequestMethod.POST)
    public ModelAndView test04(){
        ModelAndView modelAndView = new ModelAndView();
        // 设置数据
        modelAndView.addObject("hello","test04");
        // 设置视图名称
        modelAndView.setViewName("hello");
        return modelAndView;
    }```

####  4.1.5. 通过参数名称映射URL

```java
/**
     *  通过参数名称访问
     *  通过参数的形式访问
     *       访问地址：
     *           http://ip:port/springmvc01/url?test06
     * @return
     */
    @RequestMapping(params = "test03")
    public ModelAndView test03(){
        ModelAndView modelAndView = new ModelAndView();
        // 设置数据
        modelAndView.addObject("hello","test03");
        // 设置视图名称
        modelAndView.setViewName("hello");
        return modelAndView;
    }```

###  4.2. 参数绑定
客户端请求的参数到控制器功能处理方法上的参数的绑定，对于参数绑定非常灵活
####  4.2.1. 基本数据类型

```java
**
     * 基本类型数据绑定
     * 参数值必须存在。如果没有指定参数值，也没有设置参数默认值，则会报500异常。
     * @param age
     * @param money
     */
    @RequestMapping("date01")
    public void test01(int age , int money){
        System.out.println("age: " + age + "  money: " + money);
    }

    /**
     * 基本类型数据绑定
     * 通过注解 @RequestParam 标记一个形参为请求参数。（注解声明在形参的前面）
     * 可以通过注解的属性设置相关内容
     * 设置参数的默认值 defaultValue
     * @param age
     * @param money
     */
    @RequestMapping("date02")
    public void test02(@RequestParam(defaultValue = "10") int age ,
                       @RequestParam(defaultValue = "20") int money){
        System.out.println("age: " + age + "  money: " + money);
    }

    /**
     * 基本类型数据绑定
     * 通过注解 @RequestParam 标记一个形参为请求参数。（注解声明在形参的前面）
     * 可以通过注解的属性设置相关内容
     * 设置参数的参数名（别名） name
     * @param age
     * @param money
     */
    @RequestMapping("date03")
    public void test03(@RequestParam(defaultValue = "10" , name = "userAge") int age ,
                       @RequestParam(defaultValue = "20" , name = "userMoney")int money){
        System.out.println("age: " + age + "  money: " + money);
    }

4.2.2. 包装类型

 /**
     * 包装类型数据绑定 （如果数据是基本类型，建议使用包装类型）
     * 客户端请求参数名与方法形参名保持一致，默认参数值为null
     * 可以通过 @RequestParam 的name属性设置参数的别名，defaultValue属性设置参数默认值
     * @param age
     * @param money
     */
    @RequestMapping("date04")
    public void test04(Integer age , Integer money){
        System.out.println("age: " + age + "  money: " + money);
    }

4.2.3. 字符串类型

/**
     * 字符串数据绑定
     * 客户端请求参数名与方法形参名保持一致，默认参数值为null
     * 可以通过 @RequestParam 的name属性设置参数的别名，defaultValue属性设置参数默认值
     * @param userName
     * @param userPwd
     */
    @RequestMapping("date05")
    public void test05(String userName , String userPwd){
        System.out.println("userName: " + userName + "  userPwd: " + userPwd);
    }

4.2.4. 数组类型

  /**
     * 数组类型数据绑定
     * 客户端传参形式：str=rap&str=dance
     * @param str
     */
    @RequestMapping("date06")
    public void test06(String[] str){
        for (String s:str) {
            System.out.println("s: " + s + "---");
        }
    }

4.2.5. JavaBean类型

package com.liuxidong.springmvc.po;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author lxd
 * #Description User
 * #Date: 2023/4/14 15:14
 */
public class User {
    private Integer id;
    private String userName;
    private String userPwd;
    private List<Integer> list;
    private Map<Integer, String> map = new HashMap<Integer, String>();

    public Map<Integer, String> getMap() {
        return map;
    }

    public void setMap(Map<Integer, String> map) {
        this.map = map;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserPwd() {
        return userPwd;
    }

    public void setUserPwd(String userPwd) {
        this.userPwd = userPwd;
    }

    public List<Integer> getList() {
        return list;
    }

    public void setList(List<Integer> list) {
        this.list = list;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", userPwd='" + userPwd + '\'' +
                ", list=" + list +
                ", map=" + map +
                '}';
    }
}



    /**
     * JavaBean 数据绑定
     * 客户端请求的参数名与JavaBean对象的属性字段名保持一致
     * @param user
     */
    @RequestMapping("date07")
    public void test07(User user){
        System.out.println(user);
    }

4.2.6. List类型

 /** @Author lxd
     * List集合类型 数据绑定
     *      注：集合类型的数据 使用JavaBean对象进行包装
     * @Param
     * @return
     **/

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

5. 请求转发与重定向的问题

SpringMVC 默认采用服务器内部转发的形式展示页面信息。同样也支持重定向页面。

5.1. 重定向

重定向是发一个302的状态码给浏览器，浏览器自己去请求跳转的网页。地址栏会发生改变。
重定向以 redirect: 开头

/**
 * @author lxd
 *      重定向到JSP页面
 * #Description ViewController
 * #Date: 2023/4/14 16:27
 */
@Controller
public class ViewController {
    @RequestMapping("/view01")
    public String test01(){
        return "redirect:view.jsp";
    }

    /**
     * 重定向到JSP页面
     * 传递参数
     * @return
     */
    @RequestMapping("/view02")
    public String test02(){
        return "redirect:view.jsp?userName=admin&userPwd=12345";
    }

    /**
     * 重定向到JSP页面
     * 传递参数 （通过 RedirectAttributes 对象设置重定向参数，避免中文乱码问题）
     * @param redirectAttributes
     * @return
     */
    @RequestMapping ("/view03")
    public String test03(RedirectAttributes redirectAttributes){
        redirectAttributes.addAttribute("userName","赵丽颖");
        redirectAttributes.addAttribute("userPwd","123456");
        return "redirect:view.jsp";
    }

    /**
     * 重定向到JSP页面
     * 返回 ModelAndView 对象
     * @param modelAndView
     * @return
     */
    @RequestMapping("/view04")
    public ModelAndView test04(ModelAndView modelAndView){
        modelAndView.addObject("userName","赵丽颖");
        modelAndView.addObject("userPwd","123456");
        modelAndView.setViewName("redirect:view.jsp");
        return modelAndView;
    }

    /**
     * 重定向到Controller
     * 返回 ModelAndView 对象
     * @param modelAndView
     * @return
     */
    @RequestMapping("/view05")
    public ModelAndView test05(ModelAndView modelAndView){
        modelAndView.addObject("userName","赵丽颖");
        modelAndView.addObject("userPwd","123456");
        modelAndView.setViewName("redirect:test");
        return modelAndView;
    }

5.2. 请求转发

请求转发，直接调用跳转的页面，让它返回。对于浏览器来说，它无法感觉服务器有没有forward。地
址栏不发生改变。可以获取请求域中的数据。
请求转发以 forward: 开头

  /**
     * 请求转发到JSP页面
     */
    @RequestMapping("/view06")
    public String test06(){
        return "forward:view.jsp";
    }

    /**
     * 请求转发到JSP页面
     * 设置参数
     */
    @RequestMapping("view07")
    public String test07(){
        return "forward:view.jsp?userName=赵丽颖&userPwd=26";
    }

    /**
     * 请求转发到JSP页面
     * 设置请求域
     */
    @RequestMapping("view08")
    public String test08(Model model){
        model.addAttribute("userName","赵丽颖");
        model.addAttribute("userPwd","26");
        return "forward:view.jsp";
    }

    /**
     * 请求转发到JSP页面 （默认）
     * 默认会去指定目录下找JSP页面 （配置文件中设置的）
     */
    @RequestMapping("/view09")
    public String test09(){
        return "/../../view";
    }
}

6. Spring开发与JSON数据开发

6.1. 基本概念

Json 在企业开发中已经作为通用的接口参数类型，在页面（客户端）解析很方便。SpringMVC 对于json
提供了良好的支持，这里需要修改相关配置，添加 json 数据支持功能

6.1.1. @ResponseBody

该注解用于将 Controller 的方法返回的对象，通过适当的 HttpMessageConverter 转换为指定格式后，写
入到 Response 对象的 body 数据区。
返回的数据不是 html 标签的页面，而是其他某种格式的数据时（如 json、xml 等）使用（通常用于
ajax 请求）。

6.1.2. @RequestBody

该注解用于读取 Request 请求的 body 部分数据，使用系统默认配置的 HttpMessageConverter 进行解
析，然后把相应的数据绑定到要返回的对象上，再把 HttpMessageConverter 返回的对象数据绑定到
controller 中方法的参数上

6.2. 使用配置

6.2.1. pom.xml添加json坐标

<!-- 添加json 依赖jar包 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.10.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.10.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.10.0</version>
</dependency>

6.2.2. 修改servle-context.xml

<!-- mvc 请求映射 处理器与适配器配置 -->
<mvc:annotation-driven>
<mvc:message-converters>
<bean class="org.springframework.http.converter.StringHttpMessageConverter" />
<bean
class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" />
</mvc:message-converters>
</mvc:annotation-driven

6.2.3. 注解使用

6.2.3.1. @ResponseBody

 /**
         * @ResponseBody 返回的是JOSN格式的数据，返回JavaBean对象
         * 注解设置在方法体上
         * @return
         */

        @RequestMapping("/query01")
        @ResponseBody
        public User queryUser01(){
            User user = new User();
            user.setId(1);
            user.setUserName("赵丽颖");
            user.setUserPwd("知否知否应是绿肥红瘦");
            return user;
        }

    /**
     * @ResponseBody 返回的是JOSN格式的数据，返回JavaBean对象
     * 注解设置在方法返回对象前，修饰符之后
     * @return
     */
    @RequestMapping("/query02")
    public @ResponseBody User query02(){
        User user = new User();
        user.setId(2);
        user.setUserName("赵丽颖");
        user.setUserPwd("风吹半夏");
        return user;
    }

    /**
     * @ResponseBody 返回的是JOSN格式的数据，返回集合
     * @return
     */
    @RequestMapping("/query03")
    @ResponseBody
    public List<User> query03(){
        ArrayList<User> list = new ArrayList<>();
        User user = new User();
        user.setId(1);
        user.setUserName("赵丽颖");
        user.setUserPwd("知否知否应是绿肥红瘦");

        User user1 = new User();
        user1.setId(2);
        user1.setUserName("赵丽颖");
        user1.setUserPwd("风吹半夏");

        list.add(user);
        list.add(user1);
        return list;
    }

6.2.3.2. @RequestBody

@RequestBody 注解常用来处理 content-type 不是默认的 application/x-www-form-urlcoded 类型的内
容，比如说：application/json 或者是application/xml 等。一般情况下来说常用其来处理 application/json
类型。@RequestBody接受的是一个 json 格式的字符串，一定是一个字符串。
通过 @RequestBody 可以将请求体中的 JSON 字符串绑定到相应的 bean 上，当然，也可以将其分别绑
定到对应的字符串上。

  /**
     * @RequestBody 规定请求的参数是JOSN格式的字符串
     * 注解设置在形参前面
     * @param user
     * @return
     */
    @RequestMapping("/getUser")
    @ResponseBody
    public User getUser(@RequestBody User user){
        System.out.println(user);
        return user;
    }