SpringMVC | SpringMVC中的 “JSON数据交互“ 和 “RESTful设计风格“

作者简介 ：一只大皮卡丘，计算机专业学生，正在努力学习、努力敲代码中! 让我们一起继续努力学习！

该文章参考学习教材为：
《Java EE企业级应用开发教程 (Spring + Spring MVC +MyBatis)》 黑马程序员 / 编著
文章以课本知识点 + 代码为主线，结合自己看书学习过程中的理解和感悟 ，最终成就了该文章

文章用于本人学习使用 ， 同时希望能帮助大家。
欢迎大家点赞👍 收藏⭐ 关注💖哦！！！

（侵权可联系我，进行删除，如果雷同，纯属巧合）

---

​

SpringMVC 在数据绑定 的过程中，需要对 传递数据的格式 和 类型 进行 转换 ，它 既可以转换String 类型的数据，也能够 转换 JSON 等其他类型的数据。

一、JSON 数据交互

JSON 是近几年才流行的一种新的数据格式，它与 XML 非常相似，都是用于存储数据的；但 JSON 相对于 XML来说，解析速度更快，占用空间更小。因此在实际开发中，使用JSON 格式的数据进行前后台的数据交互是很常见的。

1.1 JSON概述

• JSON ( JavaScript Object Notation ，JS对象标记 ) 是一种 轻量级 的 数据交换格式。它是 基于 JavaScript 的一个 子集 ( JSON 是 JavaScript 的子集 )，使用了 C、C++、C#、Java、JavaScript、Perl、Python 等其他语言的约定，采用 完全独立于编程语言的文本格式来存储和表示数据。这些特性使 JSON 成为理想的数据交互语言，它易于阅读和编写，同时也易于机器解析和生成。

• 与 XML 一样，JSON 也是基于纯文本的数据格式。可以使用 JSON 传输一个简单的String、Number、Boolean，也可以传输一个数组或者一个复杂的 Object 对象。

1.2 JSON的“数据结构”

• JSON 有如下 两种数据结构 ：

  ①对象结构 ②数组结构

对象结构

• 对象结构 以 “{” 开始，以 “}” 结束。中间部分 由0个或多个以英文逗号 “,” 分隔的 name/value对 构成，name 和 value 之间以英文冒号 “:” 分隔。 （以 { }开始和结束，中间由0个或多个 name:value,name:value 对构成，name 和value之间用 : 分隔 ）

  例子如 ：
  {“id”:111,“name”:“张三”} ,这个就是 JSON的“数据结构”中的对象结构”。（name必须为String类型，value就不限制一定得是String类型。）

• JSON “对象结构” 的“存储形式” 下图所示 :
  

• JSON “对象结构” 的语法结构代码如下 ：

  {
    key1:value1,
    key2:value2,
    ...
  }
  ps : key必须为String类型，value不一定得是String类型
  

  其中关键字 (key )必须为String 类型，值( value )可以是 String、Number、Object、Array等数据类型。例如，一个address 对象包含城市、街道、邮编等信息，使用JSON的表示形式如下 ：

  { "city":"beijing","street":"Xisanqi","postcode":10096}
  

数组结构

• 数组结构以 “[” 开始，以 “]” 结束。中间部分由0个或多个以英文逗号 “,” 分隔的值的列表组成。
  （value 值 之间用英文逗号 , 进行 分隔 ）

• JSON “数组结构” 的“存储形式” 下图所示 :
  

• JSON “数组结构” 的语法结构代码如下 ：

  [
    value1,
    value2,
    ...
  ]
  ps1 : value可以是Spring、Number、Boolean、null等数据类型
  ps2 : value之间用英文逗号, 进行分隔
  

  value 可以是Spring、Number、Boolean、null等数据类型，例如 ：

  ["abc",123,flase,null]
  

