前后端请求响应

皓木.2024-11-18 13:33

引入

在之前的例子中，我们编写了一个简单的web类，我们运行启动类，启动内嵌的tomcat后就可以在浏览器通过特定的路径访问tomcat中的应用程序。

但之前编写的程序仅仅是个简单的java类，其并未实现某个接口或继承某个类，因此tomcat并不会识别该程序，也不能够直接运行。虽然他并不识别该程序，但它是识别servlet的，tomcat也称为Servlet容器，而我们基于SpringWeb开发的web入门程序中，SpringBoot底层为我们提供了一个非常核心的servlet------dispathcherServlet，它实现了Servlet规范中的Servlet接口。其在web请求中是个核心类，因此我们称之为核心控制器或前端控制器。

继承关系图：

浏览器发起请求后，tomcat对该请求进行解析，并将解析后的所有请求信息封装到对象HttpServletRequest当中，接下来应用程序再从这个request对象中获取请求数据并处理。

响应数据也类似，程序通过HttpServletResponse设置响应数据。

这种浏览器＋服务器的架构模式称为BS架构，即Browser-Server架构(浏览器-服务器 架构)。用户的电脑上只需要安装一个浏览器，就可以访问服务器上的应用程序和数据，所有的业务逻辑、数据处理和存储都集中在服务器端。

我们常见的京东、淘宝、天猫等等大多数网站都是采用BS架构的，此外还有一种CS架构，仅需了解：CS架构，即Client-Server（客户端-服务器）架构，在这种模型中，用户需要下载客户端来作为请求服务的设备，而服务器则是提供服务的设备。面对不同的操作系统客户端也不同。

两者互有优略，BS无需安装客户端易于访问，跨平台能力强，但服务器负载重、用户体验受限、对网络有依赖、安全性低。CS性能好响应速度快、用户体验丰富、支持离线工作、安全性较高；但维护成本高、跨平台兼容性差、部署复杂。我们后续仍以学习CS为主。

请求

之前我们了解过前后端分离开发模式，此时前端和后端是独立开发的，所以我们在编写后端时无法使用前端的接口。在之前的例子中我们直接在浏览器中输入地址以访问我们所开发的web应用，但其发起的请求都是get请求，如果我们需要测试post请求那就需要编写繁琐的代码。此时我们就可以借助一款功能强大的接口测试工具：postman。

postman

Postman是一款用于网页调试与发送网页Http请求的工具，其之前是chrome浏览器的一款插件，常用于进行接口测试。基于其也延申出了很多例如Apipost、Apifox之类的工具。

一、下载

进入postman官网Postman: The World's Leading API Platform | Sign Up for Free选择对应版本下载、安装、注册账号并登录。(也可直接使用网页版)

二、使用

点击workspace并创建新工作空间，并修改对应选项：

点击send后，在response部分就会返回响应的数据，点击save按钮即可保存文件，下次便可快捷发起。

简单参数

简单参数指传递给服务器端应用程序的单一值或基本数据类型的参数。有两种接收方法：

原始方式

在原始的web程序中，接收简单参数需要通过HttpServletRequest对象手动获取

java 复制代码 
//HelloControl.java文件
@RestController
public class HelloControl {
    @RequestMapping("/getData")
    public String getData(HttpServletRequest request){
        String name=request.getParameter("name");
        String age=request.getParameter("age");
        int myage=Integer.parseInt(age);
        System.out.println(name+":"+age);
        return "OK";
    }
}

并在postman填写对应的参数，点击send，我们可以看到下方传回的数据

但该方式比较繁琐，还需进行类型转换，现阶段我们早已不再使用。而是使用SpringBoot。

SpringBoot

java 复制代码 
//SpringBoot方式
@RestController
public class HelloControl {
    @RequestMapping("/getData")
    public String getData(String name,Integer age){
        System.out.println(name+":"+age);
        return "OK";}}

执行效果相同。也就是说使用此种方法只要参数名对应，即可正确执行，但如果没有对应的参数，则会导致接收不成功但不会报错仍能执行：

java 复制代码 
//SpringBoot方式
@RestController
public class HelloControl {
    @RequestMapping("/getData")
    public String getData(String username,Integer age){//age自动进行类型转换
        System.out.println(username+":"+age);
        return "OK";}}
//idea执行结果：null:20

想要解决这一问题则需要借助Spring中的一个注解：@RequestParam来完成映射

@RequestParam注解

其有一个默认属性required默认为TRUE，代表该参数必须传递，否则会报错，我们可以手动将该属性更改为false，此时系统不会报错而是将username参数设置为null。

