[JavaWeb]【九】web后端开发-SpringBootWeb案例（菜单）

-- 部门管理
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());

1.2.2 创建springboot工程

1.2.3 配置application.properties & 准备对应实体类

1.2.3.1 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=1234

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

#开启mybatis的驼峰命名自动映射开关 a_column ------> aCloumn
mybatis.configuration.map-underscore-to-camel-case=true

1.2.3.2 实体类

1.2.3.2.1 Emp类

package com.runa.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; //ID
    private String username; //用户名
    private String password; //密码
    private String name; //姓名
    private Short gender; //性别 , 1 男, 2 女
    private String image; //图像url
    private Short job; //职位 , 1 班主任 , 2 讲师 , 3 学工主管 , 4 教研主管 , 5 咨询师
    private LocalDate entrydate; //入职日期
    private Integer deptId; //部门ID
    private LocalDateTime createTime; //创建时间
    private LocalDateTime updateTime; //修改时间
}

1.2.3.2.2 Dept类

package com.runa.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;

/**
 * 部门实体类
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Dept {
    private Integer id; //ID
    private String name; //部门名称
    private LocalDateTime createTime; //创建时间
    private LocalDateTime updateTime; //修改时间
}

1.2.4 准备对应的Mapper、Service（接口实现类）、Controller基础结构

1.2.4.1 Mapper

1.2.4.1.1 DeptMapper接口

package com.runa.mapper;

import org.apache.ibatis.annotations.Mapper;

/**
 * 部门管理
 */
@Mapper
public interface DeptMapper {
}

1.2.4.1.2 EmpMapper接口

package com.runa.mapper;

import org.apache.ibatis.annotations.Mapper;

/**
 * 员工管理
 */
@Mapper
public interface EmpMapper {
}

1.2.4.2 Service（接口实现类）

1.2.4.2.1 DeptService接口

package com.runa.service;

public interface DeptService {
}

1.2.4.2.2 EmpService接口

package com.runa.service;

public interface EmpService {
}

1.2.4.2.1 DeptServiceImpl实现类

package com.runa.service.impl;

import com.runa.service.DeptService;
import org.springframework.stereotype.Service;

@Service
public class DeptServiceImpl implements DeptService {
}

1.2.4.2.2 EmpServiceImpl实现类

package com.runa.service.impl;

import com.runa.service.EmpService;
import org.springframework.stereotype.Service;

@Service
public class EmpServiceImpl implements EmpService {
}

1.2.4.3 Controller基础结构

1.2.4.3.1 Deptcontroller

package com.runa.controller;

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

/**
 * 部门管理Controller
 */
@RestController
public class Deptcontroller {
}

1.2.4.3.2 EmpController

package com.runa.controller;

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

/**
 * 员工管理Controller
 */
@RestController
public class EmpController {
}

1.2.5 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.runa</groupId>
    <artifactId>spring-boot-project-test</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-boot-project-test</name>
    <description>spring-boot-project-test</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
            <!--        web  起步依赖  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--       mybatis起步依赖  -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.2</version>
        </dependency>
        <!--       mysql驱动  -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--       lombok  -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!--       springboot 单元测试  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter-test</artifactId>
            <version>3.0.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

1.2.6 完成效果

1.3 开发规范

1.3.1 接口文档

tlias智能学习辅助系统接口文档-V1.0

1.3.1.1 部门管理

1.3.1.1.1 部门列表查询

1.3.1.1.1.1 基本信息

请求路径：/depts

请求方式：GET

接口描述：该接口用于部门列表数据查询

1.3.1.1.1.2 请求参数

无

1.3.1.1.1.3 响应数据

参数格式：application/json

参数说明：

参数名	类型	是否必须	备注
code	number	必须	响应码，1 代表成功，0 代表失败
msg	string	非必须	提示信息
data	object[ ]	非必须	返回的数据
\|- id	number	非必须	id
\|- name	string	非必须	部门名称
\|- createTime	string	非必须	创建时间
\|- updateTime	string	非必须	修改时间

响应数据样例：

{
  "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"
    }
  ]
}

1.3.1.1.2 删除部门

1.3.1.1.2.1 基本信息

请求路径：/depts/{id}

请求方式：DELETE

接口描述：该接口用于根据ID删除部门数据

1.3.1.1.2.2 请求参数

参数格式：路径参数

参数说明：

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

请求参数样例：

/depts/1

1.3.1.1.2.3 响应数据

参数格式：application/json

参数说明：

参数名	类型	是否必须	备注
code	number	必须	响应码，1 代表成功，0 代表失败
msg	string	非必须	提示信息
data	object	非必须	返回的数据

响应数据样例：

{
    "code":1,
    "msg":"success",
    "data":null
}

1.3.1.1.3 添加部门

1.3.1.1.3 1 基本信息

请求路径：/depts

请求方式：POST

接口描述：该接口用于添加部门数据

1.3.1.1.3 .2 请求参数

格式：application/json

参数说明：

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

请求参数样例：

{
    "name": "教研部"
}

1.3.1.1.3 .3 响应数据

参数格式：application/json

参数说明：

参数名	类型	是否必须	备注
code	number	必须	响应码，1 代表成功，0 代表失败
msg	string	非必须	提示信息
data	object	非必须	返回的数据

响应数据样例：

{
    "code":1,
    "msg":"success",
    "data":null
}

1.3.1.1.4 根据ID查询

1.3.1.1.4.1 基本信息

请求路径：/depts/{id}

请求方式：GET

接口描述：该接口用于根据ID查询部门数据

1.3.1.1.4..2 请求参数

参数格式：路径参数

参数说明：

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

请求参数样例：

/depts/1

1.3.1.1.4.3 响应数据

参数格式：application/json

参数说明：

参数名	类型	是否必须	备注
code	number	必须	响应码，1 代表成功，0 代表失败
msg	string	非必须	提示信息
data	object	非必须	返回的数据
\|- id	number	非必须	id
\|- name	string	非必须	部门名称
\|- createTime	string	非必须	创建时间
\|- updateTime	string	非必须	修改时间

响应数据样例：

{
  "code": 1,
  "msg": "success",
  "data": {
    "id": 1,
    "name": "学工部",
    "createTime": "2022-09-01T23:06:29",
    "updateTime": "2022-09-01T23:06:29"
  }
}

1.3.1.1.5 修改部门

1.3.1.1.5.1 基本信息

请求路径：/depts

请求方式：PUT

接口描述：该接口用于修改部门数据

1.3.1.1.5.2 请求参数

格式：application/json

参数说明：

参数名	类型	是否必须	备注
id	number	必须	部门ID
name	string	必须	部门名称

请求参数样例：

{
    "id": 1,
    "name": "教研部"
}

1.3.1.1.5.3 响应数据

参数格式：application/json

参数说明：

参数名	类型	是否必须	备注
code	number	必须	响应码，1 代表成功，0 代表失败
msg	string	非必须	提示信息
data	object	非必须	返回的数据

响应数据样例：

{
    "code":1,
    "msg":"success",
    "data":null
}

1.3.1.2 员工管理

1.3.1.2.1 员工列表查询

1.3.1.2.1.1 基本信息

请求路径：/emps

请求方式：GET

接口描述：该接口用于员工列表数据的条件分页查询

1.3.1.2.1.2 请求参数

参数格式：queryString

参数说明：

参数名称	是否必须	示例	备注
name	否	张	姓名
gender	否	1	性别 , 1 男 , 2 女
begin	否	2010-01-01	范围匹配的开始时间(入职日期)
end	否	2020-01-01	范围匹配的结束时间(入职日期)
page	是	1	分页查询的页码，如果未指定，默认为1
pageSize	是	10	分页查询的每页记录数，如果未指定，默认为10

请求数据样例：

/emps?name=张&gender=1&begin=2007-09-01&end=2022-09-01&page=1&pageSize=10

1.3.1.2.1.3 响应数据

参数格式：application/json

参数说明：

名称	类型	是否必须	备注	其他信息
code	number	必须	响应码, 1 成功 , 0 失败
msg	string	非必须	提示信息
data	object	必须	返回的数据
\|- total	number	必须	总记录数
\|- rows	object []	必须	数据列表	item 类型: object
\|- id	number	非必须	id
\|- username	string	非必须	用户名
\|- name	string	非必须	姓名
\|- password	string	非必须	密码
\|- entrydate	string	非必须	入职日期
\|- gender	number	非必须	性别 , 1 男 ; 2 女
\|- image	string	非必须	图像
\|- job	number	非必须	职位, 说明: 1 班主任,2 讲师, 3 学工主管, 4 教研主管, 5 咨询师
\|- deptId	number	非必须	部门id
\|- createTime	string	非必须	创建时间
\|- updateTime	string	非必须	更新时间

响应数据样例：

{
  "code": 1,
  "msg": "success",
  "data": {
    "total": 2,
    "rows": [
       {
        "id": 1,
        "username": "jinyong",
        "password": "123456",
        "name": "金庸",
        "gender": 1,
        "image": "https://web-framework.oss-cn-hangzhou.aliyuncs.com/2022-09-02-00-27-53B.jpg",
        "job": 2,
        "entrydate": "2015-01-01",
        "deptId": 2,
        "createTime": "2022-09-01T23:06:30",
        "updateTime": "2022-09-02T00:29:04"
      },
      {
        "id": 2,
        "username": "zhangwuji",
        "password": "123456",
        "name": "张无忌",
        "gender": 1,
        "image": "https://web-framework.oss-cn-hangzhou.aliyuncs.com/2022-09-02-00-27-53B.jpg",
        "job": 2,
        "entrydate": "2015-01-01",
        "deptId": 2,
        "createTime": "2022-09-01T23:06:30",
        "updateTime": "2022-09-02T00:29:04"
      }
    ]
  }
}

1.3.1.2.2 删除员工

1.3.1.2.2.1 基本信息

请求路径：/emps/{ids}

请求方式：DELETE

