SpringBootWeb案例 Part 1-CSDN博客

已注销
133 阅读26分钟

目录

1. 准备工作

1.1 需求&环境搭建

1.1.1 需求说明

1.1.2 环境搭建  

1.2 开发规范 

2. 部门管理

2.1 查询部门

2.1.1 原型和需求  

2.1.2 接口文档

2.1.3 思路分析

2.1.4 功能开发

2.1.5 功能测试

2.2 前后端联调

2.3 删除部门

2.3.1 需求

2.3.2 接口文档

2.3.3 思路分析

2.3.4 功能开发

2.3.5 功能测试

2.3.6 前后端联调

2.4 新增部门

2.4.1 需求

​编辑

2.4.2 接口文档

2.4.3 思路分析

2.4.4 功能开发

2.4.5 功能测试

2.4.6 前后端联调

2.4.7 请求路径

2.5 修改部门

2.5.1 需求 

2.5.2 接口文档 

2.5.3 思路分析 

2.5.4 功能开发 

DeptController  

DeptService

DeptServiceImpl

DeptMapper

2.5.5 功能测试 

D通过该综合案例，我们就可以知道，在开发一个Web程序时，前端程序、后端程序以及数据库这三者之间是如何交互、如何协作的，而通过这个综合案例也需要掌握根据接口文档开发服务端接口的能力。

而这个案例呢，就是Tlias智能学习辅助系统。

产品经理所绘制的页面原型：

在这个案例中，前端开发人员已经将前端工程开发完毕了。 我们需要做的，就是参考接口文档完成后端功能的开发，然后结合前端工程进行联调测试即可。  

完成后的成品效果展示：  

今天的主要内容如下：

  • 准备工作
  • 部门管理
  • 员工管理

1. 准备工作

准备工作的学习，我们先从"需求"和"环境搭建"开始入手。

1.1 需求&环境搭建

1.1.1 需求说明

1、部门管理  

部门管理功能开发包括：

  • 查询部门列表
  • 删除部门
  • 新增部门
  • 修改部门

2、员工管理  

员工管理功能开发包括：

  • 查询员工列表(分页、条件)
  • 删除员工
  • 新增员工
  • 修改员工

说白了就是完成部门管理和员工管理的增删改查功能。

1.1.2 环境搭建  

前端程序会发起请求来请求后端，也就是服务端，服务端接收到请求之后再来操作数据库，而这个请求处理完毕之后，服务端再给前端响应结果。 

步骤：

  1. 准备数据库表(dept、emp)
  2. 创建springboot工程，引入对应的起步依赖（web、mybatis、mysql驱动、lombok）
  3. 配置文件application.properties中引入mybatis的配置信息，准备对应的实体类
  4. 准备对应的Mapper接口、Service(接口、实现类)、Controller基础结构

web：web开发的起步依赖

Controller控制层仅仅负责接收请求、处理响应；Service业务层负责具体的逻辑处理；而Mapper数据访问层就负责数据访问操作。

为了增强程序的灵活性，并且方便我们层与层之间解耦，我们会采用面向接口的方式编程，所以Service层我们在准备的时候，还需要准备Service业务层的接口，而这个Mapper本身就是一个接口。

第1步：准备数据库表

-- 部门管理
create table dept(
    id int unsigned primary key auto_increment comment '主键ID',
    name varchar(10) not null unique comment '部门名称',
    create_time datetime not null comment '创建时间',
    update_time datetime not null comment '修改时间'
) comment '部门表';
-- 部门表测试数据
insert into dept (id, name, create_time, update_time) values(1,'学工部',now(),now()),(2,'教研部',now(),now()),(3,'咨询部',now(),now()), (4,'就业部',now(),now()),(5,'人事部',now(),now());



