• SpringMVC--HttpMessageConverter

    结合视频一起学习——66_尚硅谷_SpringMVC_@RequestBody注解获取请求体信息_哔哩哔哩_bilibili

    1. 概述

    HttpMessageConverter（报文信息转换器）

    想象一下，你的电脑想要告诉另一台电脑一些信息。但是，它们不能直接用语言交流，它们需要用一种特殊的代码来交流，这种代码就是HTTP。

    在Web应用中，客户端和服务器之间通常通过HTTP请求和响应来交换数据。这些数据通常以特定的格式存在，比如JSON、XML等。HttpMessageConverter的作用就是帮助将这些数据转换为Java对象，或者将Java对象转换为客户端能够理解的格式。

    相关注解和类型

    1. @RequestBody
      • 这个注解用于告诉Spring框架，某个方法的参数应该直接从HTTP请求体中获取数据，而不是通过表单参数或其他方式。换句话说，它允许你将请求体中的数据（如JSON或XML）直接映射到Java对象中。
      • 想象你收到了一封电子邮件，你不需要手动复制邮件内容，@RequestBody就像是一个自动帮你把邮件内容转换成你可以理解的格式的工具。
    1. @ResponseBody
      • 与@RequestBody相反，@ResponseBody注解告诉Spring框架，方法的返回值应该被转换为客户端能够理解的格式（如JSON或XML），并作为HTTP响应体发送回去。这意味着你不需要返回一个视图或视图名称，Spring会自动处理。
      • 这就像你回复邮件时，不需要自己手动把回复内容转换成邮件格式，@ResponseBody会自动帮你做这个工作。
    1. RequestEntity
      • RequestEntity是一个类，它封装了一个HTTP请求的所有信息，包括头信息、方法和正文。你可以使用这个类来构建复杂的请求，或者在客户端模拟HTTP请求。
      • 就像你写邮件时，不仅写正文，还可以添加附件、设置主题等。RequestEntity就是一个可以帮你构建这样一封完整邮件的工具。
    1. ResponseEntity
      • ResponseEntity是一个类，它封装了HTTP响应的所有信息，包括状态码、头信息和正文。当你想要控制响应的每个细节时，可以使用这个类。
      • 这就像你收到了一封邮件，ResponseEntity可以让你看到邮件的所有信息，包括附件、主题等，并且可以对这些信息进行操作。

    举个例子

    假设你在网上购物，你选择了一个商品并提交了订单：

    1. {
    2.   "productId": "12345", 
    3.   "quantity": 2
    4. }

    这是你发给网站的一个请求，告诉它你想买什么。

    在网站的服务器上，使用@RequestBody，服务器能够自动理解你的请求，知道你想要购买的商品编号和数量。

    然后，服务器处理你的请求，准备给你一个确认信息，比如：

    1. {
    2.   "status": "success",
    3.   "message": "Your order has been placed."
    4. }

    服务器使用@ResponseBody来自动将这个确认信息发送回给你，你就能在你的浏览器上看到这个消息了。

    2. 初始化项目 demo05

    前面学了那么多，从新再来一个如何创建一个新的 SpringMVC 项目

    2.1. 新建项目 -- SpringMVC-demo05

    对应 pom 文件打 war 包

    2.2. 配置 web.xml 文件

    创建 webapp 文件夹

    注意，需要图标带个小点点才算成功，且和 java、resources 文件夹同级

    创建 web.xml 文件

    注意要正确的 web.xml 文件路径

    我这里是

    F:\Program\Java\SpringMVC\SpringMVC-demo05\src\main\webapp\WEB-INF\web.xml

    需要自己手动加上\src\main\webapp\

    2.3. web.xml 配置

    编码过滤器、HiddenHttpMethodFilter、前端控制器

    顺序不能错，编码要在最前

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
    5.          version="4.0">
    6.     <!--编码过滤器、HiddenHttpMethodFilter、前端控制器-->
    7.     <!-- 配置springMVC的编码过滤器 -->
    8.     <filter>
    9.         <filter-name>CharacterEncodingFilter</filter-name>
    10.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    11.         <init-param>
    12.             <param-name>encoding</param-name>
    13.             <param-value>UTF-8</param-value>
    14.         </init-param>
    15.         <init-param>
    16.             <param-name>forceResponseEncoding</param-name>
    17.             <param-value>true</param-value>
    18.         </init-param>
    19.     </filter>
    20.     <filter-mapping>
    21.         <filter-name>CharacterEncodingFilter</filter-name>
    22.         <url-pattern>/*</url-pattern>
    23.     </filter-mapping>
    24.     
    25.     <!-- 配置HiddenHttpMethodFilter -->
    26.     <filter>
    27.         <filter-name>HiddenHttpMethodFilter</filter-name>
    28.         <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    29.     </filter>
    30.     <filter-mapping>
    31.         <filter-name>HiddenHttpMethodFilter</filter-name>
    32.         <url-pattern>/*</url-pattern>
    33.     </filter-mapping>
    34.     
    35.     <!--配置Spring MVC核心控制器（DispatcherServlet）-->
    36.     <servlet>
    37.         <servlet-name>springmvc05</servlet-name>
    38.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    39.         <init-param>
    40.             <param-name>contextConfigLocation</param-name>
    41.             <param-value>classpath:springmvc-servlet.xml</param-value>
    42.         </init-param>
    43.         <load-on-startup>1</load-on-startup>
    44.     </servlet>
    45.     <servlet-mapping>
    46.         <servlet-name>springmvc05</servlet-name>
    47.         <url-pattern>/</url-pattern>
    48.     </servlet-mapping>
    49.     
    50. </web-app>

    2.4. 配置 spring 文件

    配置前端 dispatcherServlet 需要对应的 spring 配置文件，不然这里会爆红

    在 resources 文件夹中创建上文代码中对应名称的 spring 配置文件

    即 springmvc-servlet.xml 文件，名称可以随意，符合命名规范即可

    要求如下：

    1. 组件扫描：告诉Spring在哪些地方寻找你的代码中的特定部分（比如控制器），然后自动把它们加入到应用中。
    2. Thymeleaf视图解析器：Thymeleaf是一个工具，用来生成用户看到的网页。视图解析器告诉Spring怎么使用Thymeleaf来显示这些网页。
    3. servlet-handler处理静态资源：静态资源是指网站上不会变的东西，比如图片、CSS样式表和JavaScript文件。这个设置让Spring知道怎么正确地发送这些文件给请求它们的用户。
    4. 启动注解驱动：注解是一种特殊的标记，你可以加在代码中。启动注解驱动就是让Spring注意这些注解，并根据它们来设置应用的行为。
    5. view-controller视图默认映射：这设置了一个“首页”，当用户访问你的网站，但没有明确说要看哪个页面时，就会看到这个“首页”。
    1. "1.0" encoding="UTF-8"?>
    3. <beans xmlns="http://www.springframework.org/schema/beans"
    4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    5.        xmlns:context="http://www.springframework.org/schema/context"
    6.        xmlns:mvc="http://www.springframework.org/schema/mvc"
    7.        xsi:schemaLocation="
    8.            http://www.springframework.org/schema/beans 
    9.            http://www.springframework.org/schema/beans/spring-beans.xsd 
    10.            http://www.springframework.org/schema/context 
    11.            https://www.springframework.org/schema/context/spring-context.xsd
    12.            http://www.springframework.org/schema/mvc
    13.            http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    14.     
    15.     
    16.     
    17.     
    18.     
    19.     <context:component-scan base-package="com.sakurapaid.mvc"/>
    20.     
    21.     
    22.     
    23.     <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
    24.         <property name="order" value="1"/> 
    25.         <property name="characterEncoding" value="UTF-8"/> 
    26.         <property name="templateEngine">
    27.             <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
    28.                 <property name="templateResolver">
    29.                     <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
    30.                         
    31.                         
    32.                         <property name="prefix" value="/WEB-INF/html/"/>
    33.                         
    34.                         
    35.                         <property name="suffix" value=".html"/>
    36.                         <property name="templateMode" value="HTML5"/> 
    37.                         <property name="characterEncoding" value="UTF-8"/> 
    38.                     bean>
    39.                 property>
    40.             bean>
    41.         property>
    42.     bean>
    43.     
    44.     
    45.     <mvc:default-servlet-handler/>
    46.     
    47.     
    48.     
    49.     <mvc:view-controller path="/" view-name="index"/>
    50.     
    51.     
    52.     <mvc:annotation-driven/>
    53. beans>

    2.5. 测试首页 index.html

    根据视图解析器在对应的位置创建 index 文件

    配置 Tomcat 服务器

    3. @RequestBody

    @RequestBody注解获取请求体信息

    @RequestBody是一个告诉Spring框架，你想要直接从HTTP请求体中读取数据的注解。它通常用在处理非表单类型的数据，比如JSON或XML格式的数据。

    @RequestBody可以获取请求体，需要在控制器方法设置一个形参，使用@RequestBody进行标识，当前请求的请求体就会为当前注解所标识的形参赋值

    例子解释

    有一个HTML表单，用户可以输入用户名和密码，然后提交表单：

    • 修改 index.html
    1. <!DOCTYPE html>
    2. <html lang="en" xmlns:th="http://www.thymeleaf.org">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>index</title>
    6. </head>
    7. <body>
    8.     <form th:action="@{/demo05/testRequestBody}" method="post">
    9.         用户名：<input type="text" name="username">
    10.         密码：<input type="password" name="password">
    11.         <input type="submit">
    12.     </form>
    13. </body>
    14. </html>

    当用户填写表单并点击提交时，浏览器会将表单中的数据以application/x-www-form-urlencoded格式发送到服务器。

    然后，有一个Spring的控制器方法，它用@RequestBody注解来获取这个数据：

    • 创建 TestController05 控制器
    1. package com.sakurapaid.mvc.controller;
    2.  
    3. import org.springframework.stereotype.Controller;
    4. import org.springframework.web.bind.annotation.RequestBody;
    5. import org.springframework.web.bind.annotation.RequestMapping;
    6.  
    7. @Controller
    8. @RequestMapping("/demo05")
    9. public class TestController05 {
    10.  
    11.     /**
    12.      * 测试请求体的函数
    13.      *
    14.      * @param requestBody 请求体内容，以字符串形式传入
    15.      * @return 返回一个表示操作成功的字符串
    16.      */
    17.     @RequestMapping("/testRequestBody")
    18.     public String testRequestBody(@RequestBody String requestBody){
    19.         // 打印请求体内容
    20.         System.out.println("requestBody:"+requestBody);
    21.         return "success";
    22.     }
    23. }

    在这个例子中，@RequestBody注解告诉Spring，我们想要将请求体中的数据直接作为一个字符串传递给requestBody参数。

    • success.html 文件
    1. <!DOCTYPE html>
    2. <html lang="en" xmlns:th="http://www.thymeleaf.org">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>Success</title>
    6. </head>
    7. <body>
    8.     <h1>Success</h1>
    9. </body>
    10. </html>

    输出结果

    当你提交表单时，服务器上的testRequestBody方法会被调用，并且会打印出请求体的内容：

    requestBody:username=admin&password=123456

    这意味着，表单中的数据（用户名和密码）被作为请求体发送，并且被@RequestBody注解的方法参数接收为一个字符串。

    注意

    通常，我们不会用@RequestBody来处理表单数据，因为表单数据通常是键值对的形式，而不是JSON或XML。对于表单数据，我们通常会使用@RequestParam注解来获取每个表单字段的值。

    4. @RequestEntity

    RequestEntity封装请求报文的一种类型，需要在控制器方法的形参中设置该类型的形参，当前请求的请求报文就会赋值给该形参，可以通过getHeaders()获取请求头信息，通过getBody()获取请求体信息。

    RequestEntity是一个更高级的类，它不仅包含了请求体，还包含了请求头、HTTP方法、URI等信息。当你需要获取整个请求的详细信息时，可以使用RequestEntity。

    • 修改 index.html
    1. <!DOCTYPE html>
    2. <html lang="en" xmlns:th="http://www.thymeleaf.org">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>index</title>
    6. </head>
    7. <body>
    8.     <form th:action="@{/demo05/testRequestBody}" method="post">
    9.         用户名：<input type="text" name="username">
    10.         密码：<input type="password" name="password">
    11.         <input type="submit" value="测试RequestBody">
    12.     </form>
    13.     <hr>
    14.     <form th:action="@{/demo05/testRequestEntity}" method="post">
    15.         用户名：<input type="text" name="username">
    16.         密码：<input type="password" name="password">
    17.         <input type="submit" value="测试RequestEntity">
    18.     </form>
    19. </body>
    20. </html>

    • 修改后端控制器
    1. package com.sakurapaid.mvc.controller;
    2.  
    3. import org.springframework.http.RequestEntity;
    4. import org.springframework.stereotype.Controller;
    5. import org.springframework.web.bind.annotation.RequestBody;
    6. import org.springframework.web.bind.annotation.RequestMapping;
    7.  
    8. @Controller
    9. @RequestMapping("/demo05")
    10. public class TestController05 {
    11.  
    12.     @RequestMapping("/testRequestBody")
    13.     public String testRequestBody(@RequestBody String requestBody){
    14.         // 打印请求体内容
    15.         System.out.println("requestBody:"+requestBody);
    16.         return "success";
    17.     }
    18.  
    19.     @RequestMapping("/testRequestEntity")
    20.     public String testRequestEntity(RequestEntity requestEntity){
    21.         // 当前requestEntity对象中包含了请求头、请求体、请求方式等信息
    22.         System.out.println("请求头:" + requestEntity.getHeaders());
    23.         System.out.println("请求体:" + requestEntity.getBody());
    24.         System.out.println("请求方式:" + requestEntity.getMethod());
    25.         System.out.println("请求URL:" + requestEntity.getUrl());
    26.         System.out.println("请求参数:" + requestEntity.getUrl().getQuery());
    27.         return "success";
    28.     }
    29. }

    • 测试输出

    5. @ResponseBody

    5.1. HttpServletResponse 响应数据

    回顾以前的通过 ServletAPI 去响应数据

    • 修改 index.html
    1. <!DOCTYPE html>
    2. <html lang="en" xmlns:th="http://www.thymeleaf.org">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>index</title>
    6. </head>
    7. <body>
    8.     <form th:action="@{/demo05/testRequestBody}" method="post">
    9.         用户名：<input type="text" name="username">
    10.         密码：<input type="password" name="password">
    11.         <input type="submit" value="测试RequestBody">
    12.     </form>
    13.     <hr>
    14.     <form th:action="@{/demo05/testRequestEntity}" method="post">
    15.         用户名：<input type="text" name="username">
    16.         密码：<input type="password" name="password">
    17.         <input type="submit" value="测试RequestEntity">
    18.     </form>
    19.     <hr>
    20.     <a th:href="@{/demo05/testServletAPI}">测试ServletAPI</a> 
    21. </body>
    22. </html>

    • 添加控制器
    1. package com.sakurapaid.mvc.controller;
    2.  
    3. import org.springframework.http.RequestEntity;
    4. import org.springframework.stereotype.Controller;
    5. import org.springframework.web.bind.annotation.RequestBody;
    6. import org.springframework.web.bind.annotation.RequestMapping;
    7.  
    8. import javax.servlet.http.HttpServletResponse;
    9. import java.io.IOException;
    10.  
    11. @Controller
    12. @RequestMapping("/demo05")
    13. public class TestController05 {
    14.  
    15.     @RequestMapping("/testRequestBody")
    16.     public String testRequestBody(@RequestBody String requestBody){
    17.         // 打印请求体内容
    18.         System.out.println("requestBody:"+requestBody);
    19.         return "success";
    20.     }
    21.  
    22.     @RequestMapping("/testRequestEntity")
    23.     public String testRequestEntity(RequestEntity requestEntity){
    24.         // 当前requestEntity对象中包含了请求头、请求体、请求方式等信息
    25.         System.out.println("请求头:" + requestEntity.getHeaders());
    26.         System.out.println("请求体:" + requestEntity.getBody());
    27.         System.out.println("请求方式:" + requestEntity.getMethod());
    28.         System.out.println("请求URL:" + requestEntity.getUrl());
    29.         System.out.println("请求参数:" + requestEntity.getUrl().getQuery());
    30.         return "success";
    31.     }
    32.  
    33.     @RequestMapping("/testServletAPI")
    34.     public void toResponse(HttpServletResponse response) throws IOException {
    35.         response.getWriter().print("hello,response");
    36.     }
    37. }

    • 测试输出

    5.2. @ResponseBody 注解

    @ResponseBody 是一个注解，它告诉Spring框架，某个方法的返回值应该直接作为HTTP响应的正文发送给客户端，而不是被渲染成视图（如HTML页面）。这样，当客户端发送请求到服务器，服务器处理完请求后，可以直接将处理结果以文本、JSON或XML等格式返回给客户端，而不是返回一个视图模板。这在开发RESTful Web服务时非常有用，因为客户端通常期望收到可以直接处理的数据，而不是一个网页视图。

    @ResponseBody用于标识一个控制器方法，可以将该方法的返回值直接作为响应报文的响应体响应到浏览器。

    • index.html
    1. <!DOCTYPE html>
    2. <html lang="en" xmlns:th="http://www.thymeleaf.org">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>index</title>
    6. </head>
    7. <body>
    8.     <form th:action="@{/demo05/testRequestBody}" method="post">
    9.         用户名：<input type="text" name="username">
    10.         密码：<input type="password" name="password">
    11.         <input type="submit" value="测试RequestBody">
    12.     </form>
    13.     <hr>
    14.     <form th:action="@{/demo05/testRequestEntity}" method="post">
    15.         用户名：<input type="text" name="username">
    16.         密码：<input type="password" name="password">
    17.         <input type="submit" value="测试RequestEntity">
    18.     </form>
    19.     <hr>
    20.     <a th:href="@{/demo05/testServletAPI}">测试ServletAPI</a>
    21.     <hr>
    22.     <a th:href="@{/demo05/testResponseBody}">测试ResponseBody</a>
    23. </body>
    24. </html>

    • 控制器
    1. package com.sakurapaid.mvc.controller;
    2.  
    3. import org.springframework.http.RequestEntity;
    4. import org.springframework.stereotype.Controller;
    5. import org.springframework.web.bind.annotation.RequestBody;
    6. import org.springframework.web.bind.annotation.RequestMapping;
    7. import org.springframework.web.bind.annotation.ResponseBody;
    8.  
    9. import javax.servlet.http.HttpServletResponse;
    10. import java.io.IOException;
    11.  
    12. @Controller
    13. @RequestMapping("/demo05")
    14. public class TestController05 {
    15.  
    16.     @RequestMapping("/testRequestBody")
    17.     public String testRequestBody(@RequestBody String requestBody){
    18.         // 打印请求体内容
    19.         System.out.println("requestBody:"+requestBody);
    20.         return "success";
    21.     }
    22.  
    23.     @RequestMapping("/testRequestEntity")
    24.     public String testRequestEntity(RequestEntity requestEntity){
    25.         // 当前requestEntity对象中包含了请求头、请求体、请求方式等信息
    26.         System.out.println("请求头:" + requestEntity.getHeaders());
    27.         System.out.println("请求体:" + requestEntity.getBody());
    28.         System.out.println("请求方式:" + requestEntity.getMethod());
    29.         System.out.println("请求URL:" + requestEntity.getUrl());
    30.         System.out.println("请求参数:" + requestEntity.getUrl().getQuery());
    31.         return "success";
    32.     }
    33.  
    34.     @RequestMapping("/testServletAPI")
    35.     public void toResponse(HttpServletResponse response) throws IOException {
    36.         response.getWriter().print("hello,response");
    37.     }
    38.  
    39.     @RequestMapping("/testResponseBody")
    40.     @ResponseBody
    41.     public String testResponseBody(){
    42.         return "success";
    43.     }
    44. }

    有@ResponseBody 注解的情况

    没有@ResponseBody 注解的情况

    6. SpringMVC处理JSON

    6.1. 回顾 JSON

    参考视频

    71_尚硅谷_SpringMVC_回顾json_哔哩哔哩_bilibili

    6.2. @ResponseBody处理json的步骤

    1. 添加Jackson库依赖

    Jackson是一个流行的Java库，用于将Java对象转换成JSON格式的字符串，也可以将JSON字符串转换成Java对象。在你的项目中，你需要添加Jackson库，以便Spring能够将Java对象转换为JSON格式。

    1. <dependency>
    2.     <groupId>com.fasterxml.jackson.core</groupId>
    3.     <artifactId>jackson-databind</artifactId>
    4.     <version>2.12.1</version>
    5. </dependency>

    1. 启用注解驱动

    在Spring的配置文件中，你需要启用注解驱动。这样做可以让Spring识别并处理用注解标记的方法，比如@RequestMapping和@ResponseBody。

    <mvc:annotation-driven />

    1. 使用@ResponseBody注解

    在你的控制器方法上使用@ResponseBody注解，这样Spring就知道这个方法的返回值需要直接作为响应体发送给客户端，而不是渲染成页面。

    1. @RequestMapping("/testResponseUser")
    2. @ResponseBody
    3. public User testResponseUser(){
    4.     return new User(1001,"admin","123456",23,"男");
    5. }

    同时修改 index.html 页面

    1. <!DOCTYPE html>
    2. <html lang="en" xmlns:th="http://www.thymeleaf.org">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>index</title>
    6. </head>
    7. <body>
    8.     <form th:action="@{/demo05/testRequestBody}" method="post">
    9.         用户名：<input type="text" name="username">
    10.         密码：<input type="password" name="password">
    11.         <input type="submit" value="测试RequestBody">
    12.     </form>
    13.     <hr>
    14.     <form th:action="@{/demo05/testRequestEntity}" method="post">
    15.         用户名：<input type="text" name="username">
    16.         密码：<input type="password" name="password">
    17.         <input type="submit" value="测试RequestEntity">
    18.     </form>
    19.     <hr>
    20.     <a th:href="@{/demo05/testServletAPI}">测试ServletAPI</a>
    21.     <hr>
    22.     <a th:href="@{/demo05/testResponseBody}">测试ResponseBody</a>
    23.     <hr>
    24.     <a th:href="@{/demo05/testResponseUser}">测试Json</a>
    25. </body>
    26. </html>

    1. 返回Java对象

    在你的控制器方法中，你可以直接返回一个Java对象。由于前面已经启用了注解驱动并添加了@ResponseBody注解，Spring会使用Jackson库将这个Java对象转换成JSON格式的字符串，并发送给客户端。

    1. / 假设User是一个简单的Java类，包含id, username, password, age, sex等属性
    2. public class User {
    3.     private int id;
    4.     private String username;
    5.     private String password;
    6.     private int age;
    7.     private String sex;
    8.     // 构造方法、getter和setter省略
    9. }

    1. 结果

    当客户端请求/testResponseUser这个URL时，浏览器会收到一个JSON格式的响应，如下所示：

    1. {
    2.   "id": 1001,
    3.   "username": "admin",
    4.   "password": "123456",
    5.   "age": 23,
    6.   "sex": "男"
    7. }

    这样，你就可以在客户端（比如浏览器或者移动应用）直接使用这个JSON数据了。

    7. SpringMVC处理ajax

    请求超链接

    通过vue和axios处理点击事件

    2. <div id="app">
    3.     
    4.     <a th:href="@{/demo05/testAjax}" @click="testAjax">testAjaxa><br>
    5. div>
    6.  
    8. <script type="text/javascript" th:src="@{/static/js/vue.js}">script>
    10. <script type="text/javascript" th:src="@{/static/js/axios.min.js}">script>
    11.  
    13. <script type="text/javascript">
    14.     const vue = new Vue({
    15.         el: "#app", // 挂载点为 id 为 app 的 div 元素
    16.         methods: {
    17.             /**
    18.              * 发起 AJAX 请求的方法
    19.              * @param event 鼠标点击事件对象
    20.              */
    21.             testAjax: function (event) {
    22.                 // 使用 axios 发起 POST 请求
    23.                 axios({
    24.                     method: "post", // 请求方法
    25.                     url: event.target.href, // 请求地址，来自点击的链接
    26.                     params: { // 请求参数
    27.                         username: "admin",
    28.                         password: "123456"
    29.                     }
    30.                 }).then(function (response) { // 请求成功后的处理
    31.                     alert(response.data); // 显示响应数据
    32.                 });
    33.                 event.preventDefault(); // 阻止默认行为，即阻止链接跳转
    34.             }
    35.         }
    36.     });
    37. script>

    控制器方法

    1. @RequestMapping("/testAjax")
    2. @ResponseBody
    3. public String testAjax(String username, String password){
    4.     System.out.println("username:"+username+",password:"+password);
    5.     return "hello,ajax";
    6. }

    测试输出

    8. @RestController注解

    在Spring MVC框架中，我们通常会用到两种注解来创建一个控制器：

    1. @Controller：这个注解用来标记一个类是一个控制器，它负责处理用户的请求并返回响应。
    2. @ResponseBody：这个注解用来标记一个方法，表示该方法的返回值将直接作为响应体返回，而不是返回一个视图（View）。

    @RestController是一个复合注解，它相当于同时包含了@Controller和@ResponseBody的功能。当你在一个类上使用@RestController注解时，你就不需要在该类的方法上单独使用@ResponseBody注解了，因为@RestController已经包含了它的功能。

    1. import org.springframework.stereotype.Controller;
    2. import org.springframework.web.bind.annotation.GetMapping;
    3. import org.springframework.web.bind.annotation.ResponseBody;
    4.  
    5. // 使用@RestController注解，这个类就成为了一个控制器
    6. // 并且类中的所有方法都会将返回值作为响应体返回
    7. @RestController
    8. public class MyController {
    9.  
    10.     // 使用@GetMapping注解，这个请求会映射到"/hello"这个URL
    11.     @GetMapping("/hello")
    12.     // 由于类上有@RestController注解，这里不需要@ResponseBody注解
    13.     public String sayHello() {
    14.         return "Hello, World!";
    15.     }
    16. }

    在这个例子中，我们创建了一个名为MyController的控制器类，并使用@RestController注解标记它。然后，我们在这个类中定义了一个名为sayHello的方法，并用@GetMapping("/hello")注解来映射到URL /hello。当用户访问这个URL时，sayHello方法会被调用，并且它返回的字符串"Hello, World!"将直接作为响应体返回给用户。

    这样，你就不需要在sayHello方法上使用@ResponseBody注解，因为@RestController已经包含了这个功能。这使得代码更加简洁。

    9. ResponseEntity 类

    ResponseEntity是一个在Spring MVC中用来构建HTTP响应的类。当你需要对HTTP响应进行更细致的控制时，比如设置状态码、添加响应头或者自定义响应体，就可以使用ResponseEntity。

    简单来说，ResponseEntity允许你构造一个完整的HTTP响应，包括：

    • 状态码（如200 OK, 404 Not Found等）
    • 响应头（如Content-Type, Cache-Control等）
    • 响应体（即返回给客户端的数据）

    下面是一个使用ResponseEntity的简单Spring MVC代码示例：

    1. import org.springframework.http.HttpHeaders;
    2. import org.springframework.http.HttpStatus;
    3. import org.springframework.http.ResponseEntity;
    4. import org.springframework.web.bind.annotation.GetMapping;
    5. import org.springframework.web.bind.annotation.RestController;
    6.  
    7. @RestController
    8. public class MyController {
    9.  
    10.     @GetMapping("/greeting")
    11.     public ResponseEntity<String> getGreeting() {
    12.         // 创建一个响应对象
    13.         HttpHeaders headers = new HttpHeaders();
    14.         // 添加一个响应头，告诉浏览器这是一个HTML内容
    15.         headers.add("Content-Type", "text/plain; charset=UTF-8");
    16.         
    17.         // 设置HTTP状态码为200 OK
    18.         HttpStatus status = HttpStatus.OK;
    19.         
    20.         // 响应体的内容
    21.         String body = "Hello, this is a custom response!";
    22.         
    23.         // 构建ResponseEntity对象
    24.         ResponseEntity<String> response = new ResponseEntity<>(body, headers, status);
    25.         
    26.         // 返回ResponseEntity对象
    27.         return response;
    28.     }
    29. }

    在这个例子中，我们定义了一个名为getGreeting的方法，它返回一个ResponseEntity类型的值。我们首先创建了一个HttpHeaders对象，并添加了一个Content-Type响应头，指定内容类型为纯文本。然后，我们指定了HTTP状态码为HttpStatus.OK，这表示请求成功。接下来，我们定义了响应体的内容，即字符串"Hello, this is a custom response!"。最后，我们使用这些信息创建了一个ResponseEntity对象，并将其返回。

    当客户端调用/getGreeting这个URL时，服务器将返回一个状态码为200的响应，响应头中包含Content-Type，且响应体为"Hello, this is a custom response!"。通过这种方式，你可以更灵活地控制HTTP响应的各个方面。

  • 相关阅读:
    GoldenGate中使用 exp/imp 进行初始化
    麒麟系统开发笔记（十三）：在国产麒麟系统上编译OSG库、搭建基础开发环境和移植测试Demo
    如果让你和你的团队去用yolov8 做一款能检测箭靶自动报靶的系统，你会怎么做？
    Mybatis - 一对多/多对一映射
    分享几个Linux几个有趣且实用的命令
    git使用
    springboot电子阅览室app毕业设计源码016514
    数据库管理-第156期 Oracle Vector DB & AI-07（20240227）
    C#中Visual Studio如何为解决方案设置启动项目
    alb和clb区别
  • 原文地址：https://blog.csdn.net/Sakurapaid/article/details/138167197