SpringMvc 从 Body 中获取数据的接口开发方式

目前网站开发基本上都是采用前后端分离，所以对于 SpringMvc 来说，大部分情况下可能主要是开发接口，接收静态 html 页面发送来的请求数据，将处理后的数据返回给调用者。在前面的博客中，已经介绍过了许多接收请求数据的方式，其实已经够用了。但是接收请求数据的方式还有很多，而且技术也在不断的发展演变，因此有必要学习更多的接口开发方式。

本篇博客主要介绍从请求 body 中接收数据的接口开发方式，后续会介绍 restful 风格接口的开发方式，掌握了这些接口开发方式后，基本上就可以应对企业中的各种开发场景了。本篇博客的 Demo 做的很简单，在博客的最后会提供 Demo 源代码下载。

一、搭建工程

新建一个 maven 项目，导入相关 jar 包，我所导入的 jar 包都是最新的，内容如下：

有关具体的 jar 包地址，可以在 https://mvnrepository.com 上进行查询。

<dependencies>
    <!--导入 servlet 相关的 jar 包-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.2</version>
        <scope>provided</scope>
    </dependency>
 
    <!--导入 Spring 核心 jar 包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.18</version>
    </dependency>
    <!--导入 SpringMvc 的 jar 包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.18</version>
    </dependency>
 
    <!--导入 jackson 相关的 jar 包-->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.13.1</version>
    </dependency>
</dependencies>

配置好引用的 jar 包后，打开右侧的 Maven 窗口，刷新一下，这样 Maven 会自动下载所需的 jar 包文件。

搭建好的项目工程整体目录比较简单，具体如下图所示：

项目工程结构简单介绍：

com.jobs.config 包下存储的是 SpringMvc 的配置文件和 Servlet 的初始化文件
com.jobs.controller 包下存储的是用于提供 api 接口的类
com.jobs.domain 包下存储的是 JavaBean 实体类

web 目录下放置的是网站文件，只有一个静态页面和一些 js 文件

二、SpringMvc 配置相关

com.jobs.config 下的 SpringMvcConfig 类是 SpringMvc 的配置类，具体内容如下：

package com.jobs.config;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.stereotype.Controller;
import org.springframework.web.servlet.config.annotation.*;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
import org.springframework.web.servlet.view.JstlView;
 
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
 
@Configuration
@ComponentScan("com.jobs")
//启用 mvc 功能，配置了该注解之后，SpringMvc 拦截器放行相关资源的设置，才会生效
@EnableWebMvc
public class SpringMvcConfig implements WebMvcConfigurer {
 
    //配置 SpringMvc 连接器放行常用资源的格式（图片，js，css）
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
 
    //配置响应数据格式所对应的数据处理转换器
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
 
        //如果响应的是 application/json ，则使用 jackson 转换器进行自动处理
        MappingJackson2HttpMessageConverter jsonConverter =
                        new MappingJackson2HttpMessageConverter();
        jsonConverter.setDefaultCharset(Charset.forName("UTF-8"));
        List<MediaType> typelist1 = new ArrayList<>();
        typelist1.add(MediaType.APPLICATION_JSON);
        jsonConverter.setSupportedMediaTypes(typelist1);
        converters.add(jsonConverter);
 
        //如果响应的是 text/html 和 text/plain ，则使用字符串文本转换器自动处理
        StringHttpMessageConverter stringConverter = new StringHttpMessageConverter();
        stringConverter.setDefaultCharset(Charset.forName("UTF-8"));
        List<MediaType> typelist2 = new ArrayList<>();
        typelist2.add(MediaType.TEXT_HTML);
        typelist2.add(MediaType.TEXT_PLAIN);
        stringConverter.setSupportedMediaTypes(typelist2);
        converters.add(stringConverter);
    }
 
    //注解配置 SpringMvc 返回配置的字符串所表示的页面，从哪些去找
    //可以注释掉下面的方法，这样需要在 SpringMvc 方法返回时，指定全局路径的页面地址
    //这里配置的是：根据 SpringMvc 方法返回的字符串，到 /WEB-INF/pages/ 下找对应名称的 jsp 页面
    @Bean
    public InternalResourceViewResolver getViewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/pages/");
        viewResolver.setSuffix(".jsp");
        //如果页面需要使用JSTL标签库的话
        //viewResolver.setViewClass(JstlView.class);
        return viewResolver;
    }
}

