文章目录

  • 前言
  • 一、请求
  • 1.1简单参数
  • 1.1.1基本方式
  • 1.1.2参数名不一致
  • 1.2实体参数
  • 1.2.1具体实现
  • 1.3数组集合参数
  • 1.3.1数组
  • 1.3.2集合
  • 1.4日期参数
  • 1.4.1具体实现
  • 1.5JSON参数
  • 1.5.1具体实现
  • 1.6路径参数
  • 二、响应
  • 2.1@ResponseBody
  • 2.2统一响应结果
  • 2.3案例
  • 2.3.1需求说明
  • 2.3.2准备工作
  • 2.3.3实现步骤
  • 2.3.4测试
  • 3.分层耦合
  • 3.1三层架构
  • 3.1.1介绍
  • 3.1.2代码拆分
  • 3.2分层解耦
  • 3.2.1耦合问题
  • 3.2.2解耦思想
  • 3.3IOC&DI
  • 3.3.1 IOC&DI入门
  • 3.3.2 IOC详解
  • 3.3.2.1bean的声明
  • 3.3.2.2组件扫描
  • 3.3.3 DI详解
  • 总结


前言

我们在浏览器发起请求，请求了我们的后端web服务器（也就是内置的Tomcat)。而我们在开发web程序时呢，定义了一个控制器类Controller，请求会被部署在Tomcat中的controller接收，然后controller再给浏览器一个响应，响应一个字符串 “Hello World”。而在请求响应的过程中是遵循HTTP协议的。
但是呢，这里要告诉大家的时，其实在Tomcat这类web服务器中，是不识别我们自己定义的Controller的。但是我们前面讲到过Tomcat是一个Servlet容器，是支持Serlvet规范的，所以呢，在tomcat中是可以识别Servlet程序的。 那我们所编写的xxxController 是如何处理请求的，又与Servlet之间有什么联系呢？
其实呢，在SpringBoot进行web程序开发时，它内置了一个核心的servlet程序
dispatcherservlet，称之为 核心控制器。 DispatcherServlet负责接收页面发送的请求，然后根据执行的规则，将请求再转发给后面的请求处理器Controller，请求处理器处理完请求之后，最终再由DispatcherServlet给浏览器响应数据。
那将来浏览器发送请求，会携带请求数据，包括：请求行、请求头；请求到达tomcat之后，tomcat会负责解析这些请求数据，然后呢将解析后的请求数据会传递给Servlet程序的HttpServletRequest 对象，那也就意味着HttpServletRequest 对象就可以获取到请求数据。而Tomcat，还给Servlet程序传递了一个参数 HttpServletResponse，通过这个对象，我们就可以给浏览器设置响应数据。

一、请求

1.1简单参数

1.1.1基本方式

在SringBoot的环境中，如果是简单参数，参数名与形参变量名相同，定义同名的形参即可接收参数。

@RestController
public class RequestController {
@RequestMapping("/simpleParam")
    public String simpleParam(String name, Integer age){
        System.out.println(name + ":" +age);
        return "OK";
    }
}

postman测试（GET 请求）

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_数据


postman测试（POST 请求）

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_实体类_02

1.1.2参数名不一致

对于简单参数来讲，请求参数名和controller方法的形参名不一致时，无法收到请求的数据，且默认为null。
解决方法：可以使用Spring提供的@RequestParam注释完成映射
在方法的形参前面加上@RequestParam然后通过value属性执行请求参数名，从而完成映射，代码如下：

@RestController
public class RequestController {
   @RequestMapping("/simpleParam")
    public String simpleParam(@RequestParam(value = "name",required = false) String username, Integer age){
        System.out.println(username + ":" +age);
        return "OK";
    }
}

执行结果和上面代码一样，同时，@RequestParam中的required属性默认值是ture，代表请求参数必须传递，在上面代码中将name的required改为false，如果没有传递name参数，也不会报错。

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_后端_03

1.2实体参数

将请求参数封装到一个实体类中，减少后端controller方法中的形参书写的个数，让代码更加简单。
封装的规则：请求参数名与实体类的属性名相同。

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_后端_04

1.2.1具体实现

定义POJO实体类：

package com.ithema.pojo;

public class User {
    private String name;
    private Integer age;

    private Address address;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address=" + address +
                '}';
    }
}

Controller方法：

@RequestMapping("/simplePojo")
    public String simplePojo(User user){
        System.out.println(user);
        return "OK";
    }

Postman测试

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_开发语言_05


springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_后端_06