接口描述：该接口用于批量删除员工的数据信息

1.3.1.2.2.2 请求参数

参数格式：路径参数

参数说明：

参数名	类型	示例	是否必须	备注
ids	数组 array	1,2,3	必须	员工的id数组

请求参数样例：

/emps/1,2,3

1.3.1.2.2.3 响应数据

参数格式：application/json

参数说明：

参数名	类型	是否必须	备注
code	number	必须	响应码，1 代表成功，0 代表失败
msg	string	非必须	提示信息
data	object	非必须	返回的数据

响应数据样例：

{
    "code":1,
    "msg":"success",
    "data":null
}

1.3.1.2.3 添加员工

1.3.1.2.3.1 基本信息

请求路径：/emps

请求方式：POST

接口描述：该接口用于添加员工的信息

1.3.1.2.3.2 请求参数

参数格式：application/json

参数说明：

名称	类型	是否必须	备注
username	string	必须	用户名
name	string	必须	姓名
gender	number	必须	性别, 说明: 1 男, 2 女
image	string	非必须	图像
deptId	number	非必须	部门id
entrydate	string	非必须	入职日期
job	number	非必须	职位, 说明: 1 班主任,2 讲师, 3 学工主管, 4 教研主管, 5 咨询师

请求数据样例：

{
  "image": "https://web-framework.oss-cn-hangzhou.aliyuncs.com/2022-09-03-07-37-38222.jpg",
  "username": "linpingzhi",
  "name": "林平之",
  "gender": 1,
  "job": 1,
  "entrydate": "2022-09-18",
  "deptId": 1
}

1.3.1.2.3.3 响应数据

参数格式：application/json

参数说明：

参数名	类型	是否必须	备注
code	number	必须	响应码，1 代表成功，0 代表失败
msg	string	非必须	提示信息
data	object	非必须	返回的数据

响应数据样例：

{
    "code":1,
    "msg":"success",
    "data":null
}

1.3.1.2.4 根据ID查询

1.3.1.2.4.1 基本信息

请求路径：/emps/{id}

请求方式：GET

接口描述：该接口用于根据主键ID查询员工的信息

1.3.1.2.4.2 请求参数

参数格式：路径参数

参数说明：

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

请求参数样例：

/emps/1

1.3.1.2.4.3 响应数据

参数格式：application/json

参数说明：

名称	类型	是否必须	备注
code	number	必须	响应码, 1 成功 , 0 失败
msg	string	非必须	提示信息
data	object	必须	返回的数据
\|- id	number	非必须	id
\|- username	string	非必须	用户名
\|- name	string	非必须	姓名
\|- password	string	非必须	密码
\|- entrydate	string	非必须	入职日期
\|- gender	number	非必须	性别 , 1 男 ; 2 女
\|- image	string	非必须	图像
\|- job	number	非必须	职位, 说明: 1 班主任,2 讲师, 3 学工主管, 4 教研主管, 5 咨询师
\|- deptId	number	非必须	部门id
\|- createTime	string	非必须	创建时间
\|- updateTime	string	非必须	更新时间

响应数据样例：

{
  "code": 1,
  "msg": "success",
  "data": {
    "id": 2,
    "username": "zhangwuji",
    "password": "123456",
    "name": "张无忌",
    "gender": 1,
    "image": "https://web-framework.oss-cn-hangzhou.aliyuncs.com/2022-09-02-00-27-53B.jpg",
    "job": 2,
    "entrydate": "2015-01-01",
    "deptId": 2,
    "createTime": "2022-09-01T23:06:30",
    "updateTime": "2022-09-02T00:29:04"
  }
}

1.3.1.2.5 修改员工

1.3.1.2.5.1 基本信息

请求路径：/emps

请求方式：PUT

接口描述：该接口用于修改员工的数据信息

1.3.1.2.5.2 请求参数

参数格式：application/json

参数说明：

名称	类型	是否必须	备注
id	number	必须	id
username	string	必须	用户名
name	string	必须	姓名
gender	number	必须	性别, 说明: 1 男, 2 女
image	string	非必须	图像
deptId	number	非必须	部门id
entrydate	string	非必须	入职日期
job	number	非必须	职位, 说明: 1 班主任,2 讲师, 3 学工主管, 4 教研主管, 5 咨询师

请求数据样例：

{
  "id": 1,
  "image": "https://web-framework.oss-cn-hangzhou.aliyuncs.com/2022-09-03-07-37-38222.jpg",
  "username": "linpingzhi",
  "name": "林平之",
  "gender": 1,
  "job": 1,
  "entrydate": "2022-09-18",
  "deptId": 1
}

1.3.1.2.5.3 响应数据

参数格式：application/json

参数说明：

参数名	类型	是否必须	备注
code	number	必须	响应码，1 代表成功，0 代表失败
msg	string	非必须	提示信息
data	object	非必须	返回的数据

响应数据样例：

{
    "code":1,
    "msg":"success",
    "data":null
}

1.3.1.2.6 文件上传

1.3.1.2.6.1 基本信息

请求路径：/upload

请求方式：POST

接口描述：上传图片接口

1.3.1.2.6.2 请求参数

参数格式：multipart/form-data

参数说明：

参数名称	参数类型	是否必须	示例	备注
image	file	是

1.3.1.2.6.3 响应数据

参数格式：application/json

参数说明：

参数名	类型	是否必须	备注
code	number	必须	响应码，1 代表成功，0 代表失败
msg	string	非必须	提示信息
data	object	非必须	返回的数据，上传图片的访问路径

响应数据样例：

{
    "code": 1,
    "msg": "success",
    "data": "https://web-framework.oss-cn-hangzhou.aliyuncs.com/2022-09-02-00-27-0400.jpg"
}

1.3.1.3. 其他接口

1.3.1.3.1 登录

1.3.1.3.1.1 基本信息

请求路径：/login

请求方式：POST

接口描述：该接口用于员工登录Tlias智能学习辅助系统，登录完毕后，系统下发JWT令牌。

1.3.1.3.1.2 请求参数

参数格式：application/json

参数说明：

名称	类型	是否必须	备注
username	string	必须	用户名
password	string	必须	密码

请求数据样例：

{
    "username": "jinyong",
    "password": "123456"
}

1.3.1.3.1.3 响应数据

参数格式：application/json

参数说明：

名称	类型	是否必须	备注
code	number	必须	响应码, 1 成功 ; 0 失败
msg	string	非必须	提示信息
data	string	必须	返回的数据 , jwt令牌

响应数据样例：

{
  "code": 1,
  "msg": "success",
  "data": "eyJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoi6YeR5bq4IiwiaWQiOjEsInVzZXJuYW1lIjoiamlueW9uZyIsImV4cCI6MTY2MjIwNzA0OH0.KkUc_CXJZJ8Dd063eImx4H9Ojfrr6XMJ-yVzaWCVZCo"
}

1.3.1.3.1.4 备注说明

用户登录成功后，系统会自动下发JWT令牌，然后在后续的每次请求中，都需要在请求头header中携带到服务端，请求头的名称为 token ，值为登录时下发的JWT令牌。

如果检测到用户未登录，则会返回如下固定错误信息：
{
    "code": 0,
    "msg": "NOT_LOGIN",
    "data": null
}

1.3.2 Resful风格

1.3.3 统一响应结果

package com.runa.pojo;

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

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result {
    private Integer code;//响应码，1 代表成功; 0 代表失败
    private String msg;  //响应信息 描述字符串
    private Object 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);
    }
}

1.3.4 思路

二、部门管理

2.1 查询部门

2.1.1 思路

2.1.2 DeptController

package com.runa.controller;

import com.runa.pojo.Result;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;

/**
 * 部门管理Controller
 */
@Slf4j
@RestController
public class Deptcontroller {

//    private static Logger log = LoggerFactory.getLogger(Deptcontroller.class);

//    @RequestMapping(value = "/depts", method = RequestMethod.GET)  //指定请求方式为GET
    @GetMapping("/depts")  //
    public Result list(){
        log.info("查询全部部门数据");
        return Result.success();

    }
}

可以启动服务测试一下

继续优化

package com.runa.controller;

import com.runa.pojo.Dept;
import com.runa.pojo.Result;
import com.runa.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;

/**
 * 部门管理Controller
 */
@Slf4j
@RestController
public class Deptcontroller {

    @Autowired
    private DeptService deptService;

//    private static Logger log = LoggerFactory.getLogger(Deptcontroller.class);
//    @RequestMapping(value = "/depts", method = RequestMethod.GET)  //指定请求方式为GET
    @GetMapping("/depts")  //
    public Result list(){
        log.info("查询全部部门数据");

        // 调用 service查询部门数据
        List<Dept> deptList = deptService.list();

        return Result.success(deptList);

    }
}

2.1.3 DeptService

package com.runa.service;

import com.runa.pojo.Dept;

import java.util.List;

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

2.1.4 DeptServiceImpl

package com.runa.service.impl;

import com.runa.mapper.DeptMapper;
import com.runa.pojo.Dept;
import com.runa.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptMapper deptMapper;

    @Override
    public List<Dept> list() {

        return deptMapper.list();
    }
}

2.1.5 DeptMapper

package com.runa.mapper;

import com.runa.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 * from springbootproject.dept")
    List<Dept> list();
}

2.1.6 启动服务测试

2.1.7 前后端联调

前端代码下载

2.1.8 总结

2.2 删除部门

2.2.1 思路

2.2.2 DeptController

package com.runa.controller;

import com.runa.pojo.Dept;
import com.runa.pojo.Result;
import com.runa.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;

/**
 * 部门管理Controller
 */
@Slf4j
@RestController
public class Deptcontroller {

    @Autowired
    private DeptService deptService;

    /**
     * 查询部门数据
     * @return
     */
//    private static Logger log = LoggerFactory.getLogger(Deptcontroller.class);
//    @RequestMapping(value = "/depts", method = RequestMethod.GET)  //指定请求方式为GET
    @GetMapping("/depts")  //
    public Result list(){
        log.info("查询全部部门数据");

        // 调用 service查询部门数据
        List<Dept> deptList = deptService.list();

        return Result.success(deptList);

    }