java 复制代码 
@RestController
public class HelloControl {
    @RequestMapping("/getData")
    public String getData(@RequestParam(name = "name",required = false)String username, Integer age){
        System.out.println(username+":"+age);
        return "OK";}}
//required默认为true，且postman未传递name参数时，postman端报错
{
    "timestamp": "2024-11-15T10:23:52.509+00:00",
    "status": 400,
    "error": "Bad Request",
    "path": "/getData"
}

实体参数

在简单参数接收中，前端传递了多少个请求参数，我们就要在方法中声明多少个形参来接收。该方法在传递大量参数时操作繁琐，且不便于后期的维护。此时我们就可以将所有的请求参数封装到一个实体类当中，即实体参数。

实体参数是一个复杂的Java对象，通常是一个POJO（Plain Old Java Object），它代表应用程序中的一个领域模型，具有多个属性。例如将name和age两个属性封装到user类中，但该方法要求请求的参数名和实体类的属性名保持一致

java 复制代码 
//定义User类
public class User {
    private String name;
    private Integer age;
//相关方法
}
@RestController
public class HelloControl {
    @RequestMapping("/getData")
    public String getData(User uesr){
        System.out.println(uesr.toString());
        return "OK";}}
//diea输出：User{name='tom', age=20}

以上就是简单实体参数的封装，只需保证请求的参数名和对象的属性名保持一致即可，如果遇到复杂的实体参数时参数名也许进行对应的更改：例如User类中包含另一个类Stu：

java 复制代码 
//User类
public class User {
    private String name;
    private Integer age;
    private Stu stu;//相关方法略
}
//Stu类
public class Stu{
    private String my_Grade;
    private String my_Class;//相关方法略
}
//postman输入
http://localhost:8080/getData?name=tom&age=20&stu.my_Grade=3&stu.my_Class=2
//idea输出
User{name='tom', age=20, stu=Stu{my_Grade='3', my_Class='2'}}

数组、集合参数

在之前的前端学习中，我们知道复选框可一次提交多个属性值，单个值时使用K-V即可，多个值时只需在K-V之间使用&连接即可：http://localhost:8080/getData?name=tom&name=jack。

接收这种参数时，通常有两种接收方式：使用数组接收、使用集合接收，我们依次来看：

数组接收

我们只需在对应方法的形参中声明对应的数组，数组名需与请求参数名保持一致，系统就会将多个属性封装到一个数组中

java 复制代码 
//方法
@RestController
public class HelloControl {
    @RequestMapping("/getData")
    public String getData(String[] name){
        System.out.println(Arrays.toString(name));
        return "OK";}}
//postman
http://localhost:8080/getData?name=tom&name=jack
//控制台
[tom, jack]

集合接收

要求类似：形参中的集合名需与请求参数名一致，并在形参前添加注解

因为其默认封装到数组中，添加该注解即可封装到集合内

java 复制代码 
@RestController
public class HelloControl {
    @RequestMapping("/getData")
    public String getData(@RequestParam List<String> name){
                          //注解          集合<泛型>  集合名
        System.out.println(name);
        return "OK";}}
//其他部分相同

日期参数

在前端传递参数时，格式可能不同，可以是2024-6-6 10:10:10、2024/6/6 10:10:10、2024年6月6日 10时10分10秒等多种不同格式，所以我们需要在后端规定传输的日期格式。

此时还要借助@RequestParam注解

java 复制代码 
//方法
@RestController
public class HelloControl {
    @RequestMapping("/getData")
    public String getData(@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")LocalDateTime time){
                         //注解           (格式="注意MM和HH应大写，其余小写")定义时间类
        System.out.println(time);
        return "OK";
    }
}
//postman
http://localhost:8080/getData?time=2024-06-06+10:09:08//应使用标准的日期时间格式:9写为09
//控制台
2024-06-06T10:09:08//此处"T"为空格编码

JSON参数

json格式的数据在前后端异步交互时使用的频率非常高，我们先来看发送请求：

首先在发送请求时需要更改：在postman中点击body-选中raw-下拉列表选择json，并编写json数据，我们一般通过实体对象接收json数据，这也存在一定的规范要求：需要将json的K与形参对象的属性名保持一致：

在编写代码时需要使用注解@RequestBody使程序接收json格式的数据：

java 复制代码 
//方法
@RestController
public class HelloControl {
    @RequestMapping("/getData")
    public String getData(@RequestBody User uesr) {
                    //注解 java类实例用于接收json数据
        System.out.println(uesr.toString());
        return "OK";}}