-- 员工管理(带约束)
create table emp (
  id int unsigned primary key auto_increment comment 'ID',
  username varchar(20) not null unique comment '用户名',
  password varchar(32) default '123456' comment '密码',
  name varchar(10) not null comment '姓名',
  gender tinyint unsigned not null comment '性别, 说明: 1 男, 2 女',
  image varchar(300) comment '图像',
  job tinyint unsigned comment '职位, 说明: 1 班主任,2 讲师, 3 学工主管, 4 教研主管, 5 咨询师',
  entrydate date comment '入职时间',
  dept_id int unsigned comment '部门ID',
  create_time datetime not null comment '创建时间',
  update_time datetime not null comment '修改时间'
) comment '员工表';
-- 员工表测试数据
INSERT INTO emp
	(id, username, password, name, gender, image, job, entrydate,dept_id, create_time, update_time) VALUES
	(1,'jinyong','123456','金庸',1,'1.jpg',4,'2000-01-01',2,now(),now()),
	(2,'zhangwuji','123456','张无忌',1,'2.jpg',2,'2015-01-01',2,now(),now()),
	(3,'yangxiao','123456','杨逍',1,'3.jpg',2,'2008-05-01',2,now(),now()),
	(4,'weiyixiao','123456','韦一笑',1,'4.jpg',2,'2007-01-01',2,now(),now()),
	(5,'changyuchun','123456','常遇春',1,'5.jpg',2,'2012-12-05',2,now(),now()),
	(6,'xiaozhao','123456','小昭',2,'6.jpg',3,'2013-09-05',1,now(),now()),
	(7,'jixiaofu','123456','纪晓芙',2,'7.jpg',1,'2005-08-01',1,now(),now()),
	(8,'zhouzhiruo','123456','周芷若',2,'8.jpg',1,'2014-11-09',1,now(),now()),
	(9,'dingminjun','123456','丁敏君',2,'9.jpg',1,'2011-03-11',1,now(),now()),
	(10,'zhaomin','123456','赵敏',2,'10.jpg',1,'2013-09-05',1,now(),now()),
	(11,'luzhangke','123456','鹿杖客',1,'11.jpg',5,'2007-02-01',3,now(),now()),
	(12,'hebiweng','123456','鹤笔翁',1,'12.jpg',5,'2008-08-18',3,now(),now()),
	(13,'fangdongbai','123456','方东白',1,'13.jpg',5,'2012-11-01',3,now(),now()),
	(14,'zhangsanfeng','123456','张三丰',1,'14.jpg',2,'2002-08-01',2,now(),now()),
	(15,'yulianzhou','123456','俞莲舟',1,'15.jpg',2,'2011-05-01',2,now(),now()),
	(16,'songyuanqiao','123456','宋远桥',1,'16.jpg',2,'2007-01-01',2,now(),now()),
	(17,'chenyouliang','123456','陈友谅',1,'17.jpg',NULL,'2015-03-21',NULL,now(),now());

第2步：创建一个SpringBoot工程，选择引入对应的起步依赖（web、mybatis、mysql驱动、lombok） (版本选择2.7.5版本，可以创建完毕之后，在pom.xml文件中更改版本号)  

 

创建项目工程目录结构：  

第3步：配置文件application.properties中引入mybatis的配置信息，准备对应的实体类

  • application.properties
#数据库连接
#驱动类名称
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#数据库连接的URL
spring.datasource.url=jdbc:mysql://localhost:3306/tlias
#连接数据库的用户名
spring.datasource.username=root
#连接数据库的密码
spring.datasource.password=123456

#开启mybatis的日志输出{配置MyBatis的日志,指定输出到控制台}
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

#开启数据库表字段 到 实体类属性的驼峰映射 a_column ---> aColumn
mybatis.configuration.map-underscore-to-camel-case=true

  • 实体类

    package com.gch.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDateTime;

/**
  部门表
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Dept {
    private Integer id;
    private String name;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

    package com.gch.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDate;
import java.time.LocalDateTime;

/**
   员工表
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Emp {
    private Integer id;
    private String username;
    private String password;
    private String name;
    private Short gender;
    private String image;
    private Short job;
    private LocalDate entrydate;
    private Integer deptId;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

第4步：准备对应的Mapper、Service(接口、实现类)、Controller基础结构

数据访问层：

  • DeptMapper
package com.gch.mapper;

import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface DeptMapper {
}
  • EmpMapper
package com.gch.mapper;

import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface EmpMapper {
}

业务层：

  • DeptService
package com.gch.service;

/**
   部门业务规则
 */
public interface DeptService {

}
  • DeptServiceImpl
package com.gch.service.impl;

import com.gch.service.DeptService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

/**
   部门业务实现类
 */
@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
}
  • EmpService
package com.gch.service;

/**
   员工业务规则
 */
public interface EmpService {

}
  • EmpServiceImpl
package com.gch.service.impl;

import com.gch.service.EmpService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

/**
   员工业务实现类
 */
@Slf4j
@Service
public class EmpServiceImpl implements EmpService {

}

控制层：

  • DeptController
package com.gch.controller;

import org.springframework.web.bind.annotation.RestController;

/**
   部门管理控制器
 */
@RestController
public class DeptController {
}
  • EmpController
package com.gch.controller;

import org.springframework.web.bind.annotation.RestController;

/**
   员工管理控制器
 */
@RestController
public class EmpController {

}

项目工程结构：

1.2 开发规范

了解完需求也完成了环境搭建了，我们下面开始学习开发的一些规范。

开发规范我们主要从以下几方面介绍：

1、开发规范-REST