ServletInitConfig 类初始化 Servlet 容器，装载 SpringMvc 的配置，具体如下：

package com.jobs.config;
 
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;
 
import javax.servlet.DispatcherType;
import javax.servlet.FilterRegistration;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import java.util.EnumSet;
 
public class ServletInitConfig extends AbstractDispatcherServletInitializer {
 
    //初始化 Servlet 容器，加载 SpringMvc 配置类
    //创建 web 专用的 Spring 容器对象：WebApplicationContext
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext cwa = new AnnotationConfigWebApplicationContext();
        cwa.register(SpringMvcConfig.class);
        return cwa;
    }
 
    //注解配置 SpringMvc 的 DispatcherServlet 拦截地址，拦截所有请求
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
 
    @Override
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }
 
    //在servlet容器启动时进行配置
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        //这行代码不能省略
        super.onStartup(servletContext);
 
        //设置【获取到的请求】的统一字符编码过滤器，
        //无论是【请求、转发、包含】统一使用 UTF-8 编码
        CharacterEncodingFilter cef = new CharacterEncodingFilter();
        cef.setEncoding("UTF-8");
        //注意：这里的过滤器名称必须是 characterEncodingFilter
        FilterRegistration.Dynamic registration =
                       servletContext.addFilter("characterEncodingFilter", cef);
        registration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST,
                       DispatcherType.FORWARD, DispatcherType.INCLUDE), false, "/*");
    }
}

上面这些 SpringMvc 纯注解搭建的细节，没有任何变化，我直接从之前编写的博客中抄了一下，估计看过我之前博客的小伙伴们，已经看吐了。其实 SpringMvc 纯注解搭建，本来就很简单，但是为了保持博客文章的完整性，我还是得保留这些内容。

三、接口开发介绍

还是首选介绍一下 domian 下的 Employee 实体类，具体内容如下：

package com.jobs.domain;
 
import java.io.Serializable;
import java.util.List;
 
public class Employee implements Serializable {
 
    //姓名
    private String name;
    //年龄
    private Integer age;
 
    public Employee() {
    }
 