• 上述 两种 数据结构 ( 对象结构、数组结构 )也可以分别组合构成更为复杂的数据结构。例如 : 一个
  person对象包含 name、hobby 和 address 对象 ，其代码表现形式如下 :
  （要实现这个例子中的JSON数据表示，要用到数据结构中的 “对象结构” 和 “数组结构” 这两种数据结构）

  //“对象结构”中嵌套了“数组结构” 和 “对象结构”
  {
    "name":"张三",
    "hobby":["唱","跳","rap"],
    "address":{
       "city":"Beijing,
        "street","Xisanqi",
        "postcode":10096
     }
  }
  

  需要注意的是，如果使用 JSON存储单个数据 (如 “abc”)，一定要使用 数组结构的形式，不要使用 对象结构，因为 对象结构 必须是“ 名称:值”的形式。

1.3 JSON的“数据转换”

• 为了实现浏览器与 控制器类(Controller) 之间的数据交互，Spring 提供了一个 HttpMessageConverter<T>接口 来完成此项工作。该接口主要用于将请求信息中的数据 “转换”为一个类型为 T 的对象，并将类型为T的对象绑定到请求方法的 参数 中，或者将 对象 转换为 响应信息 传递给 浏览器显示。

• Spring 为 HttpMessageConverter<T>接口提供了很多实现类，这些实现类可以对不同类型的数据进行信息转换。其中 MappingJackson2HttpMessageConverter 是SpringMVC 默认处理JSON 格式请求响应的 实现类。该实现类利用 Jackson 开源包读写 JSON 数据，将Java对象转换为JSON对象和 XML 文档，同时也可以将JSON 对象和 XML文档转换为 Java对象。

• 要使用MappingJackson2HttpMessageConverter对数据进行转换。
  (可通过 <mvc:annotation-driven/>来自动配置 : MappingJackson2HttpMessageConverter转换器 )
  （通过该转换器来将后端的对象类型的返回值，转换为JSON格式数据响应给前端 ）

JSON数据转换 要使用Jackson的开源包 ( 需要JAR ) ：
① jackson-annotations.jar : JSON转换注解包。
② jackson-core.jar : JSON转换核心包。
③ jackson-databind.jar : JSON 转换的数据绑定包。

JSON数据转换中的Jackson所需JAR (百度网盘)

也可通过 “http://mvnrepository.com/artifact/com.fasterxml.jackson.core” 地址自行下载JAR。

• 在使用 注解式开发时，需要用到两个重要的 JSON 格式转换注解，分别为@RequestBody 和 @ResponseBody，两个与“JSON格式转换”有关的注解描述如下 ：

注解	说明
@RequestBody	用于将 请求体 中的 数据绑定 到 方法 的 形参 中。该注解 用在方法 的 形参 上。该注解用在 “方法的形参”上。 如 ： 将前端传来的JSON类型的参数，转换为User类型，后赋值入该指定的形参中。 （该注解的作用并不局限与为JSON数据转换服务，其本质是，将请求体中的数据绑定到方法的形参中 ，但简单类型的参数绑定不一定要用到该注解，复杂参数绑定可考虑用该注解）
@ResponseBody	该注解 一般用在 方法 上 或 类上。 将方法的“返回值” 自动转换为“指定的格式”，然后 响应给"前端"。 ps : ① 如果方法的 返回值 是一个 “字符串”，那么这个字符串会直接写入响应体中； ② 如果 返回值 是一个 “对象”，SpringMVC会 默认使用MappingJackson2HttpMessageConverter（在Spring 4.x版本后）将 对象 转换为 JSON格式的字符串，然后 写入响应体 中（响应给前端）。
@ResponseBody	作用 ： 将方法的返回值转换为指定类型存入到"响应体"中响应给前端 ① 如果返回值为String类型，这个字符串会直接写入"响应体"中响应给前端( 不使用该注解时，String类型的返回值可以返回一个视图页面的，但现在没这个效果了 )。 ② 如果返回值为"对象类型"，会默认采用 MappingJackson2HttpMessageConverter 将该对象转换为"JSON格式的字符串"，后写入"响应体"中响应给前端。

用 <mvc:annotation-driven/>的方式 来“自动配置” MappingJackson2HttpMessageConverter转换器 (来完成JSON数据转换)

