基于SpringBoot和MyBatis框架的简单使用

发表于 | 更新于 | 分类于 | 评论数： | 阅读次数：
本文字数： 3,200字 | 阅读时长 ≈ 23 分钟

平台

  window10
  Intellij IDEA2020
  Spring Boot2.3.3
  Java SDK 1.8
  MySQL 8.0.19
  Navicat15

简介

Swagger

  Swagger是一个规范且完整的框架，用于生成、描述、调用和可视化 RESTful风格的Web服务。
  Swagger的目标是对REST API定义一个标准且和语言无关的接口，可以让人和计算机拥有无须访问源码、文档或网络流量监测就可以发现和理解服务的能力。当通过Swagger进行正确定义，用户可以理解远程服务并使用最少实现逻辑与远程服务进行交互。与为底层编程所实现的接口类似，Swagger消除了调用服务时可能会有的猜测。
  Swagger的优势：

  1. 支持API自动生成同步的在线文档：使用Swagger后可以直接通过代码生成文档，不再需要自己手动编写接口文档了，对程序员来说非常方便，可以节约写文档的时间去学习新技术。
  2. 提供Web页面在线测试API：光有文档还不够，Swagger生成的文档还支持在线测试。参数和格式都定好了，直接在界面上输入参数对应的值即可在线测试接口。

OAS

  OAS是OpenAPI Specification的简称，可以翻译为OpenAPI规范，它是定义API的一种规范，它的前身是Swagger规范。

OAS与Swagger

  OAS定义了一种书写API的一种格式，大家通过遵从同一种格式规范达到API文档的统一。狭义上理解，它用于描述一整套API接口，包括一个接口是GET还是POST请求，有哪些参数，哪些header等等，它在设计的时候通常是YAML格式，这种格式书写起来比较方便，而在网络中传输时又会以json形式居多，因为json的通用性比较强。OpenAPI Specification已经在2015年捐献给了Linux基金会，现在已经成为RESTful API的世界标准。
  Swagger是一个工具、一个项目、一个流行的API开发框架(当然，我们上面也说了Swagger是规范，但是后面演变成了OAS)，这个框架以OAS为基础，对整个API的开发周期都提供了相应的解决方案，是一个非常庞大的项目(包括Swagger Editor、Swagger UI、Swagger Codegen、Swagger Inspector)。

Springfox

  Springfox是践行OAS的一个项目，它将Swagger融合进流行的Spring框架，根据OpenAPI规范，帮助开发者自动生成API文档。Springfox是由Marty Pitt创建的项目swagger-springmvc发展而来。它其中有一个组件叫springfox-swagger2，springfox-swagger2是依赖OSA规范文档，也就是一个描述API的json文件，而这个组件的功能就是帮助我们自动生成这个json文件，我们会用到的另外一个组件springfox-swagger-ui就是将这个json文件解析出来，用一种更友好的方式呈现出来。

