spring MVC (上)

最新推荐文章于 2022-10-16 14:18:04 发布

z咖啡不苦

最新推荐文章于 2022-10-16 14:18:04 发布

阅读量336

点赞数

本文链接：https://blog.csdn.net/www_ly/article/details/109369539

版权

本文详细介绍了SpringMVC框架，包括其在Java web开发中的角色、MVC设计模式、执行流程、核心组件、URL映射、参数绑定、请求转发与重定向以及JSON数据处理。SpringMVC简化了Web开发，提供了清晰的角色划分、灵活的扩展性和强大的数据绑定机制。此外，还展示了如何配置和使用SpringMVC环境，以及如何处理不同类型的请求和响应数据。

摘要由CSDN通过智能技术生成

1、什么是spring MVC ?
Spring MVC是Spring家族中的⼀个web成员，它是⼀种基于Java的实现了Web MVC设计思想的请求驱动类型的轻量级Web框架，即使⽤了MVC架构模式的思想，将web层进⾏职责解耦，基于请求驱动指的就是使⽤请求-响应模型，框架的⽬的就是帮助我们简化开发，Spring MVC也是要简化我们⽇常Web开发的。

2、什么叫MVC？
模型-视图-控制器(MVC)是一种很流行的框架，是⼀个以设计界⾯应⽤程序为基础的设计思想。通过把Model，View，Controller分离，把较为复杂的web应用分成逻辑清晰的几部分，是为了简化开发，减少出错。还是为了组内开发人员之间的配合。总之就是一种分层工作的办法。

3、Spring MVC能帮我们做什么?

让我们能⾮常简单的设计出⼲净的Web层；
进⾏更简洁的Web层的开发；
天⽣与Spring框架集成（如IOC容器、AOP等）；
提供强⼤的约定⼤于配置的契约式编程⽀持；
能简单的进⾏Web层的单元测试；
⽀持灵活的URL到⻚⾯控制器的映射；
⾮常容易与其他视图技术集成，如jsp、Velocity、FreeMarker等等，因为模型数据不放在特定的API⾥，⽽是放在⼀个Model⾥（Map数据结构实现，因此很容易被其他框架使⽤）；
⾮常灵活的数据验证、格式化和数据绑定机制，能使⽤任何对象进⾏数据绑定，不必实现特定框架的API；
⽀持灵活的本地化等解析；
更加简单的异常处理；
对静态资源的⽀持；
⽀持Restful⻛格

Spring MVC主要由DispatcherServlet、处理器映射、处理器(控制器)、视图解析器、视图组成。
两个核心是:
处理器映射：选择使用哪个控制器来处理请求
视图解析器：选择结果应该如何渲染

4、SpringMVC执行流程
在这里插入图片描述

⾸先⽤户发送请求,请求被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;
渲染视图并返回渲染后的视图给前端控制器。
最终前端控制器将渲染后的⻚⾯响应给⽤户或客户端

5、Spring MVC 优势

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

6、搭建spring MVC环境
开发环境：
Idea + Maven + Jdk1.8 + Jetty

pom.xml 坐标添加

<properties>
 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 <maven.compiler.source>1.8</maven.compiler.source>
 <maven.compiler.target>1.8</maven.compiler.target>
 </properties>
 <dependencies>
 <!-- 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>
 
 </dependencies> <build>
 <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>8080</port>
 </httpConnector>
 <!-- 设置项⽬路径 -->
 <webAppConfig>
 <contextPath>/springmvc01</contextPath>
 </webAppConfig>
 </configuration>
 </plugin>
 </plugins>
</build>

配置 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</filterclass>
 <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>

要想启动我们的 SpringMVC 环境，⽬前对于 mvc 框架的配置还未进⾏。以上在 web.xml 中引⽤了servlet-context.xml ⽂件。

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.xxxx.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>
</beans>

⻚⾯控制器的编写
HelloController.java

@Controller
public class HelloController {