1.3数组集合参数

数组集合参数的使用场景：复选HTML表单
接收一个参数的多个值

1.3.1数组

Controller方法

@RestController
public class RequestController {
@RequestMapping("/arrayParam")
    public String arrayParam(String[] hobby){
        System.out.println(Arrays.toString(hobby));
        return "OK";
    }
}

Postman测试

方式一：

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_数据_07


方式二：

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_数据_08

1.3.2集合

集合参数：请求参数与形参集合对象名相同且请求的参数为多个，@RequestFaram绑定参数关系。

Controller方法

@RestController
public class RequestController {
@RequestMapping("/listParam")
    public String listParam(@RequestParam List<String> hobby){
        System.out.println(hobby);
        return "OK";
    }
}

Postman测试：

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_实体类_09

1.4日期参数

1.4.1具体实现

在对日期类型参数进行封装时，需要通过@DateTimeFormat注解，以及其pattern属性来设置日期的格式。
1.@DateTimeFormat注解的pattern属性中指定了那种日期格式，前端的日期参数就必须按照指定的格式传递。
2.后端controller方法中，需要使用Date类型或LocalDateTime类型，来封装传递的参数。

Controller方法

@RestController
public class RequestController {
@RequestMapping("/dataParam")
    public String dataParam(@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime updateTime){
        System.out.println(updateTime);
        return "OK";
    }
}

Postman测试：

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_实体类_10

1.5JSON参数

1.5.1具体实现

服务端Controller方法接收JSON格式的数据：
1.传递json格式的参数，在Controller中会使用实体类进行封装
2.封装规则：JSON数据键名与形参对象属性名相同，定义POJO类型的形参即可接收参数，需要使用@RequestBody标识。

@RequestBody注释：将JSON数据映射到形参的实体类对象中（JSON中的key和实体类的属性名保持一致）

实体类：Address

public class Address {
    private String province;
    private String city;
    //省略GET,SET 方法

实体类：User

public class User {
    private String name;
    private Integer age;
    private Address address;
    //省略GET,SET 方法

Controller方法

@RestController
public class RequestController {
    @RequestMapping("/jsonParam")
    public String jsonParam(@RequestBody User user){
        System.out.println(user);
        return "OK";
    }
}

Postman测试

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_实体类_11


springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_实体类_12

1.6路径参数

直接在请求的URL中传递参数。例如：

http://localhost:8080/user/1
http://localhost:8080/user/1/0

这种传递请求参数的形式，称为路径参数。
路径参数：
前端：通过请求URL直接传递参数
后端：使用（…）来标识该路径参数，需要使用@PathVariable获取路径参数

Controller方法：

@RestController
public class RequestController {
   @RequestMapping("/path/{id}")
    public String pathParam(@PathVariable Integer id){
        System.out.println(id);
        return "OK";
    }
}

Postman测试

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_实体类_13


springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_java_14

二、响应

2.1@ResponseBody

@RestController = @Controller +_@ResponseBody
@RestController 源码

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

所以在前面所编写的controller方法中，都已经设置了响应数据，且响应给了浏览器

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_开发语言_15

2.2统一响应结果

在前面所编写的Controller方法中，返回值各式各样，没有任何的规范。我们需要定义一个统一的返回结果。

统一的返回结果使用类来描述，在这个结果中包含：
1.响应状态码：当前请求时成功，还是失败
2.状态码信息：给页面的提示信息
3.返回的数据：给前端响应的数据（字符串，对象，集合）

定义一个实体类Result包含以上信息。代码如下：

/**
 * 统一响应结果封装类
 */
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;
    }
    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 +
                '}';
    }
}

改造Controller：

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_开发语言_16


Postman测试

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_java_17

2.3案例

2.3.1需求说明

需求：加载并解析xml文件中的数据，完成数据处理，并在页面展示。
xml文件：

<?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>

获取员工数据，返回统一响应结果，在页面渲染展示。

2.3.2准备工作

案例准备：
1.将已经准备好的（emp.xml）文件导入放到src/main/resources目录下
2.工具类：已经准备好解析xml文件的工具类，无需自己实现，直接创建一个包 com.itheima.utils，然后将文具类拷贝进来。
3.前端资源页面:将准备好的前端页面文件文件拷贝到src/main/resources下的static目录下

Springboot项目的静态资源html,css,js等前端资源默认存放目录为：classpath:/static、classpath:/public、classpath:/resources

2.3.3实现步骤

1.在pom.xml文件中引入dom4j的依赖，用于解析XML文件