总结

  Swagger是一种规范。springfox-swagger是基于Spring生态系统的该规范的实现。springfox-swagger-ui是对swagger-ui的封装，使得其可以使用 Spring的服务。
  也就是Swagger是规范，协议，Spring是实现。(Spring是一个主流的Java Web`开发框架，该框架是一个轻量级的应用框架，具有很高的凝聚力和吸引力。)

参考博客

  OAS、Swagger和Springfox

建立数据库

安装软件

  首先安装数据库和数据库可视工具(任意一个)，具体可参考：MySQL 8.0.19安装教程(windows 64位)+ Navicat破解安装教程

新建数据库

  首先建立一个连接，并设置好参数：
新建连接
  这里的用户名和密码为建立数据库时的配置。
  然后在该连接上建立一个数据库，点击新建查询，并输入以下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
-- ----------------------------
-- Table structure for doctor_info
-- ----------------------------
DROP TABLE IF EXISTS `doctor_info`;
CREATE TABLE `doctor_info`  (
  `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
  `gender` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
  `age` int(0) NULL DEFAULT NULL,
  `post` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
  `department` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
  `employeeID` int(0) NULL DEFAULT NULL
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of doctor_info
-- ----------------------------
INSERT INTO `doctor_info` VALUES ('Cxx', '男', 26, '医师', '检验科', 12345);
INSERT INTO `doctor_info` VALUES ('Xll', '男', 25, '实习医生', '住院部', 23456);

SET FOREIGN_KEY_CHECKS = 1;

  然后点击运行即可查看新建的表。

基于Spring Web和MyBatic框架的Swagger ui实现

建立工程

  打开开发工具Intellij IDEA2020，选择New->Project，选择java sdk 1.8，然后选择自己的Group和Artifact，然后这里的依赖选择Web里面的Spring Web和SQL里面的JDBC API、MyBatic Framework和MySQL Driver。然后选择Next->Finish建立工程。
新建工程

更改配置文件

  打开工程文件夹里面src\resources下的配置文件application.properties，设置数据库的连接参数：

1
2
3
4
5
spring.datasource.url=jdbc:mysql://localhost:3306/ruikedaqi?\
 serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

安装依赖库

  打开工程文件夹里面的pom.xml，在里面添加依赖文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
<!--添加spring boot依赖-->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.9.2</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.9.2</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.31</version>
</dependency>

<!--mysql连接类-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

<!--添加JDBC依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

<!--添加druid依赖-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.0.20</version>
</dependency>

  点击右上角位置出现的更新按钮，即可下载更新。

建立工程文件目录包

  首先在工程文件中建立几个包

1
2
3
4
bean          // 使用实体类
config        // 配置类
controller    // 前端接口类
mapper        // 数据库映射关系类

  最终的文件夹结构为：
工程文件文件目录结构

config包

  新建一个配置类MyConfig(名字任意，下同)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
@Configuration
@EnableSwagger2
public class MyConfig {
    //配置swagger2核心配置docket
    //修改默认配置bean
    @Bean
    public Docket myDocket(){
        return new Docket(DocumentationType.SWAGGER_2)  //指定API类型为swagger2
                .apiInfo(apiInfo())  //用于定于api文档汇总信息
                .select()
                .apis(RequestHandlerSelectors
                        .basePackage("com.ruikedaqi.sql.controller"))  //指定controller包
                .paths(PathSelectors.any())        // 所有controller
                .build();
    }


    private ApiInfo apiInfo(){
        return new ApiInfoBuilder()
                .title("睿科大器医疗机器人")     // 文档页标题
                .contact(new Contact("Cxx",  // 联系人信息
                        "www.baidu.com",
                        "@email"))
                .description("睿科大器医疗机器人有限公司")   // 详细信息
                .version("1.0.1")   // 文档版本号
                .termsOfServiceUrl("www.baidu.com")  //网站地址
                .build();
    }
}

  注意这里的basePackage为刚才的conntroller包的路径，要修改为自己的。
  Spring Boot框架是利用注解来表明类的作用。例如这里的@Configuration表明这是一个配置类，@EnableSwagger2表明使用的是Swagger2。
  编译运行后，在浏览器打开http://localhost:8080/swagger-ui.html#/即可看到生成的API文档：
初始API文档

bean包

DoctorInfo类

  首先建立一个DoctorInfo类，里面存放的是数据库里面的信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
public class DoctorInfo {
    private String name;
    private String gender;
    private int age;
    private String post;
    private String department;
    private int employeeID;

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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

    public String getPost() {
        return post;
    }

    public void setPost(String post) {
        this.post = post;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    public int getEmployeeID() {
        return employeeID;
    }

    public void setEmployeeID(int employeeID) {
        this.employeeID = employeeID;
    }

    @Override
    public String toString(){
        return "doctorInfo{" +
                "name" + name +
                ", gender='" + gender + '\'' +
                ", age='" + age + '\'' +
                ", post='" + post + '\'' +
                ", department='" + department + '\'' +
                ", employeeID='" + employeeID + '\'' +
                '}';
    }
}

  这里的属性就是刚才建立的数据表里面的表头信息，并设置其get和set方法。

ResultMessage

  因为API获取的数据一般为json格式，因此还需要定义一个返回数据信息格式的类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class ResultMessage implements Serializable {
    private int code = 0;
    private String message;
    private Map<String, Object> result = new HashMap<>();

    private ResultMessage(){

    }

    public static ResultMessage create(){
        return new ResultMessage();
    }

    public int getCode(){
        return this.code;
    }

    public String getMessage(){
        return this.message;
    }

    public void raise(int code, String message){
        this.code = code;
        this.message = message;
    }

    public void put(String key, Object obj){
        this.result.put(key, obj);
    }

    public Map<String, Object> getAttr(){
        return this.result;
    }
}

  这里一共定义3个属性：code、message和result，分别代表正确/错误码、信息提示和结果。并分为定义2个方法：raise()和put用来显示信息提示和添加结果。

mapper包

  新建一个DoctorMapper的接口，在里面定义数据库的映射关系：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Mapper
public interface DoctorMapper {
    /**通过姓名查询*/
    @Select("SELECT * FROM ruikedaqi.doctor_info WHERE name = #{name}")
    DoctorInfo getByName(@Param("name") String name);

    /**插入表记录*/
    @Insert("INSERT INTO ruikedaqi.doctor_info(name,gender,age,post,department,employeeID) VALUES(#{name},#{gender},#{age},#{post},#{department},#{employeeID})")
    int create(DoctorInfo doctorInfo);

    /*删除记录*/
    @Delete("DELETE FROM ruikedaqi.doctor_info where name=#{name}")
    int deleteByName(@Param("name") String name);

    /*根据姓名修改职务记录*/
    @Update("UPDATE ruikedaqi.doctor_info SET department=#{department} where name=#{name}")
    int updateDepartmentByName(@Param("name") String name, @Param("department") String department);
}

  这里注意要添加类注解@Mapper。
  每个方法均需要添加注解，表明是数据库中的哪种操作类型。本例中只提供了几个常用的增删改查操作。

controller包

  最后就是建立核心的controller包。
  建立DoctorInfoController类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
//提示码
//code -1  姓名不存在/不能为空
//code 999 姓名已存在
//code 101 增加成功
//code 102 删除成功
//code 103 修改成功
//code 104 查询成功

@RestController
public class DoctorInfoController {

    private boolean isNotNull(@RequestParam(value = "name", required = true) String name,
                              ResultMessage resultMessage) {
        if (name == null || name.equals("")){
            resultMessage.raise(-1,"姓名不能为空");
            return true;
        }
        return false;
    }

    @Autowired
    private DoctorMapper doctorMapper;

    /**
     * 插入数据
     */
    @PostMapping(value = "/doctor/add")
    public Object registerDoctor(@RequestParam(value = "name", required = true) String name,
                                 @RequestParam(value = "gender", required = true) String gender,
                                 @RequestParam(value = "age", required = true) int age,
                                 @RequestParam(value = "post", required = true) String post,
                                 @RequestParam(value = "department", required = true) String department,
                                 @RequestParam(value = "employeeID", required = true) int employeeID) {

        ResultMessage resultMessage = ResultMessage.create();

        //判断user name空值
        if (isNotNull(name, resultMessage)) return resultMessage;

        DoctorInfo doctorInfo = this.doctorMapper.getByName(name);
        if (doctorInfo != null){
            resultMessage.raise(999, "姓名已存在");
            return resultMessage;
        }else{
            resultMessage.put("name",name);
            resultMessage.put("gender",gender);
            resultMessage.put("age",age);
            resultMessage.put("post",post);
            resultMessage.put("department",department);
            resultMessage.put("employeeID",employeeID);
            resultMessage.raise(101,"增加成功");

            doctorInfo = new DoctorInfo();
            doctorInfo.setName(name);
            doctorInfo.setGender(gender);
            doctorInfo.setAge(age);
            doctorInfo.setPost(post);
            doctorInfo.setDepartment(department);
            doctorInfo.setEmployeeID(employeeID);
            int createName = this.doctorMapper.create(doctorInfo);
            return resultMessage;
        }
    }

    /**
     * 通过name查询信息
     */
    @GetMapping(value = "doctor/getInfo/ByName/{name}")
    public Object getInfoByName(@PathVariable String name) {
        DoctorInfo doctorInfo = this.doctorMapper.getByName(name);

        ResultMessage resultMessage = ResultMessage.create();

        if (doctorInfo == null){
            resultMessage.raise(-1,"姓名不存在");
            return resultMessage;
        }

        resultMessage.put("name",doctorInfo.getName());
        resultMessage.put("gender",doctorInfo.getGender());
        resultMessage.put("age",doctorInfo.getAge());
        resultMessage.put("post",doctorInfo.getPost());
        resultMessage.put("department",doctorInfo.getDepartment());
        resultMessage.put("employeeID",doctorInfo.getEmployeeID());
        resultMessage.raise(104,"查询成功");

        return resultMessage;
    }

    /**
     * 通过name删除信息
     */
    @PostMapping(value = "doctor/deleteInfo/ByName/{name}")
    public Object deleteInfoByName(@PathVariable String name) {
        DoctorInfo doctorInfo = this.doctorMapper.getByName(name);

        ResultMessage resultMessage = ResultMessage.create();

        if (doctorInfo == null){
            resultMessage.raise(-1,"user不存在");
            return resultMessage;
        }

        resultMessage.raise(102,"删除成功");
        int deleteName = this.doctorMapper.deleteByName(name);

        return resultMessage;
    }

    /**
     * 通过name修改职务信息D
     */
    @PostMapping(value = "doctor/updateDepartment/ByName/{name},{department}")
    public Object updateDepartmentByName(@PathVariable String name, @PathVariable String department) {
        DoctorInfo doctorInfo = this.doctorMapper.getByName(name);

        ResultMessage resultMessage = ResultMessage.create();

        if (doctorInfo == null){
            resultMessage.raise(-1,"user不存在");
            return resultMessage;
        }

        resultMessage.raise(103,"修改成功");
        int updateDepartmentByName = this.doctorMapper.updateDepartmentByName(name,department);

        return resultMessage;
    }
}

  @RestController表明这是一个控制类。@PostMapping表明这是一个post方法，@GetMapping表明这是一个get方法，后面的value就是具体的请求地址。

本地运行并测试

  点击build和run按钮，打开浏览器输入本地测试地址http://localhost:8080/swagger-ui.html：
本地运行
  打开第3个/doctor/getInfo/ByName/{name}``API，并点击Try it out，输入内容即可进行简单的测试。
简单测试

部署到服务器

生成jar包

  点击右侧的Maven选项卡，打开Lifecycle，依次双击clean和package，生成的jar包在工程文件夹的target文件夹中。
生成jar包
  将生成的jar包放在ubuntu系统中，打开终端输入命令：

1
nohup java -jar ***.jar --server.port=8181 >debug.log 2>&1 &

  nohup表示一直运行，--server.port=8181表示开启服务器端的端口号，debug.log为日志文件，可以查看报错信息等。

谢谢老板！
-------------本文结束感谢您的阅读给个五星好评吧~~-------------
欢迎光临
❤️
NJTech Cxx
请多关照
❤️
❤️