//postman
{
    "name":"tom",
    "age":"20", 
    "stu":{
        "my_Grade":"3",
        "my_Class":"2"
        }
}
//控制台输出
User{name='tom', age=20, stu=Stu{my_Grade='3', my_Class='2'}}

路径参数

路径参数通过URL直接传递参数，它即是参数，也是请求路径的一部分：

java 复制代码 
http://localhost:8080/getData/1

在编写方法上，如果按照之前的思路应编写对应的路径：@RequestMapping("/getData/1")，这样就会导致只能访问/getData/1这一路径，但"1"作为参数，其难免发生变动，导致无法访问。

应使用可变参数{参数名}代替"1"：@RequestMapping("/getData/{id}")，这就表明该部分不是固定值，而是一个路径参数，我们再在方法中声明对应的形参id接收该路径参数，路径参数和方法内形参的名字也许保持一致，同时使用注解@PathVariable。

java 复制代码 
@RestController
public class HelloControl {
    @RequestMapping("/getData/{id}")
    public String getData(@PathVariable Integer id) {
        System.out.println(id);
        return "OK";
    }
}

这里传递了一个路径参数，传递多个路径参数也类似，只需在各参数之间以"/"分隔即可，在方法中也需补充对应的形参来接收，注意每个参数前都需添加注解@PathVariabl：

java 复制代码 
//方法
@RestController
public class HelloControl {
    @RequestMapping("/getData/{id}/{name}")
    public String getData(@PathVariable Integer id,@PathVariable String name) {
        System.out.println("第"+id+"个学生名为"+name);
        return "OK";
    }
}
//postman
http://localhost:8080/getData/1/jack
//控制台
第1个学生名为jack

响应

@responsebody

在之前所举的所有例子中，都存在return语句，这就是响应内容。而这些都是依赖于注解@responsebody来实现的。虽然我们未在代码中直接看见该注解，但其实他一直存在：方法顶部的注解@RestController就是@Controller+@ResponseBody两者相结合，按住ctrl键并点击注解@RestController即可查看其源码：

java 复制代码 
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller
@ResponseBody
public @interface RestController {
    @AliasFor(
        annotation = Controller.class
    )
    String value() default "";
}

前三个注解为元注解，后面两个即为@RestController注解，因此在编写方法时，也可直接将注解@RestController替换为@Controller@ResponseBody，效果一样。java注解-CSDN博客文章浏览阅读530次，点赞14次，收藏10次。1、注解（Annotation）也被称为元数据（Metadata）,用于修饰解释包、类、方法、属性、构造器、局部变量等数据信息2、与注释有所不同的是，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息3、在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等，在JavaEE中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁杂代码和XML配置等。https://blog.csdn.net/qq_65501197/article/details/139454255?spm=1001.2014.3001.5502 它可以作用在方法上，也可以作用在类上，其功能就是将方法的返回值之间作为响应数据给客户端浏览器，如果返回值为对象实例或者集合，则会转化为json格式再响应。

上文都是发起请求时获取数据，我们在此重新编写方法以便响应时获取数据：

java 复制代码 
@RestController
public class HelloControl {
    @GetMapping("/getString")
    public String getString() {
        return "Hello, World!";
    }

    @RequestMapping("/getData")
    public String getData() {
        User user = new User("jack", 20, new Stu("3", "2"));
        return user.toString();
    }

    @GetMapping("/getList")
    public List<Stu> getList() {
        List<Stu> users = new ArrayList<>();
        users.add(new Stu("Alice","3"));
        users.add(new Stu("jack","5"));
        return users;
    }
}
//postman及返回数据分别为
http://localhost:8080/getString
Hello, World!
------------------------------------------------------------------------------------------
http://localhost:8080/getData
User{
    name='jack',
    age=20, 
    stu=Stu{
        my_Grade='3', 
        my_Class='2'}}
------------------------------------------------------------------------------------------
http://localhost:8080/getList
[
    {
        "my_Grade": "Alice",
        "my_Class": "3"
    },
    {
        "my_Grade": "jack",
        "my_Class": "5"
    }
]

可以看到响应数据不同，编写的接口也不同，后期难以管理使用，所以我们需设定一个统一的响应结果来满足所有的使用场景。

Result

在开发Web应用程序时，为了提供一致的API响应格式，通常会使用一个统一的响应结果类Result来封装所有操作的结果。这个类通常包含几个关键的属性，如状态码、消息和数据等。使用实体对象Result来响应：

java 复制代码 
public class Result {
    private Integer code ;//响应码 1 成功 , 0 失败
    private String msg; //提示信息
    private Object data; //返回的数据 data