    /**
     * 删除部门
     * @return
     */
    @DeleteMapping("/depts/{id}")
    public Result delete(@PathVariable Integer id){
        log.info("根据id删除部门：{}", id);

        //   调用service删除部门
        deptService.delete(id);
        return Result.success();

    }
}

2.2.3 DeptService

package com.runa.service;

import com.runa.pojo.Dept;

import java.util.List;

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

    /**
     * 依据id删除部门
     * @param id
     */
    void delete(Integer id);
}

2.2.4 DeptServiceImpl

package com.runa.service.impl;

import com.runa.mapper.DeptMapper;
import com.runa.pojo.Dept;
import com.runa.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptMapper deptMapper;

    /**
     * 查询部门
     * @return
     */
    @Override
    public List<Dept> list() {

        return deptMapper.list();
    }

    /**
     * 根据ID删除部门
     * @param id
     */
    @Override
    public void delete(Integer id) {
        deptMapper.deleteById(id);
    }
}

2.2.5 DeptMapper

package com.runa.mapper;

import com.runa.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 * from springbootproject.dept")
    List<Dept> list();

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

2.1.6 启动服务测试

2.2.7 前后端联调

2.3 新增部门

2.3.1 思路

2.3.2 DeptController

package com.runa.controller;

import com.runa.pojo.Dept;
import com.runa.pojo.Result;
import com.runa.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;

/**
 * 部门管理Controller
 */
@Slf4j
@RestController
public class Deptcontroller {

    @Autowired
    private DeptService deptService;

    /**
     * 查询部门数据
     * @return
     */
//    private static Logger log = LoggerFactory.getLogger(Deptcontroller.class);
//    @RequestMapping(value = "/depts", method = RequestMethod.GET)  //指定请求方式为GET
    @GetMapping("/depts")  //
    public Result list(){
        log.info("查询全部部门数据");

        // 调用 service查询部门数据
        List<Dept> deptList = deptService.list();

        return Result.success(deptList);

    }

    /**
     * 删除部门
     * @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();

    }
}

2.3.3 DeptService

package com.runa.service;

import com.runa.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);
}

2.3.4 DeptServiceImpl

package com.runa.service.impl;

import com.runa.mapper.DeptMapper;
import com.runa.pojo.Dept;
import com.runa.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptMapper deptMapper;

    /**
     * 查询部门
     * @return
     */
    @Override
    public List<Dept> list() {

        return deptMapper.list();
    }

    /**
     * 根据ID删除部门
     * @param id
     */
    @Override
    public void delete(Integer id) {
        deptMapper.deleteById(id);
    }

    /**
     * 新增部门
     * @param dept
     */
    @Override
    public void add(Dept dept) {
        dept.setCreateTime(LocalDateTime.now());
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.insert(dept);
    }
}

2.3.5 DeptMapper

package com.runa.mapper;

import com.runa.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 * from springbootproject.dept")
    List<Dept> list();

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

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

2.3.6 启动服务-测试

2.3.7 前后端联调

2.4 优化DeptController的路径

package com.runa.controller;

import com.runa.pojo.Dept;
import com.runa.pojo.Result;
import com.runa.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;

/**
 * 部门管理Controller
 */
@Slf4j
@RequestMapping("/depts")
@RestController
public class Deptcontroller {

    @Autowired
    private DeptService deptService;

    /**
     * 查询部门数据
     * @return
     */
//    private static Logger log = LoggerFactory.getLogger(Deptcontroller.class);
//    @RequestMapping(value = "/depts", method = RequestMethod.GET)  //指定请求方式为GET
    @GetMapping  //
    public Result list(){
        log.info("查询全部部门数据");

        // 调用 service查询部门数据
        List<Dept> deptList = deptService.list();

        return Result.success(deptList);

    }

    /**
     * 删除部门
     * @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();

    }
}

2.5 根据id查询部门

2.5.1 DeptController

package com.runa.controller;

import com.runa.pojo.Dept;
import com.runa.pojo.Result;
import com.runa.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;

/**
 * 部门管理Controller
 */
@Slf4j
@RestController
@RequestMapping("/depts")
public class Deptcontroller {

    @Autowired
    private DeptService deptService;

    /**
     * 查询部门数据
     * @return
     */
//    private static Logger log = LoggerFactory.getLogger(Deptcontroller.class);
//    @RequestMapping(value = "/depts", method = RequestMethod.GET)  //指定请求方式为GET
    @GetMapping  //
    public Result list(){
        log.info("查询全部部门数据");

        // 调用 service查询部门数据
        List<Dept> deptList = deptService.list();

        return Result.success(deptList);

    }

    /**
     * 删除部门
     * @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();

    }


    /**
     * 根据ID查询部门
     * @return
     */
    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id){
        log.info("根据id查询部门：{}", id);

        //   调用service查询部门
        Dept dept = deptService.getById(id);
        return Result.success(dept);

    }
}

2.5.2 DeptService

package com.runa.service;

import com.runa.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);

    /**
     * 根据id查询部门
     * @param id
     * @return
     */
    Dept getById(Integer id);
}

2.5.3 DeptServiceImpl

package com.runa.service.impl;

import com.runa.mapper.DeptMapper;
import com.runa.pojo.Dept;
import com.runa.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptMapper deptMapper;

    /**
     * 查询部门
     * @return
     */
    @Override
    public List<Dept> list() {

        return deptMapper.list();
    }

    /**
     * 根据ID删除部门
     * @param id
     */
    @Override
    public void delete(Integer id) {
        deptMapper.deleteById(id);
    }

    /**
     * 新增部门
     * @param dept
     */
    @Override
    public void add(Dept dept) {
        dept.setCreateTime(LocalDateTime.now());
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.insert(dept);
    }

    /**
     * 根据id查询部门
     * @param id
     * @return
     */
    @Override
    public Dept getById(Integer id) {
        return deptMapper.getById(id);
    }
}

2.5.4 DeptMapper

package com.runa.mapper;

import com.runa.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 * from springbootproject.dept")
    List<Dept> list();

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

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

    /**
     * 根据id查询部门
     * @return
     */
    @Select("select * from springbootproject.dept where id = #{id}")
    Dept getById(Integer id);
}

2.5.5 启动服务-测试

2.5.6 前后端联调

2.6 修改部门

2.6.1 DeptController

package com.runa.controller;

import com.runa.pojo.Dept;
import com.runa.pojo.Result;
import com.runa.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;

/**
 * 部门管理Controller
 */
@Slf4j
@RestController
@RequestMapping("/depts")
public class Deptcontroller {

    @Autowired
    private DeptService deptService;

    /**
     * 查询部门数据
     * @return
     */
//    private static Logger log = LoggerFactory.getLogger(Deptcontroller.class);
//    @RequestMapping(value = "/depts", method = RequestMethod.GET)  //指定请求方式为GET
    @GetMapping  //
    public Result list(){
        log.info("查询全部部门数据");

        // 调用 service查询部门数据
        List<Dept> deptList = deptService.list();

        return Result.success(deptList);

    }

    /**
     * 删除部门
     * @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();

    }


    /**
     * 根据ID查询部门
     * @return
     */
    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id){
        log.info("根据id查询部门：{}", id);

        //   调用service查询部门
        Dept dept = deptService.getById(id);
        return Result.success(dept);

    }

    /**
     * 编辑部门
     * @return
     */
    @PutMapping
    public Result update(@RequestBody Dept dept){
        log.info("编辑部门：{}==={}", dept.getId(),dept.getName());
        //   调用service编辑部门
        deptService.update(dept);
        return Result.success();

    }
}

2.6.2 DeptService

package com.runa.service;

import com.runa.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);

    /**
     * 根据id查询部门
     * @param id
     * @return
     */
    Dept getById(Integer id);

    /**
     * 编辑用户
     */
    void update(Dept dept);


}

2.6.3 DeptServiceImpl

package com.runa.service.impl;

import com.runa.mapper.DeptMapper;
import com.runa.pojo.Dept;
import com.runa.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptMapper deptMapper;

    /**
     * 查询部门
     * @return
     */
    @Override
    public List<Dept> list() {

        return deptMapper.list();
    }

    /**
     * 根据ID删除部门
     * @param id
     */
    @Override
    public void delete(Integer id) {
        deptMapper.deleteById(id);
    }

    /**
     * 新增部门
     * @param dept
     */
    @Override
    public void add(Dept dept) {
        dept.setCreateTime(LocalDateTime.now());
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.insert(dept);
    }

    /**
     * 根据id查询部门
     * @param id
     * @return
     */
    @Override
    public Dept getById(Integer id) {
        return deptMapper.getById(id);
    }

    /**
     * 编辑部门
     * @param dept
     */
    @Override
    public void update(Dept dept) {
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.update(dept);

    }


}

2.6.4 DeptMapper

package com.runa.mapper;

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

import java.util.List;

/**
 * 部门管理
 */
@Mapper
public interface DeptMapper {
    /**
     * 查询全部部门
     * @return
     */
    @Select("select * from springbootproject.dept")
    List<Dept> list();

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

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

    /**
     * 根据id查询部门
     * @return
     */
    @Select("select * from springbootproject.dept where id = #{id}")
    Dept getById(Integer id);


    /**
     * 编辑部门
     */
    @Update("update dept set name = #{name}, update_time = #{updateTime}  where id = #{id}")
    void update(Dept dept);
}

2.6.5 启动服务-测试

2.6.6 前后端联调

三、员工管理

3.1 分页查询

3.1.1 思路

3.1.2 PageBean分页查询结果实体类

package com.runa.pojo;

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

import java.util.List;

