SpringBoot的请求响应及其分层解耦

科大第一深情

已于 2023-09-05 09:31:38 修改

阅读量159

点赞数

分类专栏： JavaWeb 文章标签： spring boot 后端 java

于 2023-09-04 23:53:03 首次发布

本文链接：https://blog.csdn.net/m0_64046816/article/details/132641953

版权

JavaWeb 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

SpringBoot的请求响应及其分层解耦

1、请求
2、响应
3、分层解耦

1、请求

1.1 简单参数

简单参数是指请求的参数以普通的参数定义形式传递给服务器，类似String name,int age...这类形式，注意传递过来的实参名字和顺序要和方法里面的形参一模一样，否则就会报错

在这里插入图片描述

@RestController
public class HelloController {
    // 简单的参数
    @RequestMapping("/SimpleParameter")
    public String SimpleParameter(String name,int age){
        System.out.println(name+"==>"+age);
        return "ok";
    }
}

1.2 实体参数

简单实体类

在项目中创建一个实体类来存放传递过来的参数，实参的名字和顺序要和实体类的属性一样，否则得到的数据不完整

在这里插入图片描述

@RestController
public class HelloController {
    @RequestMapping("/userInfo")
    public String userInfo(User user){
        System.out.println(user);
        return "ok";
    }
}

复杂实体类

如果一个实体类里面嵌套这另外一个实体类对象的话，书写实参的时候就要注意书写方

在这里插入图片描述

1.3 数组参数

当实参接收多个名字相同但是值不同的参数时，方法中的形参就可以使用数组的方式来接收，注意数组名要和实参名一样

在这里插入图片描述

@RestController
public class HelloController {
    @RequestMapping("/hobbyArray")
    public String hobbyArray(String hobby[]){
        System.out.println(Arrays.toString(hobby));
        return "ok";
    }
}

1.4 集合参数

当接收的多个参数名字相同，但值不同，就可以用集合参数的形式传递，注意形参的集合名字一定要和实参的名字一样，并且方法的形参一定要用@RequestParam注解修饰，实参的传递形式和数组一样

在这里插入图片描述

@RestController
public class HelloController {
    // 集合参数，接收的多个参数名字相同但值不同，注意形参的集合名一定要和实参名一样
    // 这个形参一定要用@RequestParam注解修饰
    @RequestMapping("/list")
    public String list(@RequestParam ArrayList<String> hobby){
        System.out.println(hobby);
        return "ok";
    }
}

1.5 日期参数

封装日期格式的参数时，在形参列表的最前面，一定要调用@DateTimeFormat(pattern = "日期格式")的注解，如果传入的日期数据和规定的日期格式不一样就会报错

在这里插入图片描述

@RestController
public class HelloController {
    // 封装日期格式的时候，在形参列表的最前面，一定要调用@DateTimeFormat(pattern = "日期格式")注解
    @RequestMapping("/date")
    public String date(@DateTimeFormat(pattern = "yyyy-MM-dd")LocalDate localDate ){
        System.out.println(localDate);
        return "ok";
    }
}

1.6 JSON参数

JSON格式传递数据，一定要用post发送请求并且要用实体类来接收，实参的属性名一定要和实体类中的属性名一样，注意，一定要在方法形参的前面加上@RequestBody注解，把实参的值反射到实体类对象中

在这里插入图片描述

@RestController
public class HelloController {
    // json格式传递数据，一定要用post发送请求，实参的属性名一定要和实体类里面的属性名一样
    // 并且一定要在方法形参的前面加上@RequestBody注解，把实参的值反射到实体类对象中
    @RequestMapping("/json")
    public String json(@RequestBody Student student){
        System.out.println(student);
        return "ok";
    }
}

1.7 路径参数

路径参数就是把所要传输的数据直接放在路径中，无需定义参数的名字，后端接收的时候要在接口路径定义{xxx}来接收参数，并且在定义方法形参的时候，有多少个参数路径就要使用多少个@PathVariable注解来获取参数

在这里插入图片描述

@RestController
public class HelloController {
    // 路径参数
    @RequestMapping("/path/{id}/{name}")
    public String path(@PathVariable Integer id,@PathVariable String name){
        System.out.println(id+"==>"+name);
        return "ok";
    }
}

2、响应

当我们从后端响应数据给前端的时候，往往响应的数据类型都是不同，这就使得前端解析数据的难度大大提升，而且要做很多重复的工作，那么如果我们给前端响应的数据格式都是一样的话，只运用一种方式就可以完成数据的解析，这样就会大大提高我们的开发效率，所以我们要对响应的数据进行统一的封装

在这里插入图片描述