我们的案例是基于当前最为主流的前后端分离模式进行开发。

  • 前端开发人员要开发前端的工程，最终将打包好的前端工程是要部署在Nginx服务器上运行；而后端开发人员需要开发后端的工程，也就是服务端的工程，然后再将打包好的服务端程序运行在Tomcat服务器当中。
  • 而最终，前端程序是需要来请求服务端的，服务端接收到请求之后，对请求进行处理，然后再给前端响应数据。 
  • 而在前后端分离的开发模式当中，前后端程序开发完毕之后，要想能够正常的对接起来，那么它们在开发的时候就必须遵循某种开发规范，而这个开发规范会定义在一份儿单独的文档当中，这份儿文档就是接口文档。 
  • 有了接口文档之后，前端开发人员和后端开发人员只需要严格的基于这份儿接口文档进行开发就可以了。

这份儿接口文档又是怎么来的？

  • 这份儿接口文档是开发人员根据产品经理提供的页面原型和需求分析出来的。

到底是前端开发人员来编写这份儿接口文档还是后端开发人员编写这份儿接口文档呢？

  • 大部分情况下，都是由后端开发人员来编写的。
  • 目前阶段需要掌握阅读接口文档并根据接口文档来开发功能接口。

在前后端分离的开发模式中，前后端开发人员都需要根据提前定义好的接口文档，来进行前后端功能的开发。

后端开发人员：必须严格遵守提供的接口文档进行后端功能开发（保障开发的功能可以和前端对接）

而在前后端进行交互的时候，我们需要基于当前主流的REST风格的API接口进行交互。

什么是REST风格呢?

  • REST（Representational State Transfer），表述性状态转换，它是一种软件架构风格。

在网络当中，我们描述一个网络资源，可以通过两种方式，一种是传统风格，一种就是REST风格

传统URL风格如下：

http://localhost:8080/user/getById?id=1     GET：查询id为1的用户
http://localhost:8080/user/saveUser         POST：新增用户
http://localhost:8080/user/updateUser       POST：修改用户
http://localhost:8080/user/deleteUser?id=1  GET：删除id为1的用户

我们看到，原始的传统URL呢，定义比较复杂，而且将资源的访问行为对外暴露出来了。

基于REST风格URL如下：

http://localhost:8080/users/1  GET：查询id为1的用户
http://localhost:8080/users    POST：新增用户
http://localhost:8080/users    PUT：修改用户
http://localhost:8080/users/1  DELETE：删除id为1的用户

其中总结起来，就一句话：通过URL定位要操作的资源，通过HTTP动词(HTTP的请求方式)来描述具体的操作(增删改查操作)。

在REST风格的URL中，通过四种请求方式，来操作数据的增删改查：

  • GET：查询
  • POST：新增
  • PUT：修改
  • DELETE：删除

我们看到，如果是基于REST风格，定义URL，URL将会更加简洁、更加规范、更加优雅。  

注意事项：

  • REST是一种软件架构的风格，是约定方式，约定不是规定，可以打破。
  • 描述模块的功能通常使用复数，也就是加s的格式来描述，表示此类资源，而非单个资源。如：users、emps、books…

2、开发规范-统一响应结果

  • 前后端工程在进行交互时，使用统一响应结果 Result
package com.gch.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
/**
   定义实体类Result作为统一响应结果类
 */
public class Result {
    /** 响应码,1代表成功,0代表失败 */
    private Integer code;
    /** 响应信息,描述字符串 */
    private String msg;
    /** 返回的数据 */
    private Object data;

    /**
     * 增删改 成功响应(不需要给前端返回数据)
     * @return
     */
    public static Result success() {
        return new Result(1, "success", null);
    }

    /**
     * 查询 成功响应(把查询结果作为返回数据响应给前端)
     * @param data => 返回的数据
     * @return
     */
    public static Result success(Object data) {
        return new Result(1,"success",data);
    }

    /**
     * 失败响应
     * @param msg 失败的响应信息
     * @return
     */
    public static Result error(String msg){
        return new Result(0,msg,null);
    }
}

3、开发流程

我们在进行功能开发时，都是根据如下流程进行：  

  1. 查看页面原型明确需求

    • 根据页面原型和需求，进行表结构设计、编写接口文档(已提供)

  2. 阅读接口文档

  3. 思路分析

  4. 功能接口开发

    • 就是开发后台的业务功能，一个业务功能，我们称为一个接口

  5. 功能接口测试

    • 功能开发完毕后，先通过Postman进行功能接口测试，测试通过后，再和前端进行联调测试

  6. 前后端联调测试

    • 和前端开发人员开发好的前端工程一起测试

2. 部门管理

我们按照前面学习的开发流程，开始完成功能开发。首先按照之前分析的需求，完成部门管理的功能开发。