/**
 * 分页查询的结果类
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class PageBean {
    
    //  这里的定义名称要与接口文档一致性
    private long total; // 总记录数
    private List rows; //数据列表

}

3.1.3 EmpController

package com.runa.controller;

import com.runa.pojo.PageBean;
import com.runa.pojo.Result;

import com.runa.service.EmpService;
import lombok.extern.slf4j.Slf4j;
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.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * 员工管理Controller
 */
@Slf4j
@RequestMapping("/emps")
@RestController
public class EmpController {

    @Autowired
    private EmpService empService;

    @GetMapping
    public Result page(@RequestParam(defaultValue = "1") Integer page, @RequestParam(defaultValue = "10") Integer pageSize){
        log.info("分页查询，参数：开始页 {}, 每页显示：{}", page, pageSize);
        // 调用Service方法进行查询
        PageBean pageBean = empService.page(page,pageSize);

        return Result.success(pageBean);
    }
}

3.1.4 EmpService

package com.runa.service;

import com.runa.pojo.PageBean;

public interface EmpService {



    /**
     * 分页查询
     * @param page
     * @param pageSize
     * @return
     */
    PageBean page(Integer page, Integer pageSize);

}

3.1.5 EmpServiceImpl

package com.runa.service.impl;

import com.runa.mapper.EmpMapper;
import com.runa.pojo.Emp;
import com.runa.pojo.PageBean;
import com.runa.service.EmpService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class EmpServiceImpl implements EmpService {

    @Autowired
    private EmpMapper empMapper;

    /**
     * 分页查询
     * @param page
     * @param pageSize
     * @return
     */
    @Override
    public PageBean page(Integer page, Integer pageSize) {
        // 1 获取总记录数
        Long count = empMapper.count();

        // 2 获取分页查询结果列表
        Integer start = (page - 1) * pageSize;
        List<Emp> empList = empMapper.page(start, pageSize);

        // 3 封装PangeBean对象
        PageBean pageBean = new PageBean(count,empList);

        return pageBean;
    }
}

3.1.6 EmpMapper

package com.runa.mapper;

import com.runa.pojo.Emp;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * 员工管理
 */
@Mapper
public interface EmpMapper {

    /**
     * 查询总记录数
     * @return
     */
    @Select("select count(*) from emp")
    public Long count();

    /**
     * 分页查询 获取列表数据
     * @param start
     * @param pageSize
     * @return
     */
    @Select("select * from emp limit #{start}, #{pageSize}")
    public List<Emp> page(Integer start, Integer pageSize);
}

3.1.7 启动服务-测试

控制台没有看到这个，就说明pagehelper版本有问题

3.1.8 前后端联调

3.1.9 总结

3.1.10 使用分页插件 PageHelper优化代码

3.1.10.1 引入 PageHelper依赖

使用1.4.2版本没有成功，换成1.4.6就OK了

       <!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper-spring-boot-starter -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.4.6</version>
        </dependency>

3.1.10.2 EmpMapper

package com.runa.mapper;

import com.runa.pojo.Emp;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * 员工管理
 */
@Mapper
public interface EmpMapper {

    /**
     * 查询总记录数
     * @return
     */
//    @Select("select count(*) from emp")
//    public Long count();

    /**
     * 分页查询 获取列表数据
     * @param start
     * @param pageSize
     * @return
     */
//    @Select("select * from emp limit #{start}, #{pageSize}")
//    public List<Emp> page(Integer start, Integer pageSize);
    /**
     * 使用pagehelper的员工信息查询
     * @return
     */
    @Select("select * from emp")
    public List<Emp> list();

}

3.1.10.3 EmpServiceImpl

package com.runa.service.impl;

import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.runa.mapper.EmpMapper;
import com.runa.pojo.Emp;
import com.runa.pojo.PageBean;
import com.runa.service.EmpService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class EmpServiceImpl implements EmpService {

    @Autowired
    private EmpMapper empMapper;

    /**
     * 分页查询
     * @param page
     * @param pageSize
     * @return
     */
    @Override
    public PageBean page(Integer page, Integer pageSize) {
//        // 1 获取总记录数
//        Long count = empMapper.count();
//
//        // 2 获取分页查询结果列表
//        Integer start = (page - 1) * pageSize;
//        List<Emp> empList = empMapper.page(start, pageSize);
//
//        // 3 封装PangeBean对象
//        PageBean pageBean = new PageBean(count,empList);

        // 1 设置分页参数
        PageHelper.startPage(page, pageSize);

        // 2 执行查询
        List<Emp> empList = empMapper.list();
        Page<Emp> p = (Page<Emp>) empList;

        // 3 封装PangeBean对象
        PageBean pageBean = new PageBean(p.getTotal(),p.getResult());
        return pageBean;
    }
}

3.1.10.4 启动服务-测试

3.1.10.5 前后端联调

3.1.10.6 总结

3.2 分页查询（带条件）

3.2.1 思路

3.2.2 EmpController

package com.runa.controller;

import com.runa.pojo.PageBean;
import com.runa.pojo.Result;

import com.runa.service.EmpService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDate;

/**
 * 员工管理Controller
 */
@Slf4j
@RequestMapping("/emps")
@RestController
public class EmpController {

    @Autowired
    private EmpService empService;

    /**
     * 员工数据查询列表 ，  不带条件
     * @param page
     * @param pageSize
     * @return
     */
    //    @GetMapping
//    public Result page(@RequestParam(defaultValue = "1") Integer page,
//                       @RequestParam(defaultValue = "10") Integer pageSize){
//        log.info("分页查询，参数：开始页 {}, 每页显示：{}", page, pageSize);
//        // 调用Service方法进行查询
//        PageBean pageBean = empService.page(page,pageSize);
//
//        return Result.success(pageBean);
//    }

    /**
     * 员工数据查询列表 ，  带条件组合查询
     * @param page
     * @param pageSize
     * @param name
     * @param gender
     * @param begin
     * @param end
     * @return
     */
    @GetMapping
    public Result page(@RequestParam(defaultValue = "1") Integer page,
                       @RequestParam(defaultValue = "10") Integer pageSize,
                       String name, Short gender,
                       @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin,
                       @DateTimeFormat(pattern = "yyyy-MM-dd")  LocalDate end){
        log.info("分页查询，参数：开始页 {}, 每页显示：{},姓名：{},性别：{}, 开始日期：{},结束日期:{}", page, pageSize, name, gender, begin, end);
        // 调用Service方法进行查询
        PageBean pageBean = empService.page(page, pageSize, name, gender, begin, end);

        return Result.success(pageBean);
    }



}

3.2.3 EmpService

package com.runa.service;

import com.runa.pojo.PageBean;
import org.springframework.format.annotation.DateTimeFormat;

import java.time.LocalDate;

public interface EmpService {



    /**
     * 分页查询  不带条件
     * @param page
     * @param pageSize
     * @return
     */
//    PageBean page(Integer page, Integer pageSize);

    /**
     * 分页查询 带条件
     * @param page
     * @param pageSize
     * @return
     */
    PageBean page(Integer page, Integer pageSize,String name, Short gender, LocalDate begin, LocalDate end);

}

3.2.4 EmpServiceImpl

package com.runa.service.impl;



import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.runa.mapper.EmpMapper;
import com.runa.pojo.Emp;
import com.runa.pojo.PageBean;
import com.runa.service.EmpService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.util.List;

@Service
public class EmpServiceImpl implements EmpService {

    @Autowired
    private EmpMapper empMapper;

    /**
     * 分页查询 pagehelper+组合查询
     * @param page
     * @param pageSize
     * @param name
     * @param gender
     * @param begin
     * @param end
     * @return
     */
    @Override
    public PageBean page(Integer page, Integer pageSize, String name, Short gender, LocalDate begin, LocalDate end) {
        // 1 设置分页参数
        PageHelper.startPage(page, pageSize);

        // 2 执行查询
        List<Emp> empList = empMapper.list(name, gender, begin, end);
        Page<Emp> p = (Page<Emp>) empList;

        // 3 封装PangeBean对象
        PageBean pageBean = new PageBean(p.getTotal(),((Page<Emp>) empList).getResult());
        return pageBean;
    }


    /**
     * 分页查询  加pagehelper
     * @param page
     * @param pageSize
     * @return
     */
//    @Override
//    public PageBean page(Integer page, Integer pageSize) {
//        // 1 设置分页参数
//        PageHelper.startPage(page, pageSize);
//
//        // 2 执行查询
//        List<Emp> empList = empMapper.list();
//        Page<Emp> p = (Page<Emp>) empList;
//
//        // 3 封装PangeBean对象
//        PageBean pageBean = new PageBean(p.getTotal(),((Page<Emp>) empList).getResult());
//        return pageBean;
//    }

    /**
     * 分页查询
     * @param page
     * @param pageSize
     * @return
     */
//    @Override
//    public PageBean page(Integer page, Integer pageSize) {
//        // 1 获取总记录数
//        Long count = empMapper.count();
//
//        // 2 获取分页查询结果列表
//        Integer start = (page - 1) * pageSize;
//        List<Emp> empList = empMapper.page(start, pageSize);
//
//        // 3 封装PangeBean对象
//        PageBean pageBean = new PageBean(count,empList);
//    }


}

3.2.5 EmpMapper

package com.runa.mapper;

import com.runa.pojo.Emp;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.time.LocalDate;
import java.util.List;

/**
 * 员工管理
 */
@Mapper
public interface EmpMapper {

    /**
     * 查询总记录数
     * @return
     */
//    @Select("select count(*) from emp")
//    public Long count();

    /**
     * 分页查询 获取列表数据
     * @param start
     * @param pageSize
     * @return
     */
//    @Select("select * from emp limit #{start}, #{pageSize}")
//    public List<Emp> page(Integer start, Integer pageSize);
    /**
     * 使用pagehelper的员工信息查询
     * @return
     */
//    @Select("select * from emp")
//    public List<Emp> list();

    /**
     * 使用pagehelper的员工信息查询(带条件)--动态sql
     * 使用xml注解sql
     * @return
     */