    /**
     * 访问hello路径，返回指定视图
     * @return
     */
    @RequestMapping("/hello")
    public ModelAndView hello(){
        // 准备模型和视图
        ModelAndView modelAndView = new ModelAndView();
        // 设置数据模型
        modelAndView.addObject("msg", "Hello SpringMVC");
        // 设置视图名称
        modelAndView.setViewName("hello");
        // 返回模型与视图
        return modelAndView;
    }

}

添加视图⻚⾯
在 WEB-INF 下新建 jsp ⽂件夹，并在⽂件夹下新建 hello.jsp。浏览器无法访问WEB-INF下的文件夹，但java代码可以范文。在servlet-context.xml 中配置了

<%@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表达式接收参数值 -->
 ${msg}
 </body>
</html>

启动 jetty 服务器
在这里插入图片描述最后访问即可

这样我们的环境就OK了。

7、URL 地址映射配置
首先了解下@RequestMapping注解：
@RequestMapping 将请求地址与⽅法进⾏绑定，可以在类级别和⽅法级别声明。类级别的注解负责将⼀个特定的请求路径映射到⼀个控制器上，将 url 和类绑定；通过⽅法级别的注解可以细化映射，能够将⼀个特定的请求路径映射到某个具体的⽅法上，将 url 和类的⽅法绑定。

映射单个 URL：
@RequestMapping("") 或 @RequestMapping(value="")

/**
 * @RequestMapping 声明在⽅法上⾯，映射单个 URL
 * 访问地址：（如果有类路径需要写在⽅法路径前⾯）
 * http://ip:port/springmvc01/test01
 * @return
 */
@RequestMapping("/test01")
// @RequestMapping(value = "/test01")
public ModelAndView test01(){
 ModelAndView modelAndView = new ModelAndView();
 modelAndView.addObject("hello","test01");
 modelAndView.setViewName("hello");
 return modelAndView; }
/**
 * 路径开头是否加 斜杠"/" 均可
 * @RequestMapping("/请求路径") 与 @RequestMapping("请求路径")均可
 * 建议加上，如：@RequestMapping("/test02")
 * 访问地址：（如果有类路径需要写在⽅法路径前⾯）
 * http://ip:port/springmvc01/test02
 * @return
 */
@RequestMapping("test02")
public ModelAndView test02(){
 ModelAndView modelAndView = new ModelAndView();
 modelAndView.addObject("hello","test02");
 modelAndView.setViewName("hello");
 return modelAndView; }

映射多个 URL：
@RequestMapping({"",""}) 或 @RequestMapping(value={"",""})

/**
 * @RequestMapping 声明在⽅法上⾯，映射多个 URL
 * ⽀持⼀个⽅法绑定多个 url 的操作
 * 访问地址：（如果有类路径需要写在⽅法路径前⾯）
 * http://ip:port/springmvc01/test03_01
 * http://ip:port/springmvc01/test03_02
 * @return
 */
@RequestMapping({"/test03_01","/test03_02"})
// @RequestMapping(value = {"/test03_01","/test03_02"})
public ModelAndView test03(){
 ModelAndView modelAndView = new ModelAndView();
 modelAndView.addObject("hello","test03");
 modelAndView.setViewName("hello");
 return modelAndView;
 }

映射 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;
 }
}

设置 URL 映射的请求⽅式：
默认没有设置请求⽅式，在HTTP 请求中请求⽅法有 GET、POST、DELET、PUT、HEAD 等
可以通过 method 属性设置⽀持的请求⽅式，如method=RequestMethod.POST；如设置多种请求⽅式，以⼤括号包围，逗号隔开即可。

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

通过参数名称映射 URL：

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

8、参数绑定
基本数据类型

/**
 * 基本类型数据绑定
 * 参数值必须存在。如果没有指定参数值，也没有设置参数默认值，则会报500异常。
 * @param age
 * @param money
 */
@RequestMapping("data01")
public void data01(int age, double money){
 System.out.println("age:" + age + ", money:" + money);
}
/**
 * 基本类型数据绑定
 * 通过注解 @RequestParam 标记⼀个形参为请求参数。（注解声明在形参的前⾯）
 * 可以通过注解的属性设置相关内容
 * 设置参数的默认值 defaultValue
 * @param age
 * @param money
 */