开发的部门管理功能包含：

  1. 查询部门
  2. 删除部门
  3. 新增部门
  4. 更新部门

2.1 查询部门

2.1.1 原型和需求  

当我们点击左侧的部门管理，在右侧的表格当中就要展示出部门的列表数据，那此时就会涉及到部门的查询操作。 

查询的部门的信息：部门ID、部门名称、修改时间

通过页面原型以及需求描述，我们可以看到，部门查询，是不需要考虑分页操作的。

查询全部的操作，所以是没有请求参数的。 

2.1.2 接口文档

部门列表查询

  • 基本信息
请求路径：/depts
​
请求方式：GET
​
接口描述：该接口用于部门列表数据查询

  • 请求参数

    无

  • 响应数据

    参数格式：application/json

    参数说明：

    参数名类型是否必须备注
    codenumber必须响应码，1 代表成功，0 代表失败
    msgstring非必须提示信息
    dataobject[ ]非必须返回的数据
    |- idnumber非必须id
    |- namestring非必须部门名称
    |- createTimestring非必须创建时间
    |- updateTimestring非必须修改时间

    响应数据样例：

    {
  "code": 1,
  "msg": "success",
  "data": [
    {
      "id": 1,
      "name": "学工部",
      "createTime": "2022-09-01T23:06:29",
      "updateTime": "2022-09-01T23:06:29"
    },
    {
      "id": 2,
      "name": "教研部",
      "createTime": "2022-09-01T23:06:29",
      "updateTime": "2022-09-01T23:06:29"
    }
  ]
}
2.1.3 思路分析

2.1.4 功能开发

通过查看接口文档：部门列表查询

请求路径：/depts

请求方式：GET

请求参数：无

响应数据：json格式

DeptController 

package com.gch.controller;

import com.gch.pojo.Dept;
import com.gch.pojo.Result;
import com.gch.service.DeptService;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
   部门管理控制器
 */
@Slf4j
@RestController
public class DeptController {
    // 定义一个日志记录对象
    // private static final Logger log = LoggerFactory.getLogger(DeptController.class);

    // 在Lombok当中,为了简化定义日志记录对象的操作,给我们提供了一个注解@Slf4j
    // @Slf4j是Lombok当中提供的注解

    @Autowired
    private DeptService deptService;

    /**
     * 查询所有的部门信息 / 查询全部部门数据
     * 如果没有限定请求方式,那么在Postman中做接口测试时,不管使用GET请求还是POST请求都可以获取到请求结果
     * 而接口文档当中要求的请求方式为GET请求,这就要求我们要限定接口的请求方式
     * 注解@RequestMapping当中的method()属性用来限定接口的请求方式
     * 通过枚举类RequestMethod来指定接口的请求方式
     * @RequestMapping(value = "/depts",method = RequestMethod.GET) // 指定请求方式为GET
     * 由于使用注解@RequestMapping写法比较繁琐,因此在Spring当中,又给我们提供了一个@RequestMapping的衍生注解:@GetMapping
     * 在注解@GetMapping()里面只用指定请求路径即可
     * @GetMapping("/depts")
     * 查看注解@GetMapping的源码,会看到@GetMapping底层的注解就是@RequestMapping,并且限定了请求方式为GET
     * @return
     */
    @GetMapping("/depts")
    public Result list() {
        // 不要使用输出语句来输出日志
        // System.out.println("查询全部部门数据");
        // 要使用日志框架来完成日志的记录
        log.info("查询全部的部门数据");

        // 调用service来查询部门数据
        List<Dept> deptList = deptService.list();
        // 返回统一响应结果
        return Result.success(deptList);
    }
}

DeptService（业务接口）

package com.gch.service;

import com.gch.pojo.Dept;

import java.util.List;

/**
   部门业务规则
 */
public interface DeptService {
    /**
     * 查询全部的部门数据
     * @return
     */
    List<Dept> list();
}

DeptServiceImpl（业务实现类）

package com.gch.service.impl;

import com.gch.mapper.DeptMapper;
import com.gch.pojo.Dept;
import com.gch.service.DeptService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
   部门业务实现类
 */
@Slf4j
@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    private DeptMapper deptMapper;

    @Override
    public List<Dept> list() {
        return deptMapper.list();
    }
}
c

DeptMapper  

package com.gch.mapper;

import com.gch.pojo.Dept;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
   部门管理
 */
@Mapper
public interface DeptMapper {
    /**
     * 查询全部的部门数据
     * @return
     */
    @Select("select id, name, create_time, update_time from tlias.dept")
    List<Dept> list();
}
2.1.5 功能测试

功能开发完成后，我们就可以启动项目，然后打开Postman，发起GET请求，访问 ：http://localhost:8080/depts

运行启动类，并使用Postman做接口测试：  