用 <mvc:annotation-driven/> 来 “自动配置”MappingJackson2HttpMessageConverter转换器 来完成 JSON数据转换 例子如 : （前端传递JSON数据给后端，后端响应JSON格式数据给“前端”） :

第一步、导入依赖 ：

JSON交互中的所需的各种JAR)

第二步、编写JSON数据交互的各种文件 ：

该 JSON数据交互 的“项目结构” :

web.xml :

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
      version="4.0">


 <!--  配置DispatcherServlet : 前端控制器，负责url的拦截和分发  -->
 <servlet>
     <servlet-name>dispatcherServlet</servlet-name>
     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
     <!--    配置springmvc-config.xml 配置文件的位置 (上下文配置位置)   -->
     <init-param>
         <param-name>contextConfigLocation</param-name>
         <param-value>classpath:springmvc-config.xml</param-value>
     </init-param>
     <!--    配置服务器启动时加载此配置文件，加载此Servlet  -->
     <load-on-startup>1</load-on-startup>
 </servlet>

 <servlet-mapping>
     <servlet-name>dispatcherServlet</servlet-name>
     <!--  拦截/接收所有请求  -->
     <!--
     此处的/会将页面中引入的静态文件（如.js文件）也进行拦截，拦截后页面就找不到这些“静态资源”了，会导致报错。
     此时可在springmvc-config.xml中通过 <mvc:resources mapping="" location=""/> 标签来对“静态资源”放行
     -->
     <url-pattern>/</url-pattern>
 </servlet-mapping>
</web-app>

springmvc-config.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"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    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
	http://www.springframework.org/schema/mvc
	http://www.springframework.org/schema/mvc/spring-mvc.xsd">

 <!--  组件扫描，根包扫描 : 让注解生效  -->
 <context:component-scan base-package="com.myh.controller"/>

<!--  配置视图解析器  -->
 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
     <property name="prefix" value="/WEB-INF/jsp/"/>
     <property name="suffix" value=".jsp"/>
 </bean>

<!--  注解驱动 :
作用1 : 用于启用"注解驱动"的"控制器方法",同时让注解生效。(一般而言，用到"控制器类"或"控制器方法" 就要配置"注解驱动")
作用2 : 会注册RequestMappingHandlerMapping 和 RequestMappingHandlerAdapter这两个bean
作用3 : 对“读写XML”和“读写JSON”的支持 (所以此处的JSON数据交互要在springmvc-config.xml中用此注解)
作用4 : <mvc:annotation-driven/>注解会会自动配置一些常用的消息转换器（Message Converters），其中就包括处理JSON数据的`MappingJackson2HttpMessageConverter`(所以进行JSON数据交互时要导入该标签: 注解驱动)
 -->
 <mvc:annotation-driven/>

 <!--  放行静态资源，让前端能直接访问“静态资源”  -->
 <mvc:resources mapping="/js/" location="/js/**"/>

</beans>

在上述springmvc-config.xml文件中，不仅配置了组件扫描器 (进行根包扫描) 和 视图解析器，还配置了Spring MvC的注解驱动mvc:annotation-drivern/ 和 静态资源访问映射<mvc:resources …>，其中、<mvc:annotation-drivern/>配置会自动注册 RequestMappingHandlerMapping 和 RequestMappingHandlerAdapter 这两个Bean，并提供 对读写XML和读写JSON 等功能的 支持。
（所以此处要配置该内容，因为此处为JSON的数据交互）
<mvc:resources… />元素用于配置静态资源的访问路径，由于在 web.xml 中配置的 “/” 会 将页面中引入 ( 如.js )的静态文件也进行拦截，而拦截后页面中将找不到这些静态资源文件，这样就会引起页面报错。而增加了静态资源的访问映射配置后，程序会自动地去配置路径下找静态的内容。

<mvc:resources …> 中有两个重要属性 ：location 和 mapping，两个属性的说明如下 ：