    public List<Emp> list(String name, Short gender, LocalDate begin, LocalDate end);

}

3.2.6 EmpMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.runa.mapper.EmpMapper">
    <select id="list" resultType="com.runa.pojo.Emp">
        select * from emp
        <where>
            <if test="name != null">
                name like concat('%', #{name}, '%')
            </if>

            <if test="gender != null">
                and gender = #{gender}
            </if>

            <if test="begin != null and end != null">
                and entrydate between #{begin} and #{end}

            </if>
                 order by update_time desc
        </where>
    </select>


</mapper>

注意sql不要有结束；符号

3.2.7 启动服务-测试

3.2.8 前后端联调

3.2.9 总结

3.3 删除员工

3.3.1 思路

3.3.2 EmpController

package com.runa.controller;

import com.runa.pojo.PageBean;
import com.runa.pojo.Result;

import com.runa.service.EmpService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDate;
import java.util.List;

/**
 * 员工管理Controller
 */
@Slf4j
@RequestMapping("/emps")
@RestController
public class EmpController {

    @Autowired
    private EmpService empService;

    /**
     * 员工数据查询列表 ，  不带条件
     * @param page
     * @param pageSize
     * @return
     */
    //    @GetMapping
//    public Result page(@RequestParam(defaultValue = "1") Integer page,
//                       @RequestParam(defaultValue = "10") Integer pageSize){
//        log.info("分页查询，参数：开始页 {}, 每页显示：{}", page, pageSize);
//        // 调用Service方法进行查询
//        PageBean pageBean = empService.page(page,pageSize);
//
//        return Result.success(pageBean);
//    }

    /**
     * 员工数据查询列表 ，  带条件组合查询
     * @param page
     * @param pageSize
     * @param name
     * @param gender
     * @param begin
     * @param end
     * @return
     */
    @GetMapping
    public Result page(@RequestParam(defaultValue = "1") Integer page,
                       @RequestParam(defaultValue = "10") Integer pageSize,
                       String name, Short gender,
                       @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin,
                       @DateTimeFormat(pattern = "yyyy-MM-dd")  LocalDate end){
        log.info("分页查询，参数：开始页 {}, 每页显示：{},姓名：{},性别：{}, 开始日期：{},结束日期:{}", page, pageSize, name, gender, begin, end);
        // 调用Service方法进行查询
        PageBean pageBean = empService.page(page, pageSize, name, gender, begin, end);

        return Result.success(pageBean);
    }

    /**
     * 批量删除员工
     * @param ids
     * @return
     */
    @DeleteMapping("/{ids}")
    public Result delete(@PathVariable List<Integer> ids){
        log.info("批量删除的操作,删除对象为：{}",ids);
        empService.delete(ids);
        return Result.success();

    }

}

3.3.3 EmpService

package com.runa.service;

import com.runa.pojo.PageBean;
import org.springframework.format.annotation.DateTimeFormat;

import java.time.LocalDate;
import java.util.List;

public interface EmpService {



    /**
     * 分页查询  不带条件
     * @param page
     * @param pageSize
     * @return
     */
//    PageBean page(Integer page, Integer pageSize);

    /**
     * 分页查询 带条件
     * @param page
     * @param pageSize
     * @return
     */
    PageBean page(Integer page, Integer pageSize,String name, Short gender, LocalDate begin, LocalDate end);

    /**
     * 批量删除员工
     * @param ids
     */
    void delete(List<Integer> ids);
}

3.3.4 EmpServiceImpl

package com.runa.service.impl;



import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.runa.mapper.EmpMapper;
import com.runa.pojo.Emp;
import com.runa.pojo.PageBean;
import com.runa.service.EmpService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.util.List;

@Service
public class EmpServiceImpl implements EmpService {

    @Autowired
    private EmpMapper empMapper;

    /**
     * 分页查询 pagehelper+组合查询
     * @param page
     * @param pageSize
     * @param name
     * @param gender
     * @param begin
     * @param end
     * @return
     */
    @Override
    public PageBean page(Integer page, Integer pageSize, String name, Short gender, LocalDate begin, LocalDate end) {
        // 1 设置分页参数
        PageHelper.startPage(page, pageSize);

        // 2 执行查询
        List<Emp> empList = empMapper.list(name, gender, begin, end);
        Page<Emp> p = (Page<Emp>) empList;

        // 3 封装PangeBean对象
        PageBean pageBean = new PageBean(p.getTotal(),((Page<Emp>) empList).getResult());
        return pageBean;
    }

    /**
     * 批量删除员工
     * @param ids
     */
    @Override
    public void delete(List<Integer> ids) {
        empMapper.delete(ids);

    }


    /**
     * 分页查询  加pagehelper
     * @param page
     * @param pageSize
     * @return
     */
//    @Override
//    public PageBean page(Integer page, Integer pageSize) {
//        // 1 设置分页参数
//        PageHelper.startPage(page, pageSize);
//
//        // 2 执行查询
//        List<Emp> empList = empMapper.list();
//        Page<Emp> p = (Page<Emp>) empList;
//
//        // 3 封装PangeBean对象
//        PageBean pageBean = new PageBean(p.getTotal(),((Page<Emp>) empList).getResult());
//        return pageBean;
//    }

    /**
     * 分页查询
     * @param page
     * @param pageSize
     * @return
     */
//    @Override
//    public PageBean page(Integer page, Integer pageSize) {
//        // 1 获取总记录数
//        Long count = empMapper.count();
//
//        // 2 获取分页查询结果列表
//        Integer start = (page - 1) * pageSize;
//        List<Emp> empList = empMapper.page(start, pageSize);
//
//        // 3 封装PangeBean对象
//        PageBean pageBean = new PageBean(count,empList);
//    }


}

3.3.5 EmpMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.runa.mapper.EmpMapper">
        <!--    批量删除员工  -->
    <delete id="delete">
        delete from emp where id in
        <foreach collection="ids" item="id" separator="," open="(" close=")">
            #{id}
        </foreach>
    </delete>
        <!--    条件查询-->
    <select id="list" resultType="com.runa.pojo.Emp">
        select * from emp
        <where>
            <if test="name != null">
                name like concat('%', #{name}, '%')
            </if>

            <if test="gender != null">
                and gender = #{gender}
            </if>

            <if test="begin != null and end != null">
                and entrydate between #{begin} and #{end}

            </if>
                 order by update_time desc
        </where>

    </select>


</mapper>

3.3.6 EmpMapper

package com.runa.mapper;

import com.runa.pojo.Emp;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.time.LocalDate;
import java.util.List;

/**
 * 员工管理
 */
@Mapper
public interface EmpMapper {

    /**
     * 查询总记录数
     * @return
     */
//    @Select("select count(*) from emp")
//    public Long count();

    /**
     * 分页查询 获取列表数据
     * @param start
     * @param pageSize
     * @return
     */
//    @Select("select * from emp limit #{start}, #{pageSize}")
//    public List<Emp> page(Integer start, Integer pageSize);
    /**
     * 使用pagehelper的员工信息查询
     * @return
     */
//    @Select("select * from emp")
//    public List<Emp> list();

    /**
     * 使用pagehelper的员工信息查询(带条件)--动态sql
     * 使用xml注解sql
     * @return
     */

    public List<Emp> list(String name, Short gender, LocalDate begin, LocalDate end);

    /**
     * 批量删除员工
     * @param ids
     */
    void delete(List<Integer> ids);
}

3.3.7 启动服务-测试

3.3.8 前后端联调

3.4 新增员工

3.4.1 思路

3.4.2 EmpController

package com.runa.controller;

import com.runa.pojo.Emp;
import com.runa.pojo.PageBean;
import com.runa.pojo.Result;

import com.runa.service.EmpService;
import jakarta.annotation.PostConstruct;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDate;
import java.util.List;

/**
 * 员工管理Controller
 */
@Slf4j
@RequestMapping("/emps")
@RestController
public class EmpController {

    @Autowired
    private EmpService empService;

    /**
     * 员工数据查询列表 ，  不带条件
     * @param page
     * @param pageSize
     * @return
     */
    //    @GetMapping
//    public Result page(@RequestParam(defaultValue = "1") Integer page,
//                       @RequestParam(defaultValue = "10") Integer pageSize){
//        log.info("分页查询，参数：开始页 {}, 每页显示：{}", page, pageSize);
//        // 调用Service方法进行查询
//        PageBean pageBean = empService.page(page,pageSize);
//
//        return Result.success(pageBean);
//    }

    /**
     * 员工数据查询列表 ，  带条件组合查询
     * @param page
     * @param pageSize
     * @param name
     * @param gender
     * @param begin
     * @param end
     * @return
     */
    @GetMapping
    public Result page(@RequestParam(defaultValue = "1") Integer page,
                       @RequestParam(defaultValue = "10") Integer pageSize,
                       String name, Short gender,
                       @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin,
                       @DateTimeFormat(pattern = "yyyy-MM-dd")  LocalDate end){
        log.info("分页查询，参数：开始页 {}, 每页显示：{},姓名：{},性别：{}, 开始日期：{},结束日期:{}", page, pageSize, name, gender, begin, end);
        // 调用Service方法进行查询
        PageBean pageBean = empService.page(page, pageSize, name, gender, begin, end);

        return Result.success(pageBean);
    }

    /**
     * 批量删除员工
     * @param ids
     * @return
     */
    @DeleteMapping("/{ids}")
    public Result delete(@PathVariable List<Integer> ids){
        log.info("批量删除的操作,删除对象为：{}",ids);
        empService.delete(ids);
        return Result.success();

    }

    /**
     * 新增员工
     * @param emp
     * @return
     */
    @PostMapping
    public Result save(@RequestBody Emp emp){
        log.info("新增员工emp： {}",emp);
        empService.save(emp);
        return Result.success();
    }

}

3.4.3 EmpService

package com.runa.service;

import com.runa.pojo.Emp;
import com.runa.pojo.PageBean;
import org.springframework.format.annotation.DateTimeFormat;

import java.time.LocalDate;
import java.util.List;

public interface EmpService {



    /**
     * 分页查询  不带条件
     * @param page
     * @param pageSize
     * @return
     */
//    PageBean page(Integer page, Integer pageSize);

    /**
     * 分页查询 带条件
     * @param page
     * @param pageSize
     * @return
     */
    PageBean page(Integer page, Integer pageSize,String name, Short gender, LocalDate begin, LocalDate end);

    /**
     * 批量删除员工
     * @param ids
     */
    void delete(List<Integer> ids);

    /**
     * 新增员工
     * @param emp
     */
    void save(Emp emp);
}

3.4.4 EmpServiceImpl

package com.runa.service.impl;



import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.runa.mapper.EmpMapper;
import com.runa.pojo.Emp;
import com.runa.pojo.PageBean;
import com.runa.service.EmpService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
public class EmpServiceImpl implements EmpService {

    @Autowired
    private EmpMapper empMapper;

    /**
     * 分页查询 pagehelper+组合查询
     * @param page
     * @param pageSize
     * @param name
     * @param gender
     * @param begin
     * @param end
     * @return
     */
    @Override
    public PageBean page(Integer page, Integer pageSize, String name, Short gender, LocalDate begin, LocalDate end) {
        // 1 设置分页参数
        PageHelper.startPage(page, pageSize);

        // 2 执行查询
        List<Emp> empList = empMapper.list(name, gender, begin, end);
        Page<Emp> p = (Page<Emp>) empList;

        // 3 封装PangeBean对象
        PageBean pageBean = new PageBean(p.getTotal(),((Page<Emp>) empList).getResult());
        return pageBean;
    }

    /**
     * 批量删除员工
     * @param ids
     */
    @Override
    public void delete(List<Integer> ids) {
        empMapper.delete(ids);

    }

    /**
     * 新增员工
     * @param emp
     */
    @Override
    public void save(Emp emp) {
        emp.setCreateTime(LocalDateTime.now());
        emp.setUpdateTime(LocalDateTime.now());
        empMapper.insert(emp);

    }


    /**
     * 分页查询  加pagehelper
     * @param page
     * @param pageSize
     * @return
     */
//    @Override
//    public PageBean page(Integer page, Integer pageSize) {
//        // 1 设置分页参数
//        PageHelper.startPage(page, pageSize);
//
//        // 2 执行查询
//        List<Emp> empList = empMapper.list();
//        Page<Emp> p = (Page<Emp>) empList;
//
//        // 3 封装PangeBean对象
//        PageBean pageBean = new PageBean(p.getTotal(),((Page<Emp>) empList).getResult());
//        return pageBean;
//    }

    /**
     * 分页查询
     * @param page
     * @param pageSize
     * @return
     */
//    @Override
//    public PageBean page(Integer page, Integer pageSize) {
//        // 1 获取总记录数
//        Long count = empMapper.count();
//
//        // 2 获取分页查询结果列表
//        Integer start = (page - 1) * pageSize;
//        List<Emp> empList = empMapper.page(start, pageSize);
//
//        // 3 封装PangeBean对象
//        PageBean pageBean = new PageBean(count,empList);
//    }


}

3.4.5 EmpMapper

package com.runa.mapper;

import com.runa.pojo.Emp;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;

import java.time.LocalDate;
import java.util.List;

/**
 * 员工管理
 */
@Mapper
public interface EmpMapper {


    /**
     * 查询总记录数
     * @return
     */
//    @Select("select count(*) from emp")
//    public Long count();

    /**
     * 分页查询 获取列表数据
     * @param start
     * @param pageSize
     * @return
     */
//    @Select("select * from emp limit #{start}, #{pageSize}")
//    public List<Emp> page(Integer start, Integer pageSize);
    /**
     * 使用pagehelper的员工信息查询
     * @return
     */
//    @Select("select * from emp")
//    public List<Emp> list();

    /**
     * 使用pagehelper的员工信息查询(带条件)--动态sql
     * 使用xml注解sql
     * @return
     */

    public List<Emp> list(String name, Short gender, LocalDate begin, LocalDate end);

    /**
     * 批量删除员工
     * @param ids
     */
    void delete(List<Integer> ids);

    /**
     * 新增员工
     * @param emp
     */
    @Insert("insert into emp(username, name, gender, image, job, entrydate, dept_id, create_time, update_time)" +
            " values(#{username}, #{name}, #{gender}, #{image}, #{job}, #{entrydate}, #{deptId}, #{createTime}, #{updateTime})")
    void insert(Emp emp);
}

3.4.6 启动服务-测试

3.4.7 前后端联调

3.5 文件上传

3.5.1 简介

3.5.1.1 upload.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>上传文件</title>
</head>
<body>

    <form action="/upload" method="post" enctype="multipart/form-data">
        姓名: <input type="text" name="username"><br>
        年龄: <input type="text" name="age"><br>
        头像: <input type="file" name="image"><br>
        <input type="submit" value="提交">
    </form>

</body>
</html>

txt 内容自己定义即可

3.5.1.2 UploadController

package com.runa.controller;

import com.runa.pojo.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

@Slf4j
@RestController
public class UploadController {

    @PostMapping("/upload")
    public Result upload(String username, Integer age, MultipartFile image){
        log.info("文件上传：{},{},{}",username,age,image);
        return Result.success();

    }
}

3.5.1.3 启动服务-测试

多试几次

http://localhost:8080/upload.html

3.5.1.4 总结

3.5.2 本地存储

3.5.2.1 UploadController

package com.runa.controller;

import com.runa.pojo.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;

@Slf4j
@RestController
public class UploadController {

    @PostMapping("/upload")
    public Result upload(String username, Integer age, MultipartFile image) throws Exception {
        log.info("文件上传：{},{},{}",username,age,image);
        // 将接收到的文件存储在服务器的磁盘目录当中 D:\
        image.transferTo(new File("D:\\images\\" + image.getOriginalFilename()));

        return Result.success();

    }
}

3.5.2.2 启动服务-测试

3.5.2.3 优化（确保存储文件名唯一UUID）UploadController

package com.runa.controller;

import com.runa.pojo.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.UUID;

@Slf4j
@RestController
public class UploadController {

    @PostMapping("/upload")
    public Result upload(String username, Integer age, MultipartFile image) throws Exception {
        log.info("文件上传：{},{},{}",username,age,image);

        // 获取原始文件名
        String originalFilename = image.getOriginalFilename();

        // 构造唯一的文件名（不能重复） uuid
        int index = originalFilename.lastIndexOf(".");
        String extname = originalFilename.substring(index);

        String newFileName = UUID.randomUUID().toString() + extname;
        log.info(" 新的文件名： {}",newFileName);
        // 将接收到的文件存储在服务器的磁盘目录当中 D:\
        image.transferTo(new File("D:\\images\\" + newFileName));

        return Result.success();

    }
}

3.5.2.4 优化配置文件上传大小application.properties


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

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

#开启mybatis的驼峰命名自动映射开关 a_column ------> aCloumn
mybatis.configuration.map-underscore-to-camel-case=true

# 配置单个文件最大上传大小
spring.servlet.multipart.max-file-size=10MB

# 配置单个请求最大大小的限制（一次请求中是可以上传多个文件）
spring.servlet.multipart.max-request-size=100MB

3.5.2.5 扩展

3.5.3 阿里云OSS

3.5.3.1 通用思路

3.5.3.2 阿里云OSS准备工作

云存储解决方案-阿里云OSS

链接：https://pan.baidu.com/s/16i8-kgqqW7r5xZ-5r-eTaQ
提取码：私聊

3.5.3.3 安装依赖


        <!--        阿里云OSS依赖-->
        <dependency>
            <groupId>com.aliyun.oss</groupId>
            <artifactId>aliyun-sdk-oss</artifactId>
            <version>3.15.1</version>
        </dependency>
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.3.1</version>
        </dependency>
        <dependency>
            <groupId>javax.activation</groupId>
            <artifactId>activation</artifactId>
            <version>1.1.1</version>
        </dependency>
        <!-- no more than 2.3.3-->
        <dependency>
            <groupId>org.glassfish.jaxb</groupId>
            <artifactId>jaxb-runtime</artifactId>
            <version>2.3.3</version>
        </dependency>

3.5.3.4 示例代码

package com.runa;

import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.model.PutObjectRequest;
import com.aliyun.oss.model.PutObjectResult;
import java.io.FileInputStream;
import java.io.InputStream;

public class Demo {

    public static void main(String[] args) throws Exception {
        // Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // 填写Bucket名称，例如examplebucket。
        String bucketName = "examplebucket";
        // 填写Object完整路径，完整路径中不能包含Bucket名称，例如exampledir/exampleobject.txt。
        String objectName = "exampledir/exampleobject.txt";
        // 填写本地文件的完整路径，例如D:\\localpath\\examplefile.txt。
        // 如果未指定本地路径，则默认从示例程序所属项目对应本地路径中上传文件流。
        String filePath= "D:\\localpath\\examplefile.txt";

        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, credentialsProvider);

        try {
            InputStream inputStream = new FileInputStream(filePath);
            // 创建PutObjectRequest对象。
            PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, objectName, inputStream);
            // 创建PutObject请求。
            PutObjectResult result = ossClient.putObject(putObjectRequest);
        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }
}

依据自己的修改代码

运行main

3.6 新增页面集成文件上传阿里云OOS

3.6.1 思路

3.6.2 引人阿里云上传OSS上传文件工具类

package com.runa.utils;

import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
import java.io.*;
import java.util.UUID;

/**
 * 阿里云 OSS 工具类
 */
@Component
public class AliOSSUtils {

    private String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
    private String accessKeyId = "LTAI4GCH1vX6DKqJWxd6nEuW";
    private String accessKeySecret = "yBshYweHOpqDuhCArrVHwIiBKpyqSL";
    private String bucketName = "web-tlias";

    /**
     * 实现上传图片到OSS
     */
    public String upload(MultipartFile file) throws IOException {
        // 获取上传的文件的输入流
        InputStream inputStream = file.getInputStream();

        // 避免文件覆盖
        String originalFilename = file.getOriginalFilename();
        String fileName = UUID.randomUUID().toString() + originalFilename.substring(originalFilename.lastIndexOf("."));

        //上传文件到 OSS
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        ossClient.putObject(bucketName, fileName, inputStream);

        //文件访问路径
        String url = endpoint.split("//")[0] + "//" + bucketName + "." + endpoint.split("//")[1] + "/" + fileName;
        // 关闭ossClient
        ossClient.shutdown();
        return url;// 把上传到oss的路径返回
    }

}

3.6.3 UploadController

package com.runa.controller;

import com.runa.pojo.Result;
import com.runa.utils.AliOSSUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.UUID;


@Slf4j
@RestController
public class UploadController {

    @Autowired
    private AliOSSUtils aliOSSUtils;  //注入

//    /**
//     * 本地存储代码
//     * @param username
//     * @param age
//     * @param image
//     * @return
//     * @throws Exception
//     */
//    @PostMapping("/upload")
//    public Result upload(String username, Integer age, MultipartFile image) throws Exception {
//        log.info("文件上传：{},{},{}",username,age,image);
//
//        // 获取原始文件名
//        String originalFilename = image.getOriginalFilename();
//
//        // 构造唯一的文件名（不能重复） uuid
//        int index = originalFilename.lastIndexOf(".");
//        String extname = originalFilename.substring(index);
//
//        String newFileName = UUID.randomUUID().toString() + extname;
//        log.info(" 新的文件名： {}",newFileName);
//        // 将接收到的文件存储在服务器的磁盘目录当中 D:\
//        image.transferTo(new File("D:\\images\\" + newFileName));
//
//        return Result.success();
//    }

    @PostMapping("/upload")
    public Result upload(MultipartFile image) throws Exception {
        log.info("文件上传：{}",image.getOriginalFilename());
        // 调用阿里云OSS工具类
        String url = aliOSSUtils.upload(image); //调用阿里云OSS工具类，将上传上来的文件存入阿里云
        log.info("文件上传完成。文件访问url：{}",url);
        return Result.success(url); // 将图片上传完成后的url返回，用于浏览器回显展示
    }

}

3.6.4 启动服务-测试

3.6.5 前后端联调

3.6.6 总结

3.7 修改员工

3.7.1 思路

3.7.2 查询回显

3.7.2.1 思路

3.7.2.2 EmpController

package com.runa.controller;

import com.runa.pojo.Emp;
import com.runa.pojo.PageBean;
import com.runa.pojo.Result;

import com.runa.service.EmpService;
import jakarta.annotation.PostConstruct;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDate;
import java.util.List;

/**
 * 员工管理Controller
 */
@Slf4j
@RequestMapping("/emps")
@RestController
public class EmpController {

    @Autowired
    private EmpService empService;

    /**
     * 员工数据查询列表 ，  不带条件
     * @param page
     * @param pageSize
     * @return
     */
    //    @GetMapping
//    public Result page(@RequestParam(defaultValue = "1") Integer page,
//                       @RequestParam(defaultValue = "10") Integer pageSize){
//        log.info("分页查询，参数：开始页 {}, 每页显示：{}", page, pageSize);
//        // 调用Service方法进行查询
//        PageBean pageBean = empService.page(page,pageSize);
//
//        return Result.success(pageBean);
//    }

    /**
     * 员工数据查询列表 ，  带条件组合查询
     * @param page
     * @param pageSize
     * @param name
     * @param gender
     * @param begin
     * @param end
     * @return
     */
    @GetMapping
    public Result page(@RequestParam(defaultValue = "1") Integer page,
                       @RequestParam(defaultValue = "10") Integer pageSize,
                       String name, Short gender,
                       @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin,
                       @DateTimeFormat(pattern = "yyyy-MM-dd")  LocalDate end){
        log.info("分页查询，参数：开始页 {}, 每页显示：{},姓名：{},性别：{}, 开始日期：{},结束日期:{}", page, pageSize, name, gender, begin, end);
        // 调用Service方法进行查询
        PageBean pageBean = empService.page(page, pageSize, name, gender, begin, end);

        return Result.success(pageBean);
    }

    /**
     * 批量删除员工
     * @param ids
     * @return
     */
    @DeleteMapping("/{ids}")
    public Result delete(@PathVariable List<Integer> ids){
        log.info("批量删除的操作,删除对象为：{}",ids);
        empService.delete(ids);
        return Result.success();

    }

    /**
     * 新增员工
     * @param emp
     * @return
     */
    @PostMapping
    public Result save(@RequestBody Emp emp){
        log.info("新增员工emp： {}",emp);
        empService.save(emp);
        return Result.success();
    }

    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id){
        log.info("根据ID查询员工信息：{}",id);
        Emp emp = empService.getById(id);
        return Result.success(emp);
    }

}