2.2 前后端联调

完成了查询部门的功能，我们也通过postman工具测试通过了，下面我们再基于前后端分离的方式进行接口联调。具体操作如下：

前后端联调指的就是将前端工程、后端工程都启动起来，然后访问前端工程，通过前端工程来访问服务端程序，进而进行调试。

前端程序一般都是部署在Nginx服务器当中的。 

1、将部署好的"前端环境"文件夹中的压缩包，拷贝到一个没有中文不带空格的目录下  

2、拷贝到一个没有中文不带空格的目录后，进行解压（解压到当前目录）  

3、启动nginx

 

4、该Nginx占用的端口是90端口，因此打开浏览器，访问：http://localhost:90  

5、测试：部门管理 - 查询部门列表  

说明：只要按照接口文档开发功能接口，就能保证前后端程序交互

  • 后端：严格遵守接口文档进行功能接口开发
  • 前端：严格遵守接口文档访问功能接口

2.3 删除部门

查询部门的功能我们搞定了，下面我们开始完成删除部门的功能开发。

2.3.1 需求

点击部门列表后面操作栏的 "删除" 按钮，就可以删除该部门信息。 此时，前端只需要给服务端传递一个ID参数就可以了。 我们从接口文档中也可以看得出来。  

2.3.2 接口文档

删除部门

  • 基本信息

  • 请求参数 参数格式：路径参数

    参数说明：

    参数名类型是否必须备注
    idnumber必须部门ID

    请求参数样例：

    /depts/1

  • 响应数据 参数格式：application/json

    参数说明：

    参数名类型是否必须备注
    codenumber必须响应码，1 代表成功，0 代表失败
    msgstring非必须提示信息
    dataobject非必须返回的数据

    响应数据样例：

    {
    "code":1,
    "msg":"success",
    "data":null
}
    2.3.3 思路分析

接口文档规定：

  • 前端请求路径：/depts/{id}
  • 前端请求方式：DELETE

问题1：怎么在Controller中接收请求路径中的路径参数？

 @PathVariable

问题2：如何限定请求方式是delete？

 @DeleteMapping
2.3.4 功能开发

通过查看接口文档：删除部门

请求路径：/depts/{id}

请求方式：DELETE

请求参数：路径参数 {id}

响应数据：json格式

DeptController  

package com.gch.controller;

import com.gch.pojo.Dept;
import com.gch.pojo.Result;
import com.gch.service.DeptService;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
   部门管理控制器
 */
@Slf4j
@RestController
public class DeptController {
    // 定义一个日志记录对象
    // private static final Logger log = LoggerFactory.getLogger(DeptController.class);

    // 在Lombok当中,为了简化定义日志记录对象的操作,给我们提供了一个注解@Slf4j
    // @Slf4j是Lombok当中提供的注解

    @Autowired
    private DeptService deptService;

    /**
     * 查询所有的部门信息 / 查询全部部门数据
     * 如果没有限定请求方式,那么在Postman中做接口测试时,不管使用GET请求还是POST请求都可以获取到请求结果
     * 而接口文档当中要求的请求方式为GET请求,这就要求我们要限定接口的请求方式
     * 注解@RequestMapping当中的method()属性用来限定接口的请求方式
     * 通过枚举类RequestMethod来指定接口的请求方式
     * @RequestMapping(value = "/depts",method = RequestMethod.GET) // 指定请求方式为GET
     * 由于使用注解@RequestMapping写法比较繁琐,因此在Spring当中,又给我们提供了一个@RequestMapping的衍生注解:@GetMapping
     * @GetMapping用来指定当前接口的请求方式必须是GET请求,在注解@GetMapping()里面只用指定请求路径即可
     * @GetMapping("/depts")
     * 查看注解@GetMapping的源码,会看到@GetMapping底层的注解就是@RequestMapping,并且限定了请求方式为GET
     * @return
     */
    @GetMapping("/depts")
    public Result list() {
        // 不要使用输出语句来输出日志
        // System.out.println("查询全部部门数据");
        // 要使用日志框架来完成日志的记录
        log.info("查询全部的部门数据");

        // 调用service来查询部门数据
        List<Dept> deptList = deptService.list();
        // 返回统一响应结果
        return Result.success(deptList);
    }

    /**
     * 删除部门
     * @DeleteMapping用来指定当前接口的请求方式必须是DELETE请求
     * 一个{}就是一个参数占位符,最终id就会替换掉参数占位符
     * @return
     */
    @DeleteMapping("/depts/{id}")
    public Result delete(@PathVariable Integer id) {
        log.info("根据id删除部门:{}",id);
        // 调用service删除部门
        deptService.delete(id);
        // 返回统一响应结果
        return Result.success();
    }
}