属性	说明
location	用于 定位需要访问的本地静态资源文件路径，具体到某个文件夹。
mapping	匹配静态资源全路径，其中 “/**” 表示 文件夹及其子文件夹下 的 某个具体文件。

---

User.java :

package com.myh.po;

public class User {

private String username;
private String password;

public String getUsername() {
  return username;
}

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

public String getPassword() {
  return password;
}

public void setPassword(String password) {
  this.password = password;
}

@Override
public String toString() {
  return "User{" +
          "username='" + username + '\'' +
          ", password='" + password + '\'' +
          '}';
}
}

userController.java ：

package com.myh.controller;

import com.myh.po.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller //把该类标记为“处理器类”,用于链接DispatcherServlet，让该类中的方法能被前端访问
public class UserController {

 //  @ResponseBody() : 将User对象转换为JSON格式数据响应给“前端”
 //该注解本质意思是 : 将方法的“返回值”自动转换为“指定的格式”，后响应给"前端"。如:如果方法的返回值是一个"字符串"，那么这个字符串会直接写入响应体中；
 // 如果返回值是一个“对象”，Spring MVC会默认使用 MappingJackson2HttpMessageConverter（在Spring 4.x版本后）将对象转换为JSON格式的字符串，然后写入响应体中（响应给前端）
 @ResponseBody
 @RequestMapping(value = "/testJson")
 //@RequestBody : 将前端传来的JSON类型的参数，转换为User类型，后赋值入该User对象参数中
 //该注解本质意思 : 将前端传来的数据绑定到方法中的“形参”中
 public User testJson(@RequestBody User user) {
     System.out.println(user);
     return user; //响应一个User对象给前端（通过@ResponseBody注解会转换为JSON格式数据，后进行响应）
     //此时返回值为一个对象，因为用了@ResponseBody注解，所以此时会将其转换为JSON格式的字符串，后响应给前端。
 }
}

在 userController.java 中，使用注解方式定义了一个控制器类，并编写了接收和响应JSON格式数据
的testJson( )方法，在方法中接收并打印了接收到的JSON格式的用户数据，然后响应了JSON格式的用户对象。
方法中的 @RequestBody注解 用于将前端请求体中的JSON格式数据绑定到形参user上，
@ResponseBody注解 用于直接返回User对象( 当返回POJO对象时，会默认转换为JSON格式数据进行响应)。

index.jsp :

<%--
Created by IntelliJ IDEA.
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
 <title>测试JSON数据交互</title>
 <%-- ${pageContext.request.contextPath} : 获取当前应用的“上下文路径” ，获取当前应用的“根URL”   --%>
 <%--  例如，如果你的 Web 应用部署在 <http://example.com/myapp/>，那么上下文路径就是 `/myapp`。  --%>

 <%--  导入Jquery文件  --%>
 <script type="text/javascript" src="${pageContext.request.contextPath}/js/jquery-3.7.1.js"></script>
 <script type="text/javascript">

     function testJson() {
         //获取用户输入的“用户名”和“密码”
         var username = $("#username").val();
         var password = $("#password").val();
         //ajax操作
         $.ajax({
             url: "${pageContext.request.contextPath}/testJson",
             type:"POST",
             // {username:username, password: password} : 为JS字面量对象，可通过JSON.stringify()方法转换为JSON字符串
             data : JSON.stringify({username:username, password: password}),
             //表示: 后端响应的“数据类型”
             dataType:"json",
             //表示前端传递给后端的数据类型 或 后端响应给前端的“数据类型”
             contentType: "application/json;charset=UTF-8",
             //回调函数
             success : function (data) {
                 if (data != null) {
                     alert("你输入的用户名为: " + data.username + ",密码为: " + data.password);
                 }
             }
         });
     }
 </script>
</head>
<body>
<form>
 用户名: <label for="username"></label><input type="text" name="username" id="username"><br/>
 密码: <label for="password"></label><input type="password" name="password" id="password"><br/>
 <input type="button" value="测试JSON交互2" onclick=" testJson()">
</form>
</body>
</html>

在index.jsp文件中，编写了一个测试JSON交互的表单，当单击“测试JSON交互”按钮时，会执行页面中的testJson( )函数。在函数中使用了jQuery的AJAX方式将JSON格式的用户名和密码传递到以"/testjson" 结尾的请求中。

需要注意的是，在AJAX中包含了3个特别重要的属性，其说明如下 :

属性	说明
data	即 前端 请求时携带的数据 / 参数。当使用JSON格式时，要注意编写规范。
dataType	表示 后端响应的数据的类型。 ps : 当 后端响应数据 为JSON格式时，dataType属性 此时的 值 必须 为json。 (dataType : "json"也可以省略不写，页面会自动识别响应的数据格式)
contentType	表示 ①前端请求的数据的类型 或 ② 后端响应的数据的类型。 ps : 当 请求数据为JSON格式 时，contentType的值 必须为 application/json;charset=UTF-8。

---

配置tomcat，且启动项目成功后，自动跳转index.jsp页面，填写数据后，前端将JSON格式数据传递给后端

后端控制台输出效果 ：

---

从上面的控制台输出结果可以看出，编写的代码已经正确 实现了JSON数据交互，可以将 JSON格式 的请求数据转换为方法中的 Java对象 ，也可以将 Java对象 转换为 JSON格式 的响应数据。

（该例子中前端传输JSON格式参数给后端，后端用 @RequestBody注解将 JSON格式数据绑定到方法的形参中，后端返回值为User对象类型，但因为使用了 @ResponseBody注解，所以此处返回值的User对象会被SpringMVC默认使用MappingJackson2HttpMessageConverter转换器 来将对象转换为JSON格式的字符串，后响应给前端，所以可以说 JSON格式–> Java对象 , Java对象 –>JSON格式 ）

ps :

该例子中用的Java对象转换为JSON格式的转换器为 ：MappingJackson2HttpMessageConverter （ 该例子 中用的的 “自动配置” 转换器）。

用<bean>标签方式的来“自行配置” JSON转换器配置MappingJackson2HttpMessageConverter转换器 (来完成JSON数据转换)

• 在配置JSON转换器 : MappingJackson2HttpMessageConverter时，除了常用的 <mvc:annotation-drivern /> 方式 “自动配置” 外，还可以使用 <bean>标签 的方式进行 “自行配置”。

  <bean>标签 自行配置 : 配置方式如下 ：

      <!--  用bean标签的方式来“自行配置”转换器 : MappingJackson2HttpMessageConverter -->
      <!--  "处理器映射器"和"处理器适配器"必须搭配使用，以下是配置 (注解方式的“处理器映射器”/"处理器适配器")  -->
  
      <!--  配置“处理器映射器”  -->
      <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
  
      <!--  配置“处理器适配器”  -->
      <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
          <!--  在“处理器适配器”中配置JSON转换器(来完成JSON数据的转换)  -->
          <property name="messageConverters">
              <list>
                <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
              </list>
          </property>
      </bean>
  

  从上述配置代码可以看出，使用 <bean>标签 配置方式 配置JSON转换器 时，需要同时配置 处理器映射器 和 处理器适配器，并且 JSON转换器 是 在配置在适配器中。

1.4 配置静态资源访问的方式 (对静态资源放行) (有三种方式)

• 除了使用 <mvc:resources mapping=" " location=" "/>元素 ( 这种方式最常用 )可以实现 对静态资源的访问
  ( 对静态资源放行，不拦截静态资源，还有另外 两种可以实现 “静态资源访问” 的方式 :

  ①使用<mvc:default-servlet-handler>标签

  ②使用激活Tomcat默认的Servlet来处理静态文件访问。

  （第一种方式开发中最常用，即上面的例子中的“资源放行”的方式）

  ps ：

  第一种 : 对 静态资源放行的方式 ：<mvc:resources mapping=" " location=" "/>元素
  —该方式开发中最常用。

<mvc:default-servlet-handler>标签 (对静态资源放行)

• 使用 <mvc:default-servlet-handler>标签 实现对“静态资源“放行 , springmvc-config.xml 的 配置方式 如下 ：

  <!--  实现对“静态资源”的访问外  / 放行静态资源，让前端能直接访问“静态资源”  -->
      <mvc:default-servlet-handler/> 
  

  在springmve-config.xml中配置 <mvc:default-servlet-handler> 后，会在 Spring MVC 上下文中定义一个org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler (即默认的Servlet请求处理器)。它会像一个检查员，对进入DispatcherServlet的URL进行筛查。如果发现是 静态资源 的 请求，就将该请求转由Web服务器默认的Servlet 处理，默认的Servlet就会对这些静态资源放行；如果不是静态资源的请求，才由DispatcherServlet继续处理。

  ---

  注意点：

  一般 Web服务器默认的Servlet名称是"default"，因此DefaultServletHttpRequestHandler 可以找到它。如果使用的Web应用服务器默认的Servlet名称不是"default"，则需要通过default-servlet-name属性显示指定，具体方式如下 ：

    <mvc:default-servlet-handler default-servlet-name="Servlet名称"/>
  

  而 Web服务器的Servlet名称 是由使用的服务器确定的，常用服务器及其Servlet名称如下 :
  ①Tomcat、 Jetty、 JBoss和 and GlassFish 默认Servlet的名称 ：default。
  ②Google App Engine默认Servlet的名称: _ah_default 。
  ③Resin默认Servlet的名称 ：resin-file 。
  ④WebLogic默认Servlet的名称 : FileServlet。
  ⑤WebSphere默认Servlet的名称 : SimpleFileServlet。

使用激活Tomcat默认的Servlet (对静态资源放行)

• 使用 激活Tomcat默认 的 Servlet 来处理 静态文件访问 ，激活Tomcat默认的Servlet时，需要在web.xml中添加以下内容 ：

      <!--  激活Tomcat默认的Servlet来处理静态文件访问 (来对静态资源放行)  -->
      <!--  激活Tomcat的静态资源拦截，需要哪些“静态资源”，再往下追加  -->
      <servlet-mapping>
          <servlet-name>default</servlet-name>
          <url-pattern>*.js</url-pattern>
      </servlet-mapping>
      <servlet-mapping>
          <servlet-name>default</servlet-name>
          <url-pattern>*.css</url-pattern>
      </servlet-mapping>
       ...
  

  在上述代码中，配置了 <servlet-mapping>元素来激活Tomcat 默认的Servlet 来处理静态文件，我们还可以根据需要继续追加<servlet-mapping>。此种配置方式和上一种方式本质上是一样的，都是使用Web服务器默认的Servlet来处理静态资源文件的访问。其中 Servelt名称 (即 <servlet-name>元素的值)也是 由使用的服务器来确定 的，不同的服务器需要使用不同的名称。

• 以上3种静态资源访问的配置方式不同，并且各有优缺点，具体如下 :
  第一种和第三种配置方式 可以 选择性的释放静态资源。
  第二种 配置方式 配置相对简单，只需要一行代码，就 可以释放所有静态资源。
  第二 和 第三种配置方式 会 导致项目移植性较差，需要根据 具体的Web服务器来更改Servlet名称。
  第三种配置方式 运行 效率更高，因为服务器启动时已经加载了web.xml中的静态资源。
• 在实际开发 中，更为 常用的配置 还是 第一种(即案例中的)配置方式，这样就不需要考虑Web服务器的问题了。

二、RESTful支持

Spring MVC 除了支持JSON数据交互外，还支持RESTful风格的编程。

2.1 RESTful设计风格

• RESTful 也称之为REST ( Representational State Transfer : 表述性状态转移) ,可以将它理解为一种 软件架构风格 或 设计风格，而 不是一个标准 ( RESTFUL是一种软件架构/设计风格 )。

★★★★★
简单来说，RESTful风格 的重要特征之一 ：把请求参数变成请求路径。( 意思就是说 ： 当你的 “URL中的参数” 成为了请求路径的一部分时，说明时候你使用的就是RESTful风格在进行编程 )。
★★★★★

例如，传统风格 的带参数的 URL请求 格式为:

//传统风格的带参数的URL请求以下格式，请求参数一般是“不作为”URL路径中的一部分的，但RESTful风格中的请求参数一般是“作为”URL路径中的一部分。
http://.../queryItems?id=1

而采用 RESTful风格后，其URL请求为 ：
(传统风格请求参数不是请求路径的一部分，而用RESTful风格中请求参数是请求路径中的一部分)

//此风格为RESTful风格，请求参数1作为了URL路径中的一部分，后端通过{xxx} 和 @PathVariable()注解来获取该请求参数
http://.../items/1

/**
    * 后端接收前端通过RESTful风格传递来的参数
 */
