当前位置：首页 > news >正文

SpringBootWeb响应

news 2024/11/15 4:36:41

2. 响应

前面我们学习过HTTL协议的交互方式：请求响应模式（有请求就有响应）
那么Controller程序呢，除了接收请求外，还可以进行响应。

2.1 @ResponseBody

在我们前面所编写的controller方法中，都已经设置了响应数据。
在这里插入图片描述
controller方法中的return的结果，怎么就可以响应给浏览器呢？
答案：使用@ResponseBody注解
@ResponseBody注解：

类型：方法注解、类注解
位置：书写在Controller方法上或类上
作用：将方法返回值直接响应给浏览器
- 如果返回值类型是实体对象/集合，将会转换为JSON格式后在响应给浏览器
说明：@RestController = @Controller + @ResponseBody

但是在我们所书写的Controller中，只在类上添加了@RestController注解、方法添加了
@RequestMapping注解，并没有使用@ResponseBody注解，怎么给浏览器响应呢？

@RestController
public class HelloController {@RequestMapping("/hello")public String hello(){System.out.println("Hello World ~");return "Hello World ~";}
}

原因：在类上添加的@RestController注解，是一个组合注解。

@RestController = @Controller + @ResponseBody

@RestController源码：

@Target({ElementType.TYPE}) //元注解（修饰注解的注解）
@Retention(RetentionPolicy.RUNTIME) //元注解
@Documented //元注解
@Controller
@ResponseBody
public @interface RestController {@AliasFor(annotation = Controller.class)String value() default "";
}

结论：在类上添加@RestController就相当于添加了@ResponseBody注解。

类上有@RestController注解或@ResponseBody注解时：表示当前类下所有的方法返回值做为响应数据
- 方法的返回值，如果是一个POJO对象或集合时，会先转换为JSON格式，在响应给浏览器

下面我们来测试下响应数据：

@RestController
public class ResponseController {//响应字符串@RequestMapping("/hello")public String hello(){System.out.println("Hello World ~");return "Hello World ~";}//响应实体对象@RequestMapping("/getAddr")public Address getAddr(){Address addr = new Address(); //创建实体类对象addr.setProvince("广东");addr.setCity("深圳");return addr;}//响应集合数据@RequestMapping("/listAddr")public List<Address> listAddr(){List<Address> list = new ArrayList<>(); //集合对象Address addr = new Address();addr.setProvince("广东");addr.setCity("深圳");Address addr2 = new Address();addr2.setProvince("陕西");addr2.setCity("西安");list.add(addr);list.add(addr2);return list;}
}

在服务端响应了一个对象或者集合，那私前端获取到的数据是什么样子的呢？我们使用postman发送请求来测试下。测试效果如下：
在这里插入图片描述

2.2 统一响应结果

我们在前面所编写的这些Controller方法中，返回值各种各样，没有任何的规范。
在这里插入图片描述

如果我们开发一个大型项目，项目中controller方法将成千上万，使用上述方式将造成整个项目难以
维护。那在真实的项目开发中是什么样子的呢？
在真实的项目开发中，无论是哪种方法，我们都会定义一个统一的返回结果。方案如下：
在这里插入图片描述

前端：只需要按照统一格式的返回结果进行解析(仅一种解析方案)，就可以拿到数据。

统一的返回结果使用类来描述，在这个结果中包含：

响应状态码：当前请求是成功，还是失败
状态码信息：给页面的提示信息
返回的数据：给前端响应的数据（字符串、对象、集合）

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

public class Result {private Integer code;// 响应码，1 代表成功; 0 代表失败private String msg; // 响应码 描述字符串private Object 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(){return new Result(1,"success",null);}// 查询 成功响应(把查询结果做为返回数据响应给前端)public static Result success(Object data){return new Result(1,"success",data);}// 失败响应public static Result error(String msg){return new Result(0, msg, null);}
}

改造Controller：

@RestController
public class ResponseController {// 响应统一格式的结果@RequestMapping("/hello")public Result hello(){System.out.println("Hello World ~");// return new Result(1,"success","Hello World ~");return Result.success("Hello World ~");}// 响应统一格式的结果@RequestMapping("/getAddr")public Result getAddr(){Address addr = new Address();addr.setProvince("广东");addr.setCity("深圳");return Result.success(addr);}// 响应统一格式的结果@RequestMapping("/listAddr")public Result listAddr(){List<Address> list = new ArrayList<>();Address addr = new Address();addr.setProvince("广东");addr.setCity("深圳");Address addr2 = new Address();addr2.setProvince("陕西");addr2.setCity("西安");list.add(addr);list.add(addr2);return Result.success(list);}
}

使用Apifox测试：
在这里插入图片描述

在这里插入图片描述

2.3 案例