3.7.2.3 EmpService

package com.runa.service;

import com.runa.pojo.Emp;
import com.runa.pojo.PageBean;
import org.springframework.format.annotation.DateTimeFormat;

import java.time.LocalDate;
import java.util.List;

public interface EmpService {



    /**
     * 分页查询  不带条件
     * @param page
     * @param pageSize
     * @return
     */
//    PageBean page(Integer page, Integer pageSize);

    /**
     * 分页查询 带条件
     * @param page
     * @param pageSize
     * @return
     */
    PageBean page(Integer page, Integer pageSize,String name, Short gender, LocalDate begin, LocalDate end);

    /**
     * 批量删除员工
     * @param ids
     */
    void delete(List<Integer> ids);

    /**
     * 新增员工
     * @param emp
     */
    void save(Emp emp);

    /**
     * 根据id查询员工
     * @param id
     * @return
     */
    Emp getById(Integer id);
}

3.7.2.4 EmpServiceImpl

package com.runa.service.impl;



import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.runa.mapper.EmpMapper;
import com.runa.pojo.Emp;
import com.runa.pojo.PageBean;
import com.runa.service.EmpService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
public class EmpServiceImpl implements EmpService {

    @Autowired
    private EmpMapper empMapper;

    /**
     * 分页查询 pagehelper+组合查询
     * @param page
     * @param pageSize
     * @param name
     * @param gender
     * @param begin
     * @param end
     * @return
     */
    @Override
    public PageBean page(Integer page, Integer pageSize, String name, Short gender, LocalDate begin, LocalDate end) {
        // 1 设置分页参数
        PageHelper.startPage(page, pageSize);

        // 2 执行查询
        List<Emp> empList = empMapper.list(name, gender, begin, end);
        Page<Emp> p = (Page<Emp>) empList;

        // 3 封装PangeBean对象
        PageBean pageBean = new PageBean(p.getTotal(),((Page<Emp>) empList).getResult());
        return pageBean;
    }