我们现在创建一个类来对数据进行封装，一般我们响应给前端的封装格式包括状态码code、响应消息msg和响应数据data

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

在这里插入图片描述

3、分层解耦

我们开发中遵循'高内聚，低耦合'的设计原则，因此，在一个软件系统中，应当尽量保证模块的独立性，模块实现功能职责单一，越简单越好。这样有利于系统复用，并且大大减少模块之间的依赖，系统稳定性高，更易于维护。学习分层解耦，我们要先学习SpringBoot框架的三层架构，所谓三层架构就是把一个业务分为三部分

Controller层：负责接收和响应数据
Service层：负责业务的逻辑处理，并将处理好的数据返回给Controller层
Dao层：负责把拿到要处理的数据并返回给Service层处理

入门小案例(此案例仅是为了介绍三层架构而设计)：前端页面对一件商品进行修改操作，传入这件商品的编号和降低的价格，后端处理好后返回这个页面所有的商品信息以便更新整个页面，那我们对整个业务进行分析如下：

Controller层接收数据后传递给Service层
Service层接收到参数后通知Dao层取出数据
Dao层取出数据后返回给Service层(实际开发中我们使用数据库来存储数据，此案例就用集合来存储对应数据)
Service层接收到数据按照逻辑对数据进行处理后把数据返回给Controller层
Controller层接收到Service层返回的数据并对数据进行封装后响应给前端人员

为了方便，这里只展示三层架构的核心代码

Controller层

@RestController
public class UserController {
    private UserService service = new UserServiceImpl();
    @RequestMapping("/user")
    public Result user(String id, Double price){
        ArrayList<Foods> list = service.changePrice(id,price);
        return Result.ok("修改成功~",list);
    }
}

Service层

public interface UserDao {
    ArrayList<Foods> changePrice();
}

public class UserServiceImpl implements UserService {
    // 创建Dao层的对象用来通知Dao层取出数据
    private UserDao dao = new UserDaoImpl();
    @Override
    public ArrayList<Foods> changePrice(String id, Double price) {
        // 通知Dao层取出数据
        ArrayList<Foods> list = dao.changePrice();
        for (Foods food : list) {
            if(food.getId().equals(id)){
                food.setPrice(price);
                break;
            }
        }
        return list;
    }
}

Dao层

public interface UserService {
    ArrayList<Foods> changePrice(String id, Double price);
}

public class UserDaoImpl implements UserDao {
    @Override
    public ArrayList<Foods> changePrice() {
        // 取出数据
        return Foods.list;
    }
}

数据源

public class Foods {
    private String name;
    private String id;
    private Double price;

    public static ArrayList<Foods> list = new ArrayList<>();

    static {
        list.add(new Foods("小米10","001",3999.0));
        list.add(new Foods("苹果13","002",6888.0));
        list.add(new Foods("华为Mate50","003",4500.0));
    }
    // 构造方法和set、get方法........
}

在这里插入图片描述

虽然这样写层次清晰，但是有一个很大的弊端，就是耦合性太大，一但所依赖的程序出现异常，那整个程序就会崩溃掉，这样就要陷入无限找bug的步骤了~~

在这里插入图片描述

SpringBoot框架提供了一个方法，就是把创建Service层和Dao层对象的权限交给Spring管理，简称IOC，也叫控制反转；然后再通过DI依赖注入自动创建其对象给对应的类使用

我们只需要在Service层的实现类加上@Service注解，以及在Dao层实现类加上@Repository注解就可以把类交给Spring管理
在定义Service层和Dao层的实现类对象时加上@Autowired注解，这样Spring就可以在使用到对应的对象时自动创建，把创建对象的权限交给Spring完成解耦

Controller层

@RestController
public class UserController {
    @Autowired
    private UserService service = new UserServiceImpl();

    @RequestMapping("/user")
    public Result user(String id, Double price){
        ArrayList<Foods> list = service.changePrice(id,price);
        return Result.ok("修改成功~",list);
    }
}

Service层

public interface UserDao {
    ArrayList<Foods> changePrice();
}

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    // 创建Dao层的对象用来通知Dao层取出数据
    private UserDao dao;

    @Override
    public ArrayList<Foods> changePrice(String id, Double price) {
        // 通知Dao层取出数据
        ArrayList<Foods> list = dao.changePrice();
        for (Foods food : list) {
            if(food.getId().equals(id)){
                food.setPrice(price);
                break;
            }
        }
        return list;
    }
}

Dao层

public interface UserService {
    ArrayList<Foods> changePrice(String id, Double price);
}

@Repository
public class UserDaoImpl implements UserDao {
    @Override
    public ArrayList<Foods> changePrice() {
        // 去除数据
        return Foods.list;
    }
}