@RequestMapping(value = "/user/{id}",method = RequestMethod.GET)
   //通过 {xxx} 和 @PathVariable()注解来获得URL路径上的参数
   public User selectUserByRestful(@PathVariable("id") String id) {
        .....
   }

从上述两个请求中可以看出，RESTful风格 中的 URL将请求参数id=1变成了请求路径的一部分，并且URL中的querytems也变成了items ( RESTful风格中的URL不存在动词形式的路径，如queryltems表示查询订单，是一个动词，而 items表示订单，为名词)。

• RESTful风格在HTTP请求中，使用put、delete、 post 和get方式分别对应添加、删除、修改和查询的操作。不过目前国内开发，(更多) 还是只使用post和get方式来进行增删改查操作。

• 例子如 : (用户信息查询) :

本案例将采用 RESTful风格的请求实现对用户信息的查询，同时 返回JSON格式 的 数据 ：

restful.jsp :

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
   <title>RESTful测试</title>
   <script type="text/javascript" src="${pageContext.request.contextPath}/js/jquery-3.7.1.js"></script>
   <script type="text/javascript">
       function search() {
           //获取输入的查询编号
           var id = $("#number").val();
           $.ajax({
               //该url中传递的参数不直接接在url后面，后端则通过@PathVirable()注解来获得该参数
               url: "${pageContext.request.contextPath}/user/" + id,
               type:"GET",
               //定义回调响应的数据格式为JSON字符串
               dataType:"json", //后端响应的类型是 :josn
               //回调函数
               success : function (data) {
                   if (data.username != null) {
                       alert("你查询的用户是: " + data.username);
                   } else {
                       alert("没有找到id为:" + id + "的用户！");
                   }
               }
           });
       }
   </script>