    /**
     * 批量删除员工
     * @param ids
     */
    @Override
    public void delete(List<Integer> ids) {
        empMapper.delete(ids);

    }

    /**
     * 新增员工
     * @param emp
     */
    @Override
    public void save(Emp emp) {
        emp.setCreateTime(LocalDateTime.now());
        emp.setUpdateTime(LocalDateTime.now());
        empMapper.insert(emp);

    }

    /**
     * 根据ID查询员工
     * @param id
     * @return
     */
    @Override
    public Emp getById(Integer id) {

        return empMapper.getByID(id);
    }


    /**
     * 分页查询  加pagehelper
     * @param page
     * @param pageSize
     * @return
     */
//    @Override
//    public PageBean page(Integer page, Integer pageSize) {
//        // 1 设置分页参数
//        PageHelper.startPage(page, pageSize);
//
//        // 2 执行查询
//        List<Emp> empList = empMapper.list();
//        Page<Emp> p = (Page<Emp>) empList;
//
//        // 3 封装PangeBean对象
//        PageBean pageBean = new PageBean(p.getTotal(),((Page<Emp>) empList).getResult());
//        return pageBean;
//    }

    /**
     * 分页查询
     * @param page
     * @param pageSize
     * @return
     */
//    @Override
//    public PageBean page(Integer page, Integer pageSize) {
//        // 1 获取总记录数
//        Long count = empMapper.count();
//
//        // 2 获取分页查询结果列表
//        Integer start = (page - 1) * pageSize;
//        List<Emp> empList = empMapper.page(start, pageSize);
//
//        // 3 封装PangeBean对象
//        PageBean pageBean = new PageBean(count,empList);
//    }


}

3.7.2.5 EmpMapper

package com.runa.mapper;

import com.runa.pojo.Emp;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.time.LocalDate;
import java.util.List;

/**
 * 员工管理
 */
@Mapper
public interface EmpMapper {


    /**
     * 查询总记录数
     * @return
     */
//    @Select("select count(*) from emp")
//    public Long count();

    /**
     * 分页查询 获取列表数据
     * @param start
     * @param pageSize
     * @return
     */
//    @Select("select * from emp limit #{start}, #{pageSize}")
//    public List<Emp> page(Integer start, Integer pageSize);
    /**
     * 使用pagehelper的员工信息查询
     * @return
     */
//    @Select("select * from emp")
//    public List<Emp> list();

    /**
     * 使用pagehelper的员工信息查询(带条件)--动态sql
     * 使用xml注解sql
     * @return
     */

    public List<Emp> list(String name, Short gender, LocalDate begin, LocalDate end);

    /**
     * 批量删除员工
     * @param ids
     */
    void delete(List<Integer> ids);

    /**
     * 新增员工
     * @param emp
     */
    @Insert("insert into emp(username, name, gender, image, job, entrydate, dept_id, create_time, update_time)" +
            " values(#{username}, #{name}, #{gender}, #{image}, #{job}, #{entrydate}, #{deptId}, #{createTime}, #{updateTime})")
    void insert(Emp emp);