需求：加载并解析xml文件中的数据，完成数据处理，并在页面展示
在这里插入图片描述

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

2.3.2 准备工作

案例准备：

XML文件
- 已经准备好(emp.xml)，直接导入进来，放在 src/main/resources目录下
工具类
- 已经准备好解析XML文件的工具类，无需自己实现
- 直接在创建一个包 com.itheima.utils ，然后将工具类拷贝进来
前端页面资源
- 已经准备好，直接拷贝进来，放在src/main/resources下的static目录下

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

在SpringBoot项目中，静态资源默认可以存放的目录：
· classpath:/static/
· classpath:/public/
· classpath:/resources/
· classpath:/META-INF/resources/
classpath：
· 代表的是类路径，在maven的项目中，其实指的就是 src/main/resources 或者
src/main/java，但是java目录是存放java代码的，所以相关的配置文件及静态资源文
档，就放在 src/main/resources下。

2.3.3 实现步骤

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

<dependency><groupId>org.dom4j</groupId><artifactId>dom4j</artifactId><version>2.1.3</version>
</dependency>

引入资料中提供的：解析XML的工具类XMLParserUtils、实体类Emp、XML文件emp.xml

在这里插入图片描述
3. 引入资料中提供的静态页面文件，放在resources下的static目录下

在这里插入图片描述
4. 创建EmpController类，编写Controller程序，处理请求，响应数据

2.3.4 代码实现

Controller代码：

package com.itheima.controller;import com.itheima.pojo.Emp;
import com.itheima.pojo.Result;
import com.itheima.utils.XmlParserUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import java.util.List;@RestController
public class EmpController {@RequestMapping("/listEmp")public Result listEmp() {// 1、加载并解析xmlString file = this.getClass().getClassLoader().getResource("emp.xml").getFile();System.out.println(file);List<Emp> empList = XmlParserUtils.parse(file, Emp.class);// 2、数据转换 gender、jobempList.stream().forEach((emp) -> {// 处理gender 1：男，2“女String gender = emp.getGender();if ("1".equals(gender)) {emp.setGender("男");} else {emp.setGender("女");}// 处理job 1：讲师，2：班主任，3：就业指导String job = emp.getJob();if ("1".equals(job)) {emp.setJob("讲师");} else if ("2".equals(job)) {emp.setJob("班主任");} else {emp.setJob("就业指导");}});// 3、响应数据return Result.success(empList);}
}

统一返回结果实体类：

package com.itheima.pojo;/*** 统一响应结果封装类*/
public class Result {private Integer code; // 响应码，1 代表成功; 0 代表失败private String msg; // 响应码，描述字符串private Object 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() {return new Result(1, "success", null);}// 查询 成功响应(把查询结果做为返回数据响应给前端)public static Result success(Object data) {return new Result(1, "success", data);}// 失败响应public static Result error(String msg) {return new Result(0, msg, null);}@Overridepublic String toString() {return "Result{" +"code=" + code +", msg='" + msg + '\'' +", data=" + data +'}';}
}

2.3.5 测试

代码编写完毕之后，我们就可以运行引导类，启动服务进行测试了。
使用Apifox测试：
在这里插入图片描述
打开浏览器，在浏览器地址栏输入： http://localhost:8080/emp.html

2.3.6 问题分析

上述案例中：解析XML数据，获取数据的代码，处理数据的逻辑的代码，给页面响应的代码全部都堆积在一起了，全部都写在controller方法中了。
在这里插入图片描述
当前程序的这个业务逻辑还是比较简单的，如果业务逻辑再稍微复杂一点，我们会看到Controller方
法的代码量就很大了。

当我们要修改操作数据部分的代码，需要改动Controller
当我们要完善逻辑处理部分的代码，需要改动Controller
当我们需要修改数据响应的代码，还是需要改动Controller

这样呢，就会造成我们整个工程代码的复用性比较差，而且代码难以维护。那如何解决这个问题呢？
其实在现在的开发中，有非常成熟的解决思路，那就是分层开发。

3. 分层解耦

3.1 三层架构

3.1.1 介绍

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

单一职责原则：一个类或一个方法，就只做一件事情，只管一块功能。
这样就可以让类、接口、方法的复杂度更低，可读性更强，扩展性更好，也更利用后期的维护。

我们之前开发的程序呢，并不满足单一职责原则。下面我们来分析下之前的程序：
在这里插入图片描述
那其实我们上述案例的处理逻辑呢，从组成上看可以分为三个部分：

数据访问：负责业务数据的维护操作，包括增、删、改、查等操作。
逻辑处理：负责业务逻辑处理的代码。
请求处理、响应数据：负责，接收页面的请求，给页面响应数据。

按照上述的三个组成部分，在我们项目开发中呢，可以将代码分为三层：
在这里插入图片描述

Controller：控制层。接收前端发送的请求，对请求进行处理，并响应数据。
Service：业务逻辑层。处理具体的业务逻辑。
Dao：数据访问层(Data Access Object)，也称为持久层。负责数据访问操作，包括数据的
增、删、改、查。

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

前端发起的请求，由Controller层接收（Controller响应数据给前端）
Controller层调用Service层来进行逻辑处理（Service层处理完后，把处理结果返回给Controller层）
Serivce层调用Dao层（逻辑处理过程中需要用到的一些数据要从Dao层获取）
Dao层操作文件中的数据（Dao拿到的数据会返回给Service层）

思考：按照三层架构的思想，如何要对业务逻辑(Service层)进行变更，会影响到Controller 层和Dao层吗？答案：不会影响。
（程序的扩展性、维护性变得更好了）

3.1.2 代码拆分

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

控制层包名：xxxx.controller
业务逻辑层包名：xxxx.service
数据访问层包名：xxxx.dao

在这里插入图片描述

3.1.2.1 控制层

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

@RestController
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);}
}