package com.gch.service;

import com.gch.pojo.Dept;

import java.util.List;

/**
   部门业务规则
 */
public interface DeptService {
    /**
     * 查询全部的部门数据
     * @return
     */
    List<Dept> list();

    /**
     * 根据部门id来删除对应的部门
     * @param id
     */
    void delete(Integer id);
}

DeptServiceImpl  

package com.gch.service.impl;

import com.gch.mapper.DeptMapper;
import com.gch.pojo.Dept;
import com.gch.service.DeptService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
   部门业务实现类
 */
@Slf4j
@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    private DeptMapper deptMapper;

    @Override
    public List<Dept> list() {
        return deptMapper.list();
    }

    @Override
    public void delete(Integer id) {
        deptMapper.deleteById(id);
    }
}

DeptMapper  

package com.gch.mapper;

import com.gch.pojo.Dept;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
   部门管理
 */
@Mapper
public interface DeptMapper {
    /**
     * 查询全部的部门数据
     * @return
     */
    @Select("select id, name, create_time, update_time from tlias.dept")
    List<Dept> list();

    /**
     * 根据id删除部门
     * @param id => 部门id
     */
    @Delete("delete from tlias.dept where id = #{id}")
    void deleteById(Integer id);
}
2.3.5 功能测试

删除功能开发完成后，重新启动项目，使用postman，发起DELETE请求：

2.3.6 前后端联调

打开浏览器，测试后端功能接口：

 

2.4 新增部门

我们前面已完成了查询部门、删除部门两个功能，也熟悉了开发的流程。下面我们继续完成新增部门功能。

2.4.1 需求

点击 "新增部门" 按钮，弹出新增部门对话框，输入部门名称，点击 "保存" ，将部门信息保存到数据库。

2.4.2 接口文档

添加部门

  • 基本信息

  • 请求参数

    格式：application/json

    参数说明：

    参数名类型是否必须备注
    namestring必须部门名称

    请求参数样例：

    {
    "name": "教研部"
}

  • 响应数据

    参数格式：application/json

    参数说明：

    参数名类型是否必须备注
    codenumber必须响应码，1 代表成功，0 代表失败
    msgstring非必须提示信息
    dataobject非必须返回的数据

    响应数据样例：

    {
    "code":1,
    "msg":"success",
    "data":null
}
2.4.3 思路分析

接口文档规定：

  • 前端请求路径：/depts
  • 前端请求方式：POST
  • 前端请求参数 (Json格式)： { "name": "教研部" }

问题1：如何限定请求方式是POST？

 @PostMapping

问题2：怎么在controller中接收json格式的请求参数？

 @RequestBody  //把前端传递的json数据填充到实体类中
2.4.4 功能开发

通过查看接口文档：新增部门

请求路径：/depts

请求方式：POST

请求参数：json格式

响应数据：json格式

DeptController  

package com.gch.controller;

import com.gch.pojo.Dept;
import com.gch.pojo.Result;
import com.gch.service.DeptService;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
   部门管理控制器
 */
@Slf4j
@RestController
public class DeptController {
    // 定义一个日志记录对象
    // private static final Logger log = LoggerFactory.getLogger(DeptController.class);

    // 在Lombok当中,为了简化定义日志记录对象的操作,给我们提供了一个注解@Slf4j
    // @Slf4j是Lombok当中提供的注解

    @Autowired
    private DeptService deptService;

    /**
     * 查询所有的部门信息 / 查询全部部门数据
     * 如果没有限定请求方式,那么在Postman中做接口测试时,不管使用GET请求还是POST请求都可以获取到请求结果
     * 而接口文档当中要求的请求方式为GET请求,这就要求我们要限定接口的请求方式
     * 注解@RequestMapping当中的method()属性用来限定接口的请求方式
     * 通过枚举类RequestMethod来指定接口的请求方式
     * @RequestMapping(value = "/depts",method = RequestMethod.GET) // 指定请求方式为GET
     * 由于使用注解@RequestMapping写法比较繁琐,因此在Spring当中,又给我们提供了一个@RequestMapping的衍生注解:@GetMapping
     * @GetMapping用来指定当前接口的请求方式必须是GET请求,在注解@GetMapping()里面只用指定请求路径即可
     * @GetMapping("/depts")
     * 查看注解@GetMapping的源码,会看到@GetMapping底层的注解就是@RequestMapping,并且限定了请求方式为GET
     * @return
     */
    @GetMapping("/depts")
    public Result list() {
        // 不要使用输出语句来输出日志
        // System.out.println("查询全部部门数据");
        // 要使用日志框架来完成日志的记录
        log.info("查询全部的部门数据");

        // 调用service来查询部门数据
        List<Dept> deptList = deptService.list();
        // 返回统一响应结果
        return Result.success(deptList);
    }