    /**
     * 根据id查询员工
     * @param id
     * @return
     */
    @Select("select * from emp where id = #{id}")
    Emp getByID(Integer id);
}

3.7.2.6 启动服务-测试

3.7.2.7 前后端联调

3.7.3 修改员工

3.7.3.1 思路

3.7.3.2 EmpController

package com.runa.controller;

import com.runa.pojo.Emp;
import com.runa.pojo.PageBean;
import com.runa.pojo.Result;

import com.runa.service.EmpService;
import jakarta.annotation.PostConstruct;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDate;
import java.util.List;

/**
 * 员工管理Controller
 */
@Slf4j
@RequestMapping("/emps")
@RestController
public class EmpController {

    @Autowired
    private EmpService empService;

    /**
     * 员工数据查询列表 ，  不带条件
     * @param page
     * @param pageSize
     * @return
     */
    //    @GetMapping
//    public Result page(@RequestParam(defaultValue = "1") Integer page,
//                       @RequestParam(defaultValue = "10") Integer pageSize){
//        log.info("分页查询，参数：开始页 {}, 每页显示：{}", page, pageSize);
//        // 调用Service方法进行查询
//        PageBean pageBean = empService.page(page,pageSize);
//
//        return Result.success(pageBean);
//    }

    /**
     * 员工数据查询列表 ，  带条件组合查询
     * @param page
     * @param pageSize
     * @param name
     * @param gender
     * @param begin
     * @param end
     * @return
     */
    @GetMapping
    public Result page(@RequestParam(defaultValue = "1") Integer page,
                       @RequestParam(defaultValue = "10") Integer pageSize,
                       String name, Short gender,
                       @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin,
                       @DateTimeFormat(pattern = "yyyy-MM-dd")  LocalDate end){
        log.info("分页查询，参数：开始页 {}, 每页显示：{},姓名：{},性别：{}, 开始日期：{},结束日期:{}", page, pageSize, name, gender, begin, end);
        // 调用Service方法进行查询
        PageBean pageBean = empService.page(page, pageSize, name, gender, begin, end);

        return Result.success(pageBean);
    }

    /**
     * 批量删除员工
     * @param ids
     * @return
     */
    @DeleteMapping("/{ids}")
    public Result delete(@PathVariable List<Integer> ids){
        log.info("批量删除的操作,删除对象为：{}",ids);
        empService.delete(ids);
        return Result.success();

    }

    /**
     * 新增员工
     * @param emp
     * @return
     */
    @PostMapping
    public Result save(@RequestBody Emp emp){
        log.info("新增员工emp： {}",emp);
        empService.save(emp);
        return Result.success();
    }

    /**
     * 根据id查询员工
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id){
        log.info("根据ID查询员工信息：{}",id);
        Emp emp = empService.getById(id);
        return Result.success(emp);
    }

    /**
     * 修改员工
     * @param emp
     * @return
     */
    @PutMapping
    public Result update(@RequestBody Emp emp){
        log.info("更新员工: {}",emp);
        empService.update(emp);
        return Result.success();
    }

}

3.7.3.3 EmpService

package com.runa.service;

import com.runa.pojo.Emp;
import com.runa.pojo.PageBean;
import org.springframework.format.annotation.DateTimeFormat;

import java.time.LocalDate;
import java.util.List;

public interface EmpService {



    /**
     * 分页查询  不带条件
     * @param page
     * @param pageSize
     * @return
     */
//    PageBean page(Integer page, Integer pageSize);

    /**
     * 分页查询 带条件
     * @param page
     * @param pageSize
     * @return
     */
    PageBean page(Integer page, Integer pageSize,String name, Short gender, LocalDate begin, LocalDate end);

    /**
     * 批量删除员工
     * @param ids
     */
    void delete(List<Integer> ids);

    /**
     * 新增员工
     * @param emp
     */
    void save(Emp emp);

    /**
     * 根据id查询员工
     * @param id
     * @return
     */
    Emp getById(Integer id);

    /**
     * 修改员工
     * @param emp
     */
    void update(Emp emp);
}

3.7.3.4 EmpServiceImpl

package com.runa.service.impl;



import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.runa.mapper.EmpMapper;
import com.runa.pojo.Emp;
import com.runa.pojo.PageBean;
import com.runa.service.EmpService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
public class EmpServiceImpl implements EmpService {

    @Autowired
    private EmpMapper empMapper;

    /**
     * 分页查询 pagehelper+组合查询
     * @param page
     * @param pageSize
     * @param name
     * @param gender
     * @param begin
     * @param end
     * @return
     */
    @Override
    public PageBean page(Integer page, Integer pageSize, String name, Short gender, LocalDate begin, LocalDate end) {
        // 1 设置分页参数
        PageHelper.startPage(page, pageSize);

        // 2 执行查询
        List<Emp> empList = empMapper.list(name, gender, begin, end);
        Page<Emp> p = (Page<Emp>) empList;

        // 3 封装PangeBean对象
        PageBean pageBean = new PageBean(p.getTotal(),((Page<Emp>) empList).getResult());
        return pageBean;
    }

    /**
     * 批量删除员工
     * @param ids
     */
    @Override
    public void delete(List<Integer> ids) {
        empMapper.delete(ids);

    }

    /**
     * 新增员工
     * @param emp
     */
    @Override
    public void save(Emp emp) {
        emp.setCreateTime(LocalDateTime.now());
        emp.setUpdateTime(LocalDateTime.now());
        empMapper.insert(emp);

    }

    /**
     * 根据ID查询员工
     * @param id
     * @return
     */
    @Override
    public Emp getById(Integer id) {

        return empMapper.getByID(id);
    }

    /**
     * 修改员工
     * @param emp
     */
    @Override
    public void update(Emp emp) {
        emp.setUpdateTime(LocalDateTime.now());
        empMapper.update(emp);

    }


    /**
     * 分页查询  加pagehelper
     * @param page
     * @param pageSize
     * @return
     */
//    @Override
//    public PageBean page(Integer page, Integer pageSize) {
//        // 1 设置分页参数
//        PageHelper.startPage(page, pageSize);
//
//        // 2 执行查询
//        List<Emp> empList = empMapper.list();
//        Page<Emp> p = (Page<Emp>) empList;
//
//        // 3 封装PangeBean对象
//        PageBean pageBean = new PageBean(p.getTotal(),((Page<Emp>) empList).getResult());
//        return pageBean;
//    }

    /**
     * 分页查询
     * @param page
     * @param pageSize
     * @return
     */
//    @Override
//    public PageBean page(Integer page, Integer pageSize) {
//        // 1 获取总记录数
//        Long count = empMapper.count();
//
//        // 2 获取分页查询结果列表
//        Integer start = (page - 1) * pageSize;
//        List<Emp> empList = empMapper.page(start, pageSize);
//
//        // 3 封装PangeBean对象
//        PageBean pageBean = new PageBean(count,empList);
//    }


}

3.7.3.5 EmpMapper

package com.runa.mapper;

import com.runa.pojo.Emp;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.time.LocalDate;
import java.util.List;

/**
 * 员工管理
 */
@Mapper
public interface EmpMapper {


    /**
     * 查询总记录数
     * @return
     */
//    @Select("select count(*) from emp")
//    public Long count();

    /**
     * 分页查询 获取列表数据
     * @param start
     * @param pageSize
     * @return
     */
//    @Select("select * from emp limit #{start}, #{pageSize}")
//    public List<Emp> page(Integer start, Integer pageSize);
    /**
     * 使用pagehelper的员工信息查询
     * @return
     */
//    @Select("select * from emp")
//    public List<Emp> list();

    /**
     * 使用pagehelper的员工信息查询(带条件)--动态sql
     * 使用xml注解sql
     * @return
     */

    public List<Emp> list(String name, Short gender, LocalDate begin, LocalDate end);

    /**
     * 批量删除员工
     * @param ids
     */
    void delete(List<Integer> ids);

    /**
     * 新增员工
     * @param emp
     */
    @Insert("insert into emp(username, name, gender, image, job, entrydate, dept_id, create_time, update_time)" +
            " values(#{username}, #{name}, #{gender}, #{image}, #{job}, #{entrydate}, #{deptId}, #{createTime}, #{updateTime})")
    void insert(Emp emp);

    /**
     * 根据id查询员工
     * @param id
     * @return
     */
    @Select("select * from emp where id = #{id}")
    Emp getByID(Integer id);

    /**
     * 修改员工
     * @param emp
     */
    void update(Emp emp);
}

3.7.3.6 EmpMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.runa.mapper.EmpMapper">
<!--    修改员工-->
    <update id="update">
        update emp
        <set>
            <if test="username != null and username != ''">
                username = #{username},
            </if>
            <if test="password != null and password != ''">
                password = #{password},
            </if>
            <if test="name != null and name != ''">
                name = #{name},
            </if>
            <if test="gender != null">
                gender = #{gender},
            </if>
            <if test="image != null and image != ''">
                image = #{image},
            </if>
            <if test="job != null">
                job = #{job},
            </if>
            <if test="entrydate != null">
                entrydate = #{entrydate},
            </if>
            <if test="deptId != null">
                dept_id = #{deptId},
            </if>
            <if test="updateTime != null">
                update_time = #{updateTime}
            </if>
        </set>
        where id = #{id}
    </update>

    <!--    批量删除员工  -->
    <delete id="delete">
        delete from emp where id in
        <foreach collection="ids" item="id" separator="," open="(" close=")">
            #{id}
        </foreach>
    </delete>
        <!--    条件查询-->
    <select id="list" resultType="com.runa.pojo.Emp">
        select * from emp
        <where>
            <if test="name != null">
                name like concat('%', #{name}, '%')
            </if>

            <if test="gender != null">
                and gender = #{gender}
            </if>

            <if test="begin != null and end != null">
                and entrydate between #{begin} and #{end}

            </if>
                 order by update_time desc
        </where>

    </select>


</mapper>