<!-- 解析XML -->
        <dependency>
            <groupId>org.dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>2.1.3</version>
        </dependency>

2.引入提前准备好的：解析XML的工具类XMLParaserUtils、实体类Emp、XML文件emp.xml

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_java_18


3.创建EmpController类，编写Controller程序，处理请求，响应数据。

4.代码实现：
Controller代码：

@RestController
public class EmpController {
 @RequestMapping("/listEmp")
    public Result list(){
    //1.加载并解析emp.xml
    String file = this.getClass().getClassLoader().getResource("emp.xml").getFile();
     //System.out.println(file);
    List<Emp> empList = XmlParserUtils.parse(file,Emp.class);

    //2。对数据进行转换处理 -gender,job
        empList.stream().forEach(emp -> {
        //处理 gender 1.男 2.女
        String gender = emp.getGender();
        if("1".equals(gender)){
            emp.setGender("男");
        }else if("2".equals(gender)){
            emp.setGender("女");
        }

        //处理job - 1:讲师，2:班主任,3:就业指导
        String job = emp.getJob();
        if("1".equals(gender)){
            emp.setGender("讲师");
        }else if("2".equals(gender)){
            emp.setGender("班主任");
        }else if("3".equals(gender)) {
            emp.setGender("就业指导");
        }
    });

    //3.响应数据
            return Result.success(empList);
}
}

统一返回结果实体类：

/**
 * 统一响应结果封装类
 */
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;
    }
    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 +
                '}';
    }
}

2.3.4测试

使用Postman测试

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_java_19


打开浏览器，在地址栏输入http://localhost:8080/emp.html

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_实体类_20

3.分层耦合

3.1三层架构

3.1.1介绍

我们在进行程序设计时，尽可能让每一个接口、类、方法的职责简单一些（单一职责原则）。

我们前面开发的程序，并不满足单一职责原则。我们来分析之前的程序：

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_开发语言_21


其实按照上面的处理逻辑，我们可以从组成上分为三个部分：

1.数据访问：负责业务数据的维护操作，包括增、删、改、查等操作。

2.逻辑处理：负责业务逻辑处理的代码。

3.处理请求、响应数据：负责，接收页面的请求，给页面响应数据。

按照上述的组成部分，在我们的项目开发中，可以将代码分为三层：
1、Controller:控制层。接收前端发送的请求，对请求进行处理，并响应数据。
2、Service：业务逻辑层。处理具体的业务逻辑。
3、Dao:数据访问层（Data Access Object），也称为持久层，负责数据的访问操作，包括数据的增、删、改、查。

基于三层架构的程序执行流程：

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_java_22

3.1.2代码拆分

我们使用三层架构思想，改造之前的程序：

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_开发语言_23


控制层：接收前端发送的请求，对请求进行处理，并响应数据。

@RestController//包含Controller
public class EmpController {

 private EmpService empService = new EmpServiceA();

    @RequestMapping("/listEmp")
    public Result list(){
       //1.调用service,获取数据
        List<Emp> empList = empService.listEmp();

        //3.响应数据
            return Result.success(empList);
    }
    }
----------

业务逻辑层：处理具体的业务逻辑
业务接口

public interface EmpService {
    //获取员工列表
    public List<Emp> listEmp();
}

业务实现类

public class EmpServiceA implements com.ithema.serive.EmpService {
    private EmpDao empDao = new EmpDaoA();
     @Override
    public List<Emp> listEmp() {
        //1.调用dao，获取数据
        List<Emp> empList = empDao.listEmp();

        //2。对数据进行转换处理 -gender,job
        empList.stream().forEach(emp -> {
            //处理 gender 1.男 2.女
            String gender = emp.getGender();
            if("1".equals(gender)){
                emp.setGender("男");
            }else if("2".equals(gender)){
                emp.setGender("女");
            }

            //处理job - 1:讲师，2:班主任,3:就业指导
            String job = emp.getJob();
            if("1".equals(job)){
                emp.setJob("讲师");
            }else if("2".equals(job)){
                emp.setJob("班主任");
            }else if("3".equals(job)) {
                emp.setJob("就业指导");
            }
        });
        return empList;
    }
}
----------

数据访问层：负责业务数据的维护操作，包括增、删、改、查。
数据访问接口

public interface EmpDao {
    //获取员工列表数据
    public List<Emp> listEmp();
}

数据访问实现类

@Repository(value = "daoA")//value用来给bean赋值
public class EmpDaoA implements EmpDao {