    /**
     * 删除部门
     * @DeleteMapping用来指定当前接口的请求方式必须是DELETE请求
     * 一个{}就是一个参数占位符,最终id就会替换掉参数占位符
     * @return
     */
    @DeleteMapping("/depts/{id}")
    public Result delete(@PathVariable Integer id) {
        log.info("根据id删除部门:{}",id);
        // 调用service删除部门
        deptService.delete(id);
        // 返回统一响应结果
        return Result.success();
    }

    /**
     * 新增部门
     * @return
     */
    @PostMapping("/depts")
    public Result add(@RequestBody Dept dept) {
        log.info("新增部门:{}",dept);
        // 调用service新增部门
        deptService.add(dept);
        // 返回统一响应结果
        return Result.success();
    }
}

DeptService  

package com.gch.service;

import com.gch.pojo.Dept;

import java.util.List;

/**
   部门业务规则
 */
public interface DeptService {
    /**
     * 查询全部的部门数据
     * @return
     */
    List<Dept> list();

    /**
     * 根据部门id来删除对应的部门
     * @param id
     */
    void delete(Integer id);

    /**
     * 新增部门
     * @param dept 部门对象
     */
    void add(Dept dept);
}

DeptServiceImpl  

package com.gch.service.impl;

import com.gch.mapper.DeptMapper;
import com.gch.pojo.Dept;
import com.gch.service.DeptService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.List;

/**
   部门业务实现类
 */
@Slf4j
@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    private DeptMapper deptMapper;

    @Override
    public List<Dept> list() {
        return deptMapper.list();
    }

    @Override
    public void delete(Integer id) {
        deptMapper.deleteById(id);
    }

    @Override
    public void add(Dept dept) {
        // 补全部门数据
        dept.setCreateTime(LocalDateTime.now());
        dept.setUpdateTime(LocalDateTime.now());
        // 调用Mapper层新增员工功能
        deptMapper.insert(dept);
    }
}

DeptMapper  

package com.gch.mapper;

import com.gch.pojo.Dept;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
   部门管理
 */
@Mapper
public interface DeptMapper {
    /**
     * 查询全部的部门数据
     * @return
     */
    @Select("select id, name, create_time, update_time from tlias.dept")
    List<Dept> list();

    /**
     * 根据id删除部门
     * @param id => 部门id
     */
    @Delete("delete from tlias.dept where id = #{id}")
    void deleteById(Integer id);

    /**
     * 新增部门
     * @param dept
     */
    @Insert("insert into tlias.dept(name, create_time, update_time) values(#{name},#{createTime},#{updateTime})")
    void insert(Dept dept);
}
2.4.5 功能测试

新增功能开发完成后，重新启动项目，使用postman，发起POST请求：

2.4.6 前后端联调

打开浏览器，测试后端功能接口：

 

2.4.7 请求路径

我们部门管理的查询、删除、新增功能全部完成了，接下来我们要对controller层的代码进行优化。

首先我们先来看下目前controller层代码：

以上三个方法上的请求路径，存在一个共同点：都是以/depts作为开头。（重复了）  

在Spring当中为了简化请求路径的定义，可以把公共的请求路径，直接抽取到类上，在类上加一个注解@RequestMapping，并指定请求路径"/depts" 。代码参照如下：  

优化前后的对比：

注意事项：一个完整的请求路径，应该是类上@RequestMapping的value属性 + 方法上的                              @RequestMapping的value属性

  • 类上面的@RequestMapping里面指定公共路径！

2.5 修改部门

2.5.1 需求

2.5.2 接口文档 

1.5.1 基本信息

2.5.3 思路分析

请求参数
格式：application/json
参数说明：

参数名类型是否必须备注
idnumber必须部门ID
namestring必须部门名称

请求参数样例：

1.5.3 响应数据
参数格式：application/json
参数说明：

参数名类型是否必须备注
codenumber必须响应码，1 代表
msgstring非必须提示信息
dataobject非必须返回的数据

响应数据样例：

2.5.4 功能开发 
DeptController  
package com.gch.controller;

import com.gch.pojo.Dept;
import com.gch.pojo.Result;
import com.gch.service.DeptService;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
   部门管理控制器
 */
@Slf4j
@RestController
@RequestMapping("/depts")
public class DeptController {
    // 定义一个日志记录对象
    // private static final Logger log = LoggerFactory.getLogger(DeptController.class);

    // 在Lombok当中,为了简化定义日志记录对象的操作,给我们提供了一个注解@Slf4j
    // @Slf4j是Lombok当中提供的注解

    @Autowired
    private DeptService deptService;