@RequestMapping("data02")
public void data02(@RequestParam(defaultValue = "18") int age,
@RequestParam(defaultValue = "10.0") double money){
 System.out.println("age:" + age + ", money:" + money);
}
/**
* 基本类型数据绑定
 * 通过注解 @RequestParam 标记⼀个形参为请求参数。（注解声明在形参的前⾯）
 * 可以通过注解的属性设置相关内容
 * 设置参数的参数名（别名） name
 * @param age
 * @param money
 */
@RequestMapping("data03")
public void data03(@RequestParam(defaultValue = "18", name = "userAge") int age,
 @RequestParam(defaultValue = "10.0", name = "userMoney") double money){
 System.out.println("age:" + age + ", money:" + money);
}

包装类型

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

字符串类型

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

数组类型
Controller.java

/**
 * 数组类型数据绑定
 * 客户端传参形式：ids=1&ids=2&ids=3
 * @param ids
 */
@RequestMapping("/data06")
public void data06(String[] ids){
 for(String id : ids){
 System.out.println(id + "---");
 }
}

JavaBean 类型

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

User.java

public class User {

    private int id;
    private String userName;
    private String userPwd;

    private List<String>  list;

    private Map<String,String>  map;


    public int getId() {
        return id;
    }

    public void setId(int 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<String> getList() {
        return list;
    }

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

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

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

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

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>测试list</title>
</head>
<body>
<form action="/data08"  method="post">

姓名：<input   name="userName" type="text"/>
密码：<input   name="userPwd" type="text"/>
    list:<input type="text" name="list[0]"/>
        <input type="text" name="list[1]"/>
    <button type="submit">提交</button>
</form>
</body>
</html>

Set 类型
Set 和 List 类似，也需要绑定在对象上，⽽不能直接写在 Controller ⽅法的参数中。但是，绑定Set数据时，必须先在Set对象中add相应的数量的模型对象。

List 类型
Controller.java

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

User.java
在原有的JavaBean中添加一个属性private Map<String,String> map;和get、set、toString方法

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>测试map</title>
</head>
<body>
<form action="/data08"  method="post">

姓名：<input   name="userName" type="text"/>
密码：<input   name="userPwd" type="text"/>
    Map:<input type="text" name="map['bj']"/>
    <input type="text" name="map['sx']"/>
    <input type="text" name="map['sz']"/>
    <button type="submit">提交</button>
</form>
</body>
</html>

9、请求转发与重定向
重定向
重定向是发⼀个302的状态码给浏览器，浏览器⾃⼰去请求跳转的⽹⻚。地址栏会发⽣改变。
重定向以 redirect: 开头

@Controller
public class Redict {

    /**
     * 重定向到JSP⻚⾯
     * @return
     */
    @RequestMapping(value="/view01")
    public String view01(){
        return "redirect:view.jsp";  //跳转到view.jsp页面
    }

    /**
     * 重定向到JSP⻚⾯
     * 传递参数
     * @return
     */
    @RequestMapping(value = "/view02")
    public String view02(){
        return  "redirect:view.jsp?name=oyjj&pwd=121";
    }

    /**
     * 重定向到JSP⻚⾯
     * 传递参数 （传递中⽂参数会出现乱码）
     * @return
     */
    @RequestMapping(value = "/view03")
    public String view03(){
        return  "redirect:view.jsp?name=欧阳&pwd=121";
    }
    /**
     * 解决中文乱码问题
     * 重定向到JSP⻚⾯
     * 传递参数 （通过 RedirectAttributes 对象设置重定向参数，避免中⽂乱码问题）
     * @param -redirectAttributes
     * @return
     */
    @RequestMapping(value = "/view04")
    public String view04(RedirectAttributes redirectAttributes){
        redirectAttributes.addAttribute("name","欧阳");
        redirectAttributes.addAttribute("pwd","121");
        return  "redirect:view.jsp";
    }

/**
 * 重定向到JSP⻚⾯
 * 返回 ModelAndView 对象
 * @param modelAndView
 * @return
 */
@RequestMapping(value = "/view05")
    public ModelAndView view05(ModelAndView modelAndView){
        modelAndView.addObject("name","欧阳jj");
        modelAndView.addObject("pwd","121");
        modelAndView.setViewName("redirect:view.jsp");
        return modelAndView;
    }

    /**
     * 重定向到Controller
     * 返回 ModelAndView 对象
     * @param modelAndView
     * @return
     */
    @RequestMapping(value = "/view06")
    public ModelAndView view06(ModelAndView modelAndView) {
        modelAndView.addObject("uname", "admin");
        modelAndView.setViewName("redirect:hello");//重定向到Controller
        return modelAndView;
    }
}

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

@Controller
public class Forw {
    /**
     * 请求转发到JSP⻚⾯
     */
    @RequestMapping("/view07")
    public  String view07(){
        return  "forward:view01.jsp";
    }

    /**
     * 请求转发到JSP⻚⾯
     * 设置参数
     */
    @RequestMapping("/view08")
    public String view08(){
        return "forward:view01.jsp?name=欧阳&pwd=121";
    }
    /**
     * 请求转发到JSP⻚⾯
     * 设置请求域
     */
    @RequestMapping("/view09")
    public  String view09(Model model){
        model.addAttribute("name","ouyang");
        return "forward:view01.jsp";
    }

    /**
     * 请求转发到JSP⻚⾯ （默认）
    * 默认会去指定⽬录下找JSP⻚⾯ （配置⽂件中设置的）
    */
    @RequestMapping("/view10")
    public String view10(){
        return "/../../view01";
    }

    /**
     * 请求转发到 JSP⻚⾯
     * 返回 ModelAndView 对象
     * @return
     */
    @RequestMapping("/view11")
    private ModelAndView view11(ModelAndView modelAndView){
        modelAndView.addObject("name","oy");
        modelAndView.addObject("pwd","121");
        modelAndView.setViewName("forward:view01.jsp");
        return modelAndView;
    }

    /**
     * 请求转发到 Controller
     * 传递参数
     * @return
     */
    @RequestMapping("/view12")
    private ModelAndView view12(ModelAndView modelAndView) {
        modelAndView.setViewName("forward:hello");
        return modelAndView;
    }
    /**
     * 请求转发到 Controller
     * 传递参数
     * @return
     */
    @RequestMapping("/view13")
    private ModelAndView view13(ModelAndView modelAndView) {
        modelAndView.setViewName("forward:hello?name=欧阳&pwd=121");
        return modelAndView;
    }
}

设置请求域
ModelAndView 设置请求域
HttpServletRequest 设置请求域
Model 设置请求域
modelMap 设置请求域
map 设置请求域

/*
设置请求域
 */
@Controller
public class ModelController {

    /*
    ModelAndView 设置请求域
     */
    @RequestMapping("m01")
    public ModelAndView medel01(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("msg","设置请求域");
        modelAndView.setViewName("model");
        return  modelAndView;
    }

    /*
    HttpServletRequest  设置请求域
     */
    @RequestMapping("m02")
    public String medel02(HttpServletRequest request){
        //设置请求域
        request.setAttribute("msg","request请求域");
        return  "model";
    }

    /*
    Model 设置请求域
     */
    @RequestMapping("m03")
    public String medel03(Model model){
        //设置请求域
        model.addAttribute("msg","model请求域");
        return  "model";
    }

    /*
    modelMap 设置请求域
     */
    @RequestMapping("m04")
    public String medel04(ModelMap modelMap){
        //设置请求域
        modelMap.addAttribute("msg","modelMap请求域");
        return  "model";
    }

    /*
    map 设置请求域
     */
    @RequestMapping("m05")
    public String medel05(Map map){
        //设置请求域
        map.put("msg","Map请求域");
        return  "model";
    }
}

10、JSON 数据开发

@ResponseBody
该注解⽤于将 Controller 的⽅法返回的对象，通过适当的 HttpMessageConverter 转换为指定格式后，写⼊到 Response 对象的 body 数据区。返回的数据不是 html 标签的⻚⾯，⽽是其他某种格式的数据时（如 json、xml 等）使⽤（通常⽤于ajax 请求）。
@RequestBody
该注解⽤于读取 Request 请求的 body 部分数据，使⽤系统默认配置的 HttpMessageConverter 进⾏解析，然后把相应的数据绑定到要返回的对象上，再把 HttpMessageConverter 返回的对象数据绑定到controller 中⽅法的参数上。

使用这两个注解前需要添加相关依赖
pom.xml

<!-- 添加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>

修改配置文件
servlet-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>

注解的使用
@ResponseBody两种使用方式

@Controller
public class JsonController {

    /**
     * @ResponseBody 表示响应数据，不做页面转发操作。
     *  将响应的数据转化成JSON格式的字符串
     *  注解可以设置在方法级别
     * @return
     */
    @RequestMapping("/queryUser01")
    @ResponseBody
    public User queryUser01(){
        User user = new User();
        user.setId(1);
        user.setUserName("oyjj");
        user.setUserPwd("aaa");
        return  user;
    }

    /**
     * 注解可以设置在修饰符之后，返回类型前
     * @return
     */
    @RequestMapping("/queryUser02")
    public  @ResponseBody User queryUser02(){
        User user = new User();
        user.setId(1);
        user.setUserName("oyjj");
        user.setUserPwd("aaa");
        return  user;
    }
    /**
     * 响应List集合
     * @return
     */
    @RequestMapping("/queryUserlist")
    @ResponseBody
    public List<User> queryUserList(){
        List<User> list = new ArrayList<>();
        User user = new User();
        user.setId(1);
        user.setUserName("oyjj");
        user.setUserPwd("aaa");
        list.add(user);
        return  list;
    }

    /**
     * 直接显示字符串
     * @return
     */
    @RequestMapping("test")
    @ResponseBody
    public String user(){
        return  "test";
    }

前端接收
需要导入JQuery的包
json.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>json</title>
</head>
<body>

<script src="js/jquery-3.5.1.min.js" type="text/javascript"></script>
<script type="text/javascript">
    $.ajax({
        type:"get",                  //请求方式
        url:"queryUserlist",        //请求路径
        data:{                      //请求参数：传递给服务端的参数
            username:"oyjj",
            userPwd:"121"
        },
        dataType:"json",            //预期服务端返回的参数的数据类型
        success:function(result){   //回调函数：接收服务端响应的结果
            console.log(result);
        }
    });
</script>  
</body>
</html>

@RequestBody

@Controller
public class JsonController {
    /**
     * @RequestBody 表示接收的参数类型是JSON格式的字符串
     *  声明在形参前
     *  @RequestBody接收的是一个 json 格式的字符串，一定是一个字符串。
     *
     * @param user
     * @return
     */
    @RequestMapping("/testUser")
    @ResponseBody
    public  User testUser(@RequestBody User user ){

        return  user;
    }

}

前端接收
json.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>json</title>
</head>
<body>

<script src="js/jquery-3.5.1.min.js" type="text/javascript"></script>
<script type="text/javascript">

    $.ajax({
        type:"post",
        url:"testUser",
        data:'{"userName":"oy","userPwd":"123456"}',
        // 设置服务器请求类型的数据类型为JSON格式
        contentType: "application/json;charset=utf-8",
        success:function (result) {
            console.log(result);
        }
    });
</script>
</body>
</html>

总结一下JSON数据开发
@ResponseBody
表示方法响应的是数据。
如果响应的是字符串，直接输出，如果响应的是JavaBean或者对象，则会将对应的对象转换成JSON格式的字符串响应
该注解声明在方法上或方法返回类型前，修饰符后
@RequestBody
表示接收的参数是一个JSON格式的字符串，必须是字符串。
用来处理来处理 application/json 类型字符串
该注解声明在方法形参前

如果是ajax请求
       需要在方法行添加@ResponseBody注解，表示方法返回的数据会被ajax的回调函数接收
       如果方法形参设置了@RequestBody注解
        1. ajax传递参数时，不能使用json对象，需要将对象设置为JSON格式字符串
        2. JSON格式字符串必须是标准的JSON格式
        3. 设置请求类型 contentType: "application/json;charset=utf-8",