</head>
<body>
<form>
   编号: <input type="text" name="number" id="number">
   <input type="button" value="搜索" onclick="search()">
</form>
</body>
</html>

UserController.java :

package com.myh.controller;

import com.myh.po.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

@Controller //把该类标记为“处理器类”,用于链接DispatcherServlet，让该类中的方法能被前端访问
public class UserController {

   /**
       * 前端通过RESTful风格来进行参数的传递
       * (接收RESTful风格的请求，其接收方式为GET)
    *
       * RESTful风格 的体现之一: “请求参数”作为了URL中的“一部分”
    */
   @ResponseBody //该注解的作用: 将“返回值”自动转换为“指定格式的数据”,响应给前端。(返回对象类型时，会将对象转换为JSON格式字符串来响应给前端)
   @RequestMapping(value = "/user/{id}",method = RequestMethod.GET)
   //通过 {xxx} 和 @PathVariable()注解来获得URL路径上的参数
   public User selectUserByRestful(@PathVariable("id") String id) {
       System.out.println(id);
       User user = new User();
       //模拟根据id查询出用户对象数据
       if (id.equals("1234")) {
           user.setUsername("zhangsan");
       }
       //返回JSON格式的数据
       return user;
   }
}

在上述代码中，value = "/user/{id}"表示可以匹配 以/user/{id}结尾的请求，id为请求中的动态参数 （前端可用RESTful风格来设置该动态参数）。method=RequestMethod.GET表示只接收GET方式的请求。 方法中的 @PathVariable("id”)注解 则用于接收并绑定请求参数，它可以 将请求URL 中的 变量映射
到 方法的形参 上，如果请求路径为“user/{id}"，即 请求参数中的 id 和方法形参名称id 一样，则
@PathVariable后面的“(“id”)” 可以省略。

---

---