    public Result() {}//无参构造
    public Result(Integer code, String msg, Object data) {//有参构造
        this.code = code;
        this.msg = msg;
        this.data = data;}
    //get和set方法
    public Integer getCode() {return code;}
    public void setCode(Integer code) {this.code = code;}
    public String getMsg() {return msg;}
    public void setMsg(String msg) {this.msg = msg;}
    public Object getData() {return data;}
    public void setData(Object data) {this.data = data;}

    public static Result success(Object data){//需要返回数据
        return new Result(1, "success", data);}
    public static Result success(){//无需返回数据
        return new Result(1, "success", null);}
    public static Result error(String msg){//报错
        return new Result(0, msg, null);}
    
    @Override
    public String toString() {
        return "Result{" +
                "code=" + code +
                ", msg='" + msg + '\'' +
                ", data=" + data +
                '}';}}

我们再来修改之前的代码：

java 复制代码 
@RestController
public class HelloControl {
    @GetMapping("/getString")
    public Result getString() {
        return Result.success("Hello, World!");
    }

    @RequestMapping("/getData")
    public Result getData() {
        return Result.success(new User("jack", 20, new Stu("3", "2")));
    }

    @GetMapping("/getList")
        public Result getList() {
        List<Stu> users = new ArrayList<>();
        users.add(new Stu("Alice","3"));
        users.add(new Stu("jack","5"));
        return Result.success(users);
    }
}
//postman及返回数据分别为------------------------------------------------------
http://localhost:8080/getString
{
    "code": 1,
    "msg": "success",
    "data": "Hello, World!"
}
------------------------------------------------------------------------------------------
http://localhost:8080/getData
{
    "code": 1,
    "msg": "success",
    "data": {
        "name": "jack",
        "age": 20,
        "stu": {
            "my_Grade": "3",
            "my_Class": "2"
        }
    }
}
------------------------------------------------------------------------------------------
http://localhost:8080/getList
{
    "code": 1,
    "msg": "success",
    "data": [
        {
            "my_Grade": "Alice",
            "my_Class": "3"
        },
        {
            "my_Grade": "jack",
            "my_Class": "5"
        }
    ]
}

我们运用一篇案例来练习：获取员工数据，返回统一响应结果

例题

  1. 使用提供的解析xml文件的工具类XMLParserUtils、实体类Emp、XML文件emp.xml，将提供的静态前端页面文件放在resources下的static目录下
  2. 在pom.xml文件中引入dom4j的依赖，用于解析xml文件
  3. 编写Controller程序，处理请求并响应数据
java 复制代码 
//XmlParserUtils工具类
public class XmlParserUtils {
    public static <T> List<T> parse(String file , Class<T> targetClass)  {
        ArrayList<T> list = new ArrayList<T>(); //封装解析出来的数据
        try {
            //1.获取一个解析器对象
            SAXReader saxReader = new SAXReader();
            //2.利用解析器把xml文件加载到内存中,并返回一个文档对象
            Document document = saxReader.read(new File(file));
            //3.获取到根标签
            Element rootElement = document.getRootElement();
            //4.通过根标签来获取 user 标签
            List<Element> elements = rootElement.elements("emp");
            //5.遍历集合,得到每一个 user 标签
            for (Element element : elements) {
                //获取 name 属性
                String name = element.element("name").getText();
                //获取 age 属性
                String age = element.element("age").getText();
                //获取 image 属性
                String image = element.element("image").getText();
                //获取 gender 属性
                String gender = element.element("gender").getText();
                //获取 job 属性
                String job = element.element("job").getText();

                //组装数据
                Constructor<T> constructor = targetClass.getDeclaredConstructor(String.class, Integer.class, String.class, String.class, String.class);
                constructor.setAccessible(true);
                T object = constructor.newInstance(name, Integer.parseInt(age), image, gender, job);
                list.add(object);}
        } catch (Exception e) {
            e.printStackTrace();}
        return list;}}
java 复制代码 
//实体类Emp
public class Emp {
    private String name;
    private Integer age;
    private String image;
    private String gender;
    private String job;
//构造、get、set、toString方法略
}