3.1.2.2 业务逻辑层

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

业务接口

// 业务逻辑接口（制定业务标准）
public interface EmpService {// 获取员工列表public List<Emp> listEmp();
}

业务实现类

// 业务逻辑实现类（按照业务标准实现）
public class EmpServiceA implements EmpService {// dao层对象private EmpDao empDao = new EmpDaoA();@Overridepublic List<Emp> listEmp() {// 1. 调用dao, 获取数据List<Emp> empList = empDao.listEmp();// 2. 对数据进行转换处理 - gender, jobempList.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;}
}

3.1.2.3 数据访问层

数据访问层：负责数据的访问操作，包含数据的增、删、改、查

数据访问接口

// 数据访问层接口（制定标准）
public interface EmpDao {// 获取员工列表数据public List<Emp> listEmp();
}

数据访问实现类

// 数据访问实现类
public class EmpDaoA implements EmpDao {@Overridepublic List<Emp> listEmp() {// 1. 加载并解析emp.xmlString file =this.getClass().getClassLoader().getResource("emp.xml").getFile();System.out.println(file);List<Emp> empList = XmlParserUtils.parse(file, Emp.class);return empList;}
}

在这里插入图片描述
三层架构的好处：

复用性强
便于维护
利用扩展

3.2 分层解耦

刚才我们学习过程序分层思想了，接下来呢，我们来学习下程序的解耦思想。
解耦：解除耦合。

3.2.1 耦合问题

首先需要了解软件开发涉及到的两个概念：内聚和耦合。

内聚：软件中各个功能模块内部的功能联系。
耦合：衡量软件中各个层/模块之间的依赖、关联的程度。

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

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

程序中高内聚的体现：

EmpServiceA类中只编写了和员工相关的逻辑处理代码

在这里插入图片描述
程序中耦合代码的体现：

把业务类变为EmpServiceB时，需要修改controller层中的代码

在这里插入图片描述
高内聚、低耦合的目的是使程序模块的可重用性、移植性大大增强。

3.2.2 解耦思路

之前我们在编写代码时，需要什么对象，就直接new一个就可以了。这种做法呢，层与层之间代码就耦合了，当service层的实现变了之后，我们还需要修改controller层的代码。
在这里插入图片描述
那应该怎么解耦呢？

首先不能在EmpController中使用new对象。代码如下：

在这里插入图片描述

此时，就存在另一个问题了，不能new，就意味着没有业务层对象（程序运行就报错），怎么办呢？
- 我们的解决思路是：
  - 提供一个容器，容器中存储一些对象(例：EmpService对象)
  - controller程序从容器中获取EmpService类型的对象

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

控制反转： Inversion Of Control，简称IOC。对象的创建控制权由程序自身转移到外部（容器），这种思想称为控制反转。

对象的创建权由程序员主动创建转移到容器(由容器创建、管理对象)。这个容器称为：IOC
容器或Spring容器

依赖注入： Dependency Injection，简称DI。容器为应用程序提供运行时，所依赖的资源，称之为依赖注入。

程序运行时需要某个资源，此时容器就为其提供这个资源。
例：EmpController程序运行时需要EmpService对象，Spring容器就为其提供并注入 EmpService对象

IOC容器中创建、管理的对象，称之为：bean对象

3.3 IOC（控制反转）&DI（依赖注入）

上面我们引出了Spring中IOC和DI的基本概念，下面我们就来具体学习下IOC和DI的代码实现。

3.3.1 IOC&DI入门

任务：完成Controller层、Service层、Dao层的代码解耦

思路：
1. 删除Controller层、Service层中new对象的代码
2. Service层及Dao层的实现类，交给IOC容器管理
3. 为Controller及Service注入运行时依赖的对象
  Controller程序中注入依赖的Service层对象
  Service程序中注入依赖的Dao层对象

第1步：删除Controller层、Service层中new对象的代码

在这里插入图片描述
第2步：Service层及Dao层的实现类，交给IOC容器管理

使用Spring提供的注解：@Component ，就可以实现类交给IOC容器管理

在这里插入图片描述
第3步：为Controller及Service注入运行时依赖的对象

使用Spring提供的注解：@Autowired ，就可以实现程序运行时IOC容器自动注入需要的依赖对象

在这里插入图片描述
完整的三层代码：

Controller层：

@RestController
public class EmpController {@Autowired //运行时,从IOC容器中获取该类型对象,赋值给该变量private EmpService empService;@RequestMapping("/listEmp")public Result listEmp() {// ...List<Emp> empList = empService.listEmp();// 3、响应数据return Result.success(empList);}
}

Service层：

@Component //将当前对象交给IOC容器管理,成为IOC容器的bean
public class EmpServiceB implements EmpService {@Autowired //运行时,从IOC容器中获取该类型对象,赋值给该变量private EmpDao empDao;@Overridepublic List<Emp> listEmp() {List<Emp> listEmp = empDao.listEmp();// 数据转换 gender、joblistEmp.stream().forEach((emp) -> {String gender = emp.getGender();// gender 1：男，2：女if ("1".equals(gender)) {emp.setGender("男士");} else {emp.setGender("女士");}String job = emp.getJob();// job 1: 讲师, 2: 班主任 , 3: 就业指导if ("1".equals(job)) {emp.setJob("讲师");} else if ("2".equals(job)) {emp.setJob("班主任");} else {emp.setJob("就业指导");}});return listEmp;}
}

Dao层：

@Component //将当前对象交给IOC容器管理,成为IOC容器的bean
public class EmpDaoA implements EmpDao {@Overridepublic List<Emp> listEmp() {// 1. 加载并解析emp.xmlString file = this.getClass().getClassLoader().getResource("emp.xml").getFile();System.out.println(file);List<Emp> empList = XmlParserUtils.parse(file, Emp.class);return empList;}
}

运行测试：
启动SpringBoot引导类，打开浏览器，输入：http://localhost:8080/emp.html

3.3.2 IOC详解

通过IOC和DI的入门程序呢，我们已经基本了解了IOC和DI的基础操作。接下来呢，我们学习下IOC控
制反转和DI依赖注入的细节。

3.3.2.1 bean的声明

前面我们提到IOC控制反转，就是将对象的控制权交给Spring的IOC容器，由IOC容器创建及管理对
象。IOC容器创建的对象称为bean对象。

在之前的入门案例中，要把某个对象交给IOC容器管理，需要在类上添加一个注解：@Component

而Spring框架为了更好的标识web应用程序开发当中，bean对象到底归属于哪一层，又提供了
@Component的衍生注解：

@Controller （标注在控制层类上）
@Service （标注在业务层类上）
@Repository （标注在数据访问层类上）

修改入门案例代码：

Controller层：

@RestController //@RestController = @Controller + @ResponseBody
public class EmpController {@Autowired //运行时,从IOC容器中获取该类型对象,赋值给该变量private EmpService empService;@RequestMapping("/listEmp")public Result listEmp() {// 1、调用service, 获取数据List<Emp> empList = empService.listEmp();// 3、响应数据return Result.success(empList);}
}

Service层：

//@Component
@Service
public class EmpServiceB implements EmpService {@Autowired //运行时,从IOC容器中获取该类型对象,赋值给该变量private EmpDao empDao;@Overridepublic List<Emp> listEmp() {// 1. 调用dao, 获取数据List<Emp> listEmp = empDao.listEmp();// 2. 对数据进行转换处理 - gender, joblistEmp.stream().forEach((emp) -> {String gender = emp.getGender();// gender 1：男，2：女if ("1".equals(gender)) {emp.setGender("男士");} else {emp.setGender("女士");}String job = emp.getJob();// job 1: 讲师, 2: 班主任 , 3: 就业指导if ("1".equals(job)) {emp.setJob("讲师");} else if ("2".equals(job)) {emp.setJob("班主任");} else {emp.setJob("就业指导");}});return listEmp;}
}

Dao层：

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

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

注解	说明	位置
@Controller	@Component的衍生注解	标注在控制器类上
@Service	@Component的衍生注解	标注在业务类上
@Repository	@Component的衍生注解	标注在数据访问类上（由于与mybatis整合，用的少）
@Component	声明bean的基础注解（由于与mybatis整合，用的少）	不属于以上三类时，用此注解