    public Employee(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
 
    //这里省略了相关字段的 get 和 set 方法...
 
    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
 

然后列出从请求的 body 中获取数据的接口开发方式，内容如下：

package com.jobs.controller;
 
import com.jobs.domain.Employee;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
import java.util.List;
 
//由于接口开发，都是返回数据，不返回页面，所以直接使用 @RestController 注解
@RequestMapping("/api")
@RestController
public class ApiController {
 
    //这里主要演示普通的接口开发，主要通过 ajax 请求调用这里的接口
 
    //请求 body 中发过来文本类型的数据
    @RequestMapping(value = "/test1", produces = "text/plain")
    public String testApi1(@RequestBody String text) {
        System.out.println("接收了发来的文本数据：" + text);
        return "成功接收到数据：" + text;
    }
 
    //请求的 body 中发来的是 Json 数据，
    //并且 Json 数据中的字段名称与 Java 实体类中的字段名称一致
    //此时可以采用 Java 实体类接收 Json 数据，SpringMvc 会自动赋值处理
    @RequestMapping(value = "/test2", produces = "application/json")
    public Employee testApi2(@RequestBody Employee emp) {
        System.out.println("接收了发来的单个 Json 对象数据，自动封装成对象：");
        System.out.println(emp);
 
        System.out.println("我们对 emp 进行修改，然后返回给调用者，修改后的结果为：");
        emp.setName(emp.getName() + "111");
        emp.setAge(emp.getAge() + 10);
        System.out.println(emp);
 
        return emp;
    }
 
    //请求的 body 中发来的是 Json 数组数据，
    //数组中每个 Json 对象的字段名称与 Java 实体类中的字段名称一致
    //此时可以采用 Java 实体类集合接收，SpringMvc 会自动赋值处理并转换为集合
    @RequestMapping(value = "/test3", produces = "application/json")
    public List testApi3(@RequestBody List<Employee> emplist) {
        System.out.println("接收了发来的单个 Json 数组对象数据，自动封装成对象集合：");
        System.out.println(emplist);
 
        System.out.println("我们在 emplist 中增加一个 Employee 对象，然后返回给调用者：");
        emplist.add(new Employee("乔豆豆", 38));
        System.out.println(emplist);
 
        return emplist;
    }
 
    //使用 @CrossOrigin 开启跨域访问
    //如果 @CrossOrigin 标注在方法上，方表示该方法支持跨域访问
    //如果 @CrossOrigin 标注在 Controller 类上，表示该类中的所有方法均支持跨域访问
    @CrossOrigin
    @RequestMapping(value = "/testCross", produces = "text/plain")
    public String testApi4(@RequestBody String msg) {
        System.out.println("跨域访问成功..." + msg);
        return "恭喜你跨域访问成功，获取到的数据为：" + msg;
    }
}

本篇博客决定使用静态 html 页面，采用 JQuery 请求这些接口进行测试，首先列出静态页面的内容：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>演示普通接口的请求和响应</title>
</head>
<body>
<h1>SpringMvc 采用 Ajax 调用普通 Api 接口</h1>
<a href="javascript:void(0);" id="test1">SpringMvc发送普通文本数据</a><br/>
<a href="javascript:void(0);" id="test2">SpringMvc发送单个对象的Json数据</a><br/>
<a href="javascript:void(0);" id="test3">SpringMvc发送多个对象的Json数据（Json数组）</a><br/>
<br/>
 
<fieldset>
    <legend>SpringMvc跨域访问</legend>
    条件准备：<br/>
    1.请在本机的 hosts 文件中配置 www.jobs.com 对应的 ip 地址为 127.0.0.1<br/>
    2.在 SpringMvc 的后端接口上，增加 @CrossOrigin 注解<br/>
    <a href="javascript:return false;" id="testCross">SpringMvc测试跨域访问</a><br/>
</fieldset>
 
<script src="./js/jquery-3.6.0.min.js"></script>
<script src="./js/apitest.js"></script>
</body>
</html>

在该静态页面中，引用了 js 目录中编写的 apitest.js 文件，具体内容如下：

$(function () {
    $('#test1').click(function () {
        $.ajax({
            type: "post",
            url: "/api/test1",
            data: "努力学习，天天向上",
            dataType: "text",
            contentType: "text/plain",
            success: function (data) {
                alert(data);
            }
        });
    });
 
    $('#test2').click(function () {
        $.ajax({
            type: "post",
            url: "/api/test2",
            data: '{"name":"乔豆豆","age":28}',
            dataType: "json",
            contentType: "application/json",
            success: function (data) {
                alert("修改后的结果：" + data.name + "，" + data.age);
            }
        });
    });
 
    $('#test3').click(function () {
        $.ajax({
            type: "post",
            url: "/api/test3",
            data: '[{"name":"任肥肥","age":40},{"name":"侯胖胖","age":42}]',
            dataType: "json",
            contentType: "application/json",
            success: function (data) {
 
                //采用数组存储字符串，最后以中文逗号拼接在一起
                let arr = new Array();
                for (let i = 0; i < data.length; i++) {
                    arr.push(data[i].name + '---' + data[i].age);
                }
 
                let result = arr.join('，');
                alert(result);
            }
        });
    });
 
    $('#testCross').click(function () {
        $.ajax({
            type: "post",
            url: "http://www.jobs.com:8080/api/testCross",
            data: "祝大家事业有成",
            dataType: "text",
            contentType: "text/plain",
            success: function (data) {
                alert(data);
            }
        });
    });
})

然后运行网站，在首页 index.html 静态页面中，即可进行接口的测试。

Ok，有关从 body 中获取请求数据的接口开发方式，已经介绍完毕。这种开发接收的方式比较常用。

本篇博客的 Demo 源代码下载地址为：https://files.cnblogs.com/files/blogs/699532/SpringMvc_DataApi.zip