前端文件放于src-main-resources-static文件下：[https://pan.baidu.com/s/1bk27CBfBADPX0ACmYg4rBw 提取码: nullhttp://通过网盘分享的文件：前端页面 链接: https://pan.baidu.com/s/1bk27CBfBADPX0ACmYg4rBw 提取码: null]( " https://pan.baidu.com/s/1bk27CBfBADPX0ACmYg4rBw 提取码: null")

Springboot项目下的静态资源文件(html，css，js等前端资源)默认存放目录为类路径:/static、类路径:/public、类路径:/resources，对于Maven项目来说src-main-resources即为类路径，因static文件已自动创建，所以本例放在static文件下。

XML 复制代码 
<!--emp.xml数据文件，放在resources目录下-->
<?xml version="1.0" encoding="UTF-8" ?>
<emps>
    <emp>
        <name>金毛狮王</name>
        <age>55</age>
        <image>https://web-framework.oss-cn-hangzhou.aliyuncs.com/web/1.jpg</image>
        <!-- 1: 男, 2: 女 -->
        <gender>1</gender>
        <!-- 1: 讲师, 2: 班主任 , 3: 就业指导 -->
        <job>1</job>
    </emp>

    <emp>
        <name>白眉鹰王</name>
        <age>65</age>
        <image>https://web-framework.oss-cn-hangzhou.aliyuncs.com/web/2.jpg</image>
        <gender>1</gender>
        <job>1</job>
    </emp>

    <emp>
        <name>青翼蝠王</name>
        <age>45</age>
        <image>https://web-framework.oss-cn-hangzhou.aliyuncs.com/web/3.jpg</image>
        <gender>1</gender>
        <job>2</job>
    </emp>

    <emp>
        <name>紫衫龙王</name>
        <age>38</age>
        <image>https://web-framework.oss-cn-hangzhou.aliyuncs.com/web/4.jpg</image>
        <gender>2</gender>
        <job>3</job>
    </emp>
</emps>
XML 复制代码 
<!-- dom4j依赖用于解析XML，添加到pom.xml文件dependencies部分 -->
<dependency>
    <groupId>org.dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>2.1.3</version>
</dependency>

所需资源引入完毕后，即可新建java文件Controller程序，处理请求并响应数据：

java 复制代码 
public class EmpController {
    @RequestMapping("/ListEmp")//在前端的emp.html的钩子函数中定义了路径为/listEmp且无参数，响应时应保持一致
    public Result list(){
        //加载并解析xml文件
        String file=this.getClass().getClassLoader().getResource("emp.xml").getFile();
        List<Emp> empList = XmlParserUtils.parse(file, Emp.class);//解析的文件 封装到该对象中

        //对数据进行转换处理
        empList.stream().forEach(emp -> {//遍历并取得元素
            String gender= emp.getGender();//性别由12换为男女
            if ("1".equals(gender))
                emp.setGender("男");
            else if ("2".equals(gender)) {
                emp.setGender("女");
            }
            String job = emp.getJob();//，职业由123换为学生、学校、企业
            if ("1".equals(job))
                emp.setJob("学生");
            else if ("2".equals(job)) {
                emp.setJob("老师");
            }
            else if ("3".equals(job)) {
                emp.setJob("企业");
            }
        });
        return Result.success(empList);
    }
}
相关推荐
阿华的代码王国13 分钟前
【Bug合集】——Java大小写引起传参失败，获取值为null的解决方案
java·开发语言·springboot
redemption_231 分钟前
mybatis 动态SQL语句
java·jvm·mybatis
北执南念37 分钟前
Mybatis-Plus 多租户插件&属性自动赋值
java·mybatis
Atlasgorov41 分钟前
JAVA_单例模式
java·开发语言·单例模式
BestandW1shEs41 分钟前
设计模式的基本概述
java·设计模式
G皮T42 分钟前
【设计模式】入门 23 种设计模式（代码讲解）
java·设计模式·软件工程·创建型模式·行为型模式·结构型模式
南宫生1 小时前
力扣-Hot100-链表其一【算法学习day.34】
java·学习·算法·leetcode·链表
奔跑的废柴1 小时前
LeetCode 18. 四数之和 Java题解
java·算法·leetcode
写bug写bug1 小时前
探秘 Java 泛型：从类型参数到边界限制与类型擦除
java·后端
北国1372 小时前
蓝桥杯-顺子日期
java·蓝桥杯
热门推荐
01将 HuggingFace 模型转换为 GGUF 及使用 ollama 运行 —— 以 Qwen2-0.5B 为例02聊聊 Python 中的同步原语，为什么有了 GIL 还需要同步原语03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04RAG 实践- Ollama+RagFlow 部署本地知识库05玄机平台应急响应—webshell查杀06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07Unity中PICO实现 隔空取物 和 接触抓取物体08文件或文件夹名称中有空格如何批量去除09Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO10一文介绍回归和分类的本质区别 ！！