    /**
     * 查询所有的部门信息 / 查询全部部门数据
     * 如果没有限定请求方式,那么在Postman中做接口测试时,不管使用GET请求还是POST请求都可以获取到请求结果
     * 而接口文档当中要求的请求方式为GET请求,这就要求我们要限定接口的请求方式
     * 注解@RequestMapping当中的method()属性用来限定接口的请求方式
     * 通过枚举类RequestMethod来指定接口的请求方式
     * @RequestMapping(value = "/depts",method = RequestMethod.GET) // 指定请求方式为GET
     * 由于使用注解@RequestMapping写法比较繁琐,因此在Spring当中,又给我们提供了一个@RequestMapping的衍生注解:@GetMapping
     * @GetMapping用来指定当前接口的请求方式必须是GET请求,在注解@GetMapping()里面只用指定请求路径即可
     * @GetMapping("/depts")
     * 查看注解@GetMapping的源码,会看到@GetMapping底层的注解就是@RequestMapping,并且限定了请求方式为GET
     * @return
     */
    @GetMapping
    public Result list() {
        // 不要使用输出语句来输出日志
        // System.out.println("查询全部部门数据");
        // 要使用日志框架来完成日志的记录
        log.info("查询全部的部门数据");

        // 调用service来查询部门数据
        List<Dept> deptList = deptService.list();
        // 返回统一响应结果
        return Result.success(deptList);
    }

    /**
     * 删除部门
     * @DeleteMapping用来指定当前接口的请求方式必须是DELETE请求
     * 一个{}就是一个参数占位符,最终id就会替换掉参数占位符
     * @return
     */
    @DeleteMapping("/{id}")
    public Result delete(@PathVariable Integer id) {
        log.info("根据id删除部门:{}",id);
        // 调用service删除部门
        deptService.delete(id);
        // 返回统一响应结果
        return Result.success();
    }

    /**
     * 新增部门
     * @return
     */
    @PostMapping
    public Result add(@RequestBody Dept dept) {
        log.info("新增部门:{}",dept);
        // 调用service新增部门
        deptService.add(dept);
        // 返回统一响应结果
        return Result.success();
    }

    /**
     * 修改部门
     * @param dept 部门对象
     * @return
     */
    @PutMapping
    public Result update(@RequestBody Dept dept){
        log.info("编辑部门:{}",dept);
        // 调用service编辑部门
        deptService.update(dept);
        // 返回统一响应结果
        return Result.success();
    }
}
DeptService
package com.gch.service;

import com.gch.pojo.Dept;

import java.util.List;

/**
   部门业务规则
 */
public interface DeptService {
    /**
     * 查询全部的部门数据
     * @return
     */
    List<Dept> list();

    /**
     * 根据部门id来删除对应的部门
     * @param id
     */
    void delete(Integer id);

    /**
     * 新增部门
     * @param dept 部门对象
     */
    void add(Dept dept);

    /**
     * 修改部门
     * @param dept 部门对象
     */
    void update(Dept dept);
}
DeptServiceImpl
package com.gch.service.impl;

import com.gch.mapper.DeptMapper;
import com.gch.pojo.Dept;
import com.gch.service.DeptService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.List;

/**
   部门业务实现类
 */
@Slf4j
@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    private DeptMapper deptMapper;

    @Override
    public List<Dept> list() {
        return deptMapper.list();
    }

    @Override
    public void delete(Integer id) {
        deptMapper.deleteById(id);
    }

    @Override
    public void add(Dept dept) {
        // 补全部门数据
        dept.setCreateTime(LocalDateTime.now());
        dept.setUpdateTime(LocalDateTime.now());
        // 调用Mapper层新增员工功能
        deptMapper.insert(dept);
    }

    @Override
    public void update(Dept dept) {
        deptMapper.update(dept);
    }
}
DeptMapper
package com.gch.mapper;

import com.gch.pojo.Dept;
import org.apache.ibatis.annotations.*;

import java.util.List;

/**
   部门管理
 */
@Mapper
public interface DeptMapper {
    /**
     * 查询全部的部门数据
     * @return
     */
    @Select("select id, name, create_time, update_time from tlias.dept")
    List<Dept> list();

    /**
     * 根据id删除部门
     * @param id => 部门id
     */
    @Delete("delete from tlias.dept where id = #{id}")
    void deleteById(Integer id);

    /**
     * 新增部门
     * @param dept
     */
    @Insert("insert into tlias.dept(name, create_time, update_time) values(#{name},#{createTime},#{updateTime})")
    void insert(Dept dept);

    /**
     * 修改部门
     * @param dept
     */
    @Update("update tlias.dept set dept.name = #{name} where id = #{id}")
    void update(Dept dept);
}
2.5.5 功能测试 

avatar
文章
阅读
粉丝