    @Override
    public List<Emp> listEmp() {
        //1.加载并解析emp.xml
        String file = this.getClass().getClassLoader().getResource("emp.xml").getFile();
        System.out.println(file);
        List<Emp> empList = XmlParserUtils.parse(file,Emp.class);
        return empList;
    }
}

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_数据_24


三层架构的好处：

1、复用性强

2、便于维护

3、利于拓展

3.2分层解耦

3.2.1耦合问题

首先需要了解软件开发涉及到的两个概念：内聚和耦合。
• 内聚：软件中各个功能模块内部的功能联系。
•耦合：衡量软件中各个层/模块之间的依赖、关联的程度。

软件设计原则：高内聚低耦合。

高内聚指的是：一个模块中各个元素之间的联系的紧密程度，如果各个元素(语句、程序段)之间的联系程度越高，则内聚性越高，即“高内聚”。

低耦合指的是：软件中各个层、模块之间的依赖关联程序越低越好。

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_实体类_25


在前面的代码中，耦合程度高了，我们需要进行解耦。

3.2.2解耦思想

1、 首先不能在EmpController中使用new对象
2、提供一个容器，容器中存储一些对象
3、controller程序从容器中获取EmpService类型的对象。

我们要实现上述的解耦操作，就要涉及到Spring中的两核心概念：

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_java_26

3.3IOC&DI

3.3.1 IOC&DI入门

完成前面代码的解耦

思路：

1、删除Controller层、Service层、Dao层中的new对象代码

2、Serive层及Dao层的实现类，交给IOC容器

3、为Controller及Service注入运行时依赖的对象

（1）Controller程序中注入Service层对象

（2）Service程序中注入依赖的Dao层对象

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_实体类_27


运行测试

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_开发语言_28

3.3.2 IOC详解

3.3.2.1bean的声明

bean声明：将对象的控制权交给Spring的IOC容器，由IOC容器创建及管理对象。IOC容器创建的对象称为bean对象。

要把某个对象交给IOC容器管理，需要在对应的类上加上如下注释之一。

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_数据_29


在IOC容器中，每一个Bean都有一个属于自己的名字，可以通过注解的value属性指定bean的名字。如果没有指定，默认为类名首字母小写。

@Repository(value = "daoA")//value用来给bean赋值
3.3.2.2组件扫描

使用四大注解声明的bean，想要生效，还需要被组件扫描注解@ComponentScan扫描

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_实体类_30


手动添加@ComponentScan注解，指定要扫描的包（不推荐）

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_java_31


推荐做法：

将我们定义的controller,service,dao这些包，都放在引导类所在包com.itheima的子包下，这样我们定义的bean就会被自动扫描到。

3.3.3 DI详解

@Autowired注解，默认是按照类型进行自动装配的（去IOC容器中找某个类型的对象，然后完成注入操作）
那如果在IOC容器中，存在多个相同类型的bean对象，会出现什么情况呢？

springboot后台get请求接收多个参数能封装成对象吗 springboot中get请求_java_32


解决方案：

1、使用@Primary注解：当存在多个相同类型的Bean注入时，加上@Primary注解，来确定默认的实现。

@Primary//提高bean的优先级
@Service
public class EmpServiceB implements com.ithema.serive.EmpService {

2、使用@Qualifier注解：指定当前要注入的bean对象。在@Qualifier的value属性中，指定注入的bean的名称。
@Qualifier注解不能单独使用，必须配合@Autowired使用

@RestController//包含Controller
public class EmpController {

  @Qualifier("empServiceA")//指定一个bean
  @Autowired //运行时，IOC容器会提供该类型的bean对象，并且赋值给改变量 - 依赖注入（通过类型来指定bean）
  private EmpService empService;

3、使用@Resource注解：是按照bean的名称进行注入。通过name属性指定要注入的bean的名称。

@RestController//包含Controller
public class EmpController {

    @Resource(name = "empServiceB")//通过名字来指定bean
    private EmpService empService;

总结

通过对Spring Boot Web请求响应的全面剖析，我们希望读者能够更好地理解Spring Boot在Web开发领域的应用，并能够将这些知识应用到实际项目中，提升开发效率和代码质量。无论是初学者还是有经验的开发者，本文都旨在提供一个清晰的指南，帮助大家掌握Spring Boot在Web开发中的关键技能。

随着Spring Boot生态的不断丰富，我们期待在未来的开发实践中，看到更多创新和优化，使得Web应用的开发更加简洁、高效和强大。