（硅谷课堂项目）Java开发笔记2：项目概述，搭建项目环境和开发讲师管理接口_硅谷课堂项目责任描述

（硅谷课堂项目）Java开发笔记2：项目概述，搭建项目环境和开发讲师管理接口

1.项目概述

1.1 项目介绍

硅谷课堂是尚硅谷与腾讯云官方合作的项目，是一款基于微信公众号B2C模式的在线学习平台，该平台包含三大模块：直播、教学与微信消息服务；平台会定期推出直播课程，方便学员与名师之间的交流互动，学员也可以购买教学视频在线学习，分享直播与教学视频获取平台收益，平台支持直播、腾讯云视频点播、微信支付、微信授权登录、微信菜单、微信消息与腾讯云文件存储等一系列功能，为学员构建了一个全方位的在线学习平台。

1.2 硅谷课程流程图

1.3 硅谷课堂功能架构

1.4 硅谷课堂技术架构

1.5 硅谷课堂核心技术

(1)后端技术

SpringBoot：简化新Spring应用的初始搭建以及开发过程

SpringCloud：基于Spring Boot实现的云原生应用开发工具，SpringCloud使用的技术：（Spring Cloud Gateway、Spring Cloud Alibaba Nacos、Spring Cloud Alibaba Sentinel、Spring Cloud Alibaba Seata、Spring Cloud Task和Spring Cloud Feign等）

MyBatis-Plus：持久层框架

Redis：内存缓存

RabbitMQ：消息中间件

腾讯云：文件存储

腾讯云：视频点播

欢拓云直播：直播平台

微信支付

Nginx：负载均衡

Lombok

Mysql：关系型数据库

(2)前端技术

Vue.js：web 界面的渐进式框架

Node.js： JavaScript 运行环境

Axios：Axios 是一个基于 promise 的 HTTP 库

NPM：包管理器

Babel：转码器

Webpack：打包工具

(3)其他技术

Docker ：容器技术

Git：代码管理工具

DockerFile：管理Docker镜像命令文本

2.搭建项目工程

本次笔记主要内容：

前后端分离：

2.1 项目数据库设计

2.1.1 创建数据库和表

2.1.2 数据库设计规则

以下规则只针对本模块，更全面的文档参考《阿里巴巴Java开发手册》：

1、库名与应用名称尽量一致

2、表名、字段名必须使用小写字母或数字，禁止出现数字开头，

3、表名不使用复数名词

4、表的命名最好是加上“业务名称_表的作用”。如，edu_teacher

5、表必备三字段：id, gmt_create, gmt_modified

说明：

其中 id 必为主键，类型为 bigint unsigned、单表时自增、步长为 1。

（如果使用分库分表集群部署，则id类型为verchar，非自增，业务中使用分布式id生成器）

gmt_create, gmt_modified 的类型均为 datetime 类型，前者现在时表示主动创建，后者过去分词表示被 动更新。

6、单表行数超过 500 万行或者单表容量超过 2GB，才推荐进行分库分表。 说明：如果预计三年后的数据量根本达不到这个级别，请不要在创建表时就分库分表。

7、表达是与否概念的字段，必须使用 is_xxx 的方式命名，数据类型是 unsigned tinyint （1 表示是，0 表示否）。

说明：任何字段如果为非负数，必须是 unsigned。

注意：POJO 类中的任何布尔类型的变量，都不要加 is 前缀。数据库表示是与否的值，使用 tinyint 类型，坚持 is_xxx 的 命名方式是为了明确其取值含义与取值范围。

正例：表达逻辑删除的字段名 is_deleted，1 表示删除，0 表示未删除。

8、小数类型为 decimal，禁止使用 float 和 double。 说明：float 和 double 在存储的时候，存在精度损失的问题，很可能在值的比较时，得到不 正确的结果。如果存储的数据范围超过 decimal 的范围，建议将数据拆成整数和小数分开存储。

9、如果存储的字符串长度几乎相等，使用 char 定长字符串类型。

10、varchar 是可变长字符串，不预先分配存储空间，长度不要超过 5000，如果存储长度大于此值，定义字段类型为 text，独立出来一张表，用主键来对应，避免影响其它字段索 引效率。

11、唯一索引名为 uk_字段名；普通索引名则为 idx_字段名。

说明：uk_ 即 unique key；idx_ 即 index 的简称

12、不得使用外键与级联，一切外键概念必须在应用层解决。外键与级联更新适用于单机低并发，不适合分布式、高并发集群；级联更新是强阻塞，存在数据库更新风暴的风险；外键影响数据库的插入速度。

2.2 工程目录结构

模块说明

**onlineclass_parent：**硅谷课堂根目录（父工程），管理多个子模块：

common：公共模块父节点

​ service_utils：service服务的base包，包含service服务的公共配置类，所有service模块依赖于它，工具类模块，所有模块都可以依赖于它

model：实体类相关模块

service：api接口服务父节点

​ service_activity：优惠券api接口服务

​ service_live：直播课程api接口服务

​ service_order：订单api接口服务

​ service_user：用户api接口服务

​ service_vod：点播课程 api接口服务

​ service_wechat：公众号api接口服务

service-client：feign服务调用父节点

​ service-activity-client：优惠券api接口

​ service-course-client：课程api接口

​ service-user-client：用户api接口

service-gateway：服务网关

2.3 创建父工程

2.3.1 创建父工程onlineclass_parent

在idea开发工具中，使用 Spring Initializr 快速初始化一个 Spring Boot 模块

2.3.2 删除src目录

2.3.3 引入依赖

修改SpringBoot版本为 ：2.2.1.RELEASE

删除，

添加如下依赖

<properties>
    <skipTests>true</skipTests>
    <java.version>1.8</java.version>
    <cloud.version>Hoxton.RELEASE</cloud.version>
    <alibaba.version>2.2.0.RELEASE</alibaba.version>
    <mybatis-plus.version>3.4.1</mybatis-plus.version>
    <mysql.version>5.1.46</mysql.version>
    <swagger.version>2.9.2</swagger.version>
    <jwt.version>0.7.0</jwt.version>
    <fastjson.version>1.2.29</fastjson.version>
    <httpclient.version>4.5.1</httpclient.version>
    <easyexcel.version>2.2.0-beta2</easyexcel.version>
    <aliyun.version>4.5.14</aliyun.version>
    <jodatime.version>2.10.1</jodatime.version>
    <jwt.version>0.7.0</jwt.version>
    <xxl-job.version>2.3.0</xxl-job.version>
    <aliyun.oss.version>3.9.0</aliyun.oss.version>
</properties>

<!--配置dependencyManagement锁定依赖的版本-->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>${alibaba.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <!--mybatis-plus 持久层-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>

        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>knife4j-spring-boot-starter</artifactId>
            <version>2.0.8</version>
        </dependency>

        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>${jwt.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>${httpclient.version}</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>easyexcel</artifactId>
            <version>${easyexcel.version}</version>
        </dependency>
        <dependency>
            <groupId>com.aliyun</groupId>
            <artifactId>aliyun-java-sdk-core</artifactId>
            <version>${aliyun.version}</version>
        </dependency>

        <!--aliyunOSS-->
        <dependency>
            <groupId>com.aliyun.oss</groupId>
            <artifactId>aliyun-sdk-oss</artifactId>
            <version>${aliyun.oss.version}</version>
        </dependency>

        <!--日期时间工具-->
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>${jodatime.version}</version>
        </dependency>

        <dependency>
            <groupId>com.xuxueli</groupId>
            <artifactId>xxl-job-core</artifactId>
            <version>${xxl-job.version}</version>
        </dependency>
        <!--swagger-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>${swagger.version}</version>
        </dependency>
        <!--swagger ui-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>${swagger.version}</version>
        </dependency>
    </dependencies>
</dependencyManagement>
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

2.4 创建model模块

2.4.1 创建子模块model

2.4.2 引入依赖

在子模块中引入依赖：

<dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <scope>provided </scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>easyexcel</artifactId>
            <scope>provided </scope>
        </dependency>
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>knife4j-spring-boot-starter</artifactId>
            <!--在引用时请在maven中央仓库搜索2.X最新版本号-->
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
            <scope>provided </scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <scope>provided </scope>
        </dependency>

        <!--创建索引库的-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
            <scope>provided </scope>
        </dependency>
    </dependencies>
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

检查父工程的pom文件，已将子模块添加至父工程：

2.4.3 复制model代码

2.5 创建service模块

2.5.1 创建子模块service

2.5.2 service模块引入依赖

引入service依赖

注意：将服务注册 服务调用 流量控制的依赖注释掉。

<dependencies>
    <!--数据载体-->
    <dependency>
        <groupId>com.gerrard</groupId>
        <artifactId>model</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>

    <!--web 需要启动项目-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!--mybatis-plus-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
    </dependency>

    <!--mysql-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

    <!-- 服务注册 先注掉 -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>

    <!-- 服务调用feign 先注掉 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>

    <!-- 流量控制  先注掉-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    </dependency>

    <!--开发者工具-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>
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

2.5.3 创建service_vod模块

删掉service子模块的src目录 添加service_vod子子模块。

检查service模块的pom依赖，已将service_vod子子模块添加至service子模块。

3.后台管理系统-讲师管理接口

3.1 讲师管理模块需求

添加课程时候，需要选择所属讲师，所以要对讲师进行管理，就是基于讲师的CRUD操作。

3.2 讲师管理模块配置

3.2.1 生成模块代码

（1）引入代码生成器依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.3.1</version>
</dependency>

<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.0</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11

（2）复制生成代码工具类

把资料中的代码生成器类添加至service_vod test包中（自己创建com.gerrard文件夹）

修改代码中路径、数据库、包和表，复制到test目录下。

CodeGet.java:

package com.gerrard;


import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

public class CodeGet {

    public static void main(String[] args) {


        //1.改生成路径
        //2.改生成包名
        //3.改数据库和数据表名称


        // 1、创建代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // 2、全局配置
        // 全局配置
        GlobalConfig gc = new GlobalConfig();
    //    String projectPath = System.getProperty("user.dir");
        //gc.setOutputDir(projectPath + "/src/main/java");
//        gc.setOutputDir("C:\\Users\\zewan\\Desktop\\guli\\demo_parent\\service\\service_hosp"+"/src/main/java");
//        gc.setOutputDir("D:\\gerrardProjects\\onlineclass_parent\\service\\service_vod"+"/src/main/java");
//        gc.setOutputDir("D:\\gerrardProjects\\onlineclass_parent\\service\\service_order"+"/src/main/java");
//        gc.setOutputDir("D:\\gerrardProjects\\onlineclass_parent\\service\\service_activity"+"/src/main/java");
//        gc.setOutputDir("D:\\gerrardProjects\\onlineclass_parent\\service\\service_user"+"/src/main/java");
//        gc.setOutputDir("D:\\gerrardProjects\\onlineclass_parent\\service\\service_wechat"+"/src/main/java");
        gc.setOutputDir("D:\\gerrardProjects\\onlineclass_parent\\service\\service_live"+"/src/main/java");
        gc.setServiceName("%sService");	//去掉Service接口的首字母I
        gc.setAuthor("lyc");
        gc.setOpen(false);
        mpg.setGlobalConfig(gc);

        // 3、数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
//        dsc.setUrl("jdbc:mysql://localhost:3307/glkt_vod");
//        dsc.setUrl("jdbc:mysql://localhost:3307/glkt_order");
//        dsc.setUrl("jdbc:mysql://localhost:3307/glkt_activity");
//        dsc.setUrl("jdbc:mysql://localhost:3307/glkt_user");
//        dsc.setUrl("jdbc:mysql://localhost:3307/glkt_wechat");
        dsc.setUrl("jdbc:mysql://localhost:3307/glkt_live");
        dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("root");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);

        // 4、包配置
        PackageConfig pc = new PackageConfig();
        pc.setParent("com.gerrard.olclass");
      //  pc.setModuleName("vod"); //模块名  com.gerrard.olclass.vod.【controller/entity】
//        pc.setModuleName("service_order"); //模块名  com.gerrard.olclass.vod.【controller/entity】
//        pc.setModuleName("activity");
//        pc.setModuleName("user");
//        pc.setModuleName("wechat");
        pc.setModuleName("live");
        pc.setController("controller");
        pc.setEntity("entity");
        pc.setService("service");
        pc.setMapper("mapper");
        mpg.setPackageInfo(pc);

        // 5、策略配置
        StrategyConfig strategy = new StrategyConfig();

     //   strategy.setInclude("course","course_description","chapter","video");   //表名

//        strategy.setInclude("order_detail","order_info");   //表名
//        strategy.setInclude("coupon_info","coupon_use");   //表名
//        strategy.setInclude("user_info");   //表名
//        strategy.setInclude("menu");   //表名
        strategy.setInclude("live_course","live_course_account","live_course_config","live_course_description","live_course_goods","live_visitor");   //表名
        strategy.setNaming(NamingStrategy.underline_to_camel);//数据库表映射到实体的命名策略

        strategy.setColumnNaming(NamingStrategy.underline_to_camel);//数据库表字段映射到实体的命名策略
        strategy.setEntityLombokModel(true); // lombok 模型 @Accessors(chain = true) setter链式操作

        strategy.setRestControllerStyle(true); //restful api风格控制器
        strategy.setControllerMappingHyphenStyle(true); //url中驼峰转连字符

        mpg.setStrategy(strategy);

        // 6、执行
        mpg.execute();
    }
}
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

（3）实体类统一替换为model模块的实体类，删掉自动生成的实体类(entity包)

生成后结果：

model模块的实体类：

Teacher.java:

package com.gerrard.olclass.model.vod;

import com.gerrard.olclass.model.base.BaseEntity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.Date;

@Data
@ApiModel(description = "Teacher")
@TableName("teacher")
public class Teacher extends BaseEntity {

	private static final long serialVersionUID = 1L;

	@ApiModelProperty(value = "讲师姓名")
	@TableField("name")
	private String name;

	@ApiModelProperty(value = "讲师简介")
	@TableField("intro")
	private String intro;

	@ApiModelProperty(value = "讲师资历,一句话说明讲师")
	@TableField("career")
	private String career;

	@ApiModelProperty(value = "头衔 1高级讲师 2首席讲师")
	@TableField("level")
	private Integer level;

	@ApiModelProperty(value = "讲师头像")
	@TableField("avatar")
	private String avatar;

	@ApiModelProperty(value = "排序")
	@TableField("sort")
	private Integer sort;

	@ApiModelProperty(value = "入驻时间")
	@JsonFormat(pattern = "yyyy-MM-dd")
	@TableField("join_date")
	private Date joinDate;

}
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

3.2.2 创建配置文件和启动类

配置文件

# 服务端口
server.port=8301
# 服务名
spring.application.name=service-vod

# 环境设置：dev、test、prod
spring.profiles.active=dev

# mysql数据库连接
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3307/glkt_vod?characterEncoding=utf-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=root

#返回json的全局时间格式
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=GMT+8

#mybatis日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

启动类

ServiceVodApplication.java:

package com.gerrard.olclass.vod;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@ComponentScan("com.gerrard")
@EnableDiscoveryClient
public class ServiceVodApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceVodApplication.class, args);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.3 查询所有讲师列表接口

3.3.1 编写controller

TeacherController.java:

package com.gerrard.olclass.vod.controller;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.gerrard.olclass.exception.GgktException;
import com.gerrard.olclass.model.vod.Teacher;
import com.gerrard.olclass.result.Result;
import com.gerrard.olclass.vo.vod.TeacherQueryVo;
import com.gerrard.olclass.vod.service.TeacherService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.util.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;


import java.util.List;

/**
 * <p>
 * 讲师 前端控制器
 * </p>
 *
 * @author lyc
 * @since 2022-08-01
 */
@Api(tags = "讲师管理接口")
@RestController
@RequestMapping("/admin/vod/teacher")
//@CrossOrigin
public class TeacherController {

    @Autowired
    private TeacherService teacherService;

    // http://localhost:8301/admin/vod/teacher/findAll
    //1.查询所有讲师
    @ApiOperation("查询所有讲师")
    @GetMapping("findAll")  //一定要注意格式格式，这里之前为List<Teacher> 与前端解析的格式不匹配！！！！
    public Result findAllTeacher(){
        //调用service方法
//        try {
//            int a = 10/0;
//        }catch(Exception e) {
//            throw new GgktException(20001,"出现自定义异常");
//        }
        List<Teacher> list=teacherService.list();
        return Result.ok(list);
    }

}


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

3.3.2 编写配置类

VodConfig.java：

package com.gerrard.olclass.vod.config;


import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@MapperScan("com.gerrard.olclass.vod.mapper")
public class VodConfig {

    /**
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3.3.3 运行启动类

访问http://localhost:8301/admin/vod/teacher/findAll

得到json数据【弄了网关后还可以通过http://localhost:8333/admin/vod/teacher/findAll访问】

3.4 逻辑删除讲师接口

3.4.1 编写controller

TeacherController添加删除方法

 //remove/1
    //2 逻辑删除讲师
    @ApiOperation("逻辑删除讲师")
    @DeleteMapping("remove/{id}")
    public Result removeTeacher(@ApiParam(name="id",value = "ID",required = true)
                                @PathVariable long id){
        boolean isSuccess=teacherService.removeById(id);
        if(isSuccess){
            return Result.ok(null);
        }else{
            return Result.fail(null);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

因为删除讲师接口是delete提交方式，使用浏览器无法直接访问测试，可以通过工具测试，比如Postman，我们这里通过整合Swagger2进行接口测试。

3.5 配置Swagger2生成API接口文档

3.5.1 概述

前后端分离开发模式中，api文档是最好的沟通方式。Swagger 是一个规范和完整的框架，用于生成、描述、调用和可视化 RESTful 风格的 Web 服务。及时性 (接口变更后，能够及时准确地通知相关前后端开发人员)规范性 (并且保证接口的规范性，如接口的地址，请求方式，参数及响应格式和错误信息)一致性 (接口信息一致，不会出现因开发人员拿到的文档版本不一致，而出现分歧)可测性 (直接在接口文档上进行测试，以方便理解业务)

3.5.2 配置Swagger2

（1）在onlineclass_parent下创建子模块common

（2）在common模块引入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <scope>provided </scope>
    </dependency>

    <!--mybatis-plus-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <scope>provided </scope>
    </dependency>

    <!--lombok用来简化实体类：需要安装lombok插件-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>

    <!--swagger-->
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
    </dependency>
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger-ui</artifactId>
    </dependency>

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
    </dependency>
</dependencies>
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

（3）在common下创建子模块service_utils

（4）在service_utils创建swagger2配置类

package com.gerrard.olclass.swagger;

import com.google.common.base.Predicates;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class Swagger2Config {
    @Bean
    public Docket webApiConfig(){
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("ggkt")
                .apiInfo(webApiInfo())
                .select()
                //只显示api路径下的页面
                //.paths(Predicates.and(PathSelectors.regex("/api/.*")))
                .build();
    }

    private ApiInfo webApiInfo(){
        return new ApiInfoBuilder()
                .title("网站-API文档")
                .description("本文档描述了网站微服务接口定义")
                .version("1.0")
                .contact(new Contact("atguigu", "http://atguigu.com", "atguigu.com"))
                .build();
    }
}

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

（5）在service模块引入service_utils依赖

<dependency>
    <groupId>com.gerrard</groupId>
    <artifactId>service_utils</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>
1
2
3
4
5

（6）在service_vod启动类上添加注解，进行测试

@SpringBootApplication
@ComponentScan("com.gerrard")
public class ServiceVodApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceVodApplication.class, args);
    }
}
1
2
3
4
5
6
7

3.5.3 定义接口说明和参数说明

定义在类上：@Api

定义在方法上：@ApiOperation

定义在参数上：@ApiParam

3.5.4 swagger2测试

（1）浏览器输入固定地址 http://localhost:8301/swagger-ui.html

（2）测试接口

（3）执行接口

没有创建返回结果类的ResponseBody：

3.6 定义统一返回结果对象

项目中我们会将响应封装成json返回，一般我们会将所有接口的数据格式统一， 使前端(iOS Android, Web)对数据的操作更一致、轻松。

一般情况下，统一返回数据格式没有固定的格式，只要能描述清楚返回的数据状态以及要返回的具体数据就可以。但是一般会包含状态码、返回消息、数据这几部分内容

例如，我们的系统要求返回的基本数据格式如下：

列表：

{
  "code": 200,
  "message": "成功",
  "data": [
    {
      "id": 2,
      "name": "欧阳老师",
      "intro": "高级讲师"
    }
  ],
  "ok": true
}
1
2
3
4
5
6
7
8
9
10
11
12

分页：

{
  "code": 200,
  "message": "成功",
  "data": {
    "records": [
      {
        "id": 2,
        "name": "欧阳老师",
        "intro": "高级讲师"
      },
      {
        "id": 4,
        "name": "上官老师",
        "intro": "高级讲师"
      },
      {
        "id": 5,
        "name": "东方老师",
        "intro": "高级老师"
      }
    ],
    "total": 10,
    "size": 3,
    "current": 1,
    "orders": [],
    "hitCount": false,
    "searchCount": true,
    "pages": 2
  },
  "ok": true
}
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

没有返回数据：

{
  "code": 200,
  "message": "成功",
  "data": null,
  "ok": true
}
1
2
3
4
5
6

失败：

{
  "code": 201,
  "message": "失败",
  "data": null,
  "ok": false
}
1
2
3
4
5
6

3.6.1 创建结果类

在service_utils模块创建结果类

package com.gerrard.olclass.result;

import lombok.Data;

@Data
public class Result<T> {

    private Integer code;  //状态码
    private String message; //返回状态信息（成功 失败）

    private T data;   //返回数据

    public Result(){}

    //成功的方法，有data数据
    public static<T> Result<T> ok(T data){
        Result<T> result=new Result<>();
        if(data!=null){
            result.setData(data);
        }
        result.setCode(20000);
        result.setMessage("成功");
        return result;
    }

    //失败的方法，有data数据
    public static<T> Result<T> fail(T data){
        Result<T> result=new Result<>();
        if(data!=null){
            result.setData(data);
        }
        result.setCode(20001);
        result.setMessage("失败");
        return result;
    }

    public Result<T> message(String msg){
        this.setMessage(msg);
        return this;
    }

    public Result<T> code(Integer code){
        this.setCode(code);
        return this;
    }

}
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

3.6.2 修改controller返回结果

测试一下：

3.7 条件分页查询讲师列表接口

3.7.1 创建配置类

package com.gerrard.olclass.vod.config;


import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@MapperScan("com.gerrard.olclass.vod.mapper")
public class VodConfig {

    /**
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

疑问：是否可以将分页插件像swagger一样放在service_utils模块中？

3.7.2 创建查询条件对象

package com.gerrard.olclass.vo.vod;

import lombok.Data;
import io.swagger.annotations.ApiModelProperty;

@Data
public class TeacherQueryVo {
	
	@ApiModelProperty(value = "讲师姓名")
	private String name;

	@ApiModelProperty(value = "头衔 1高级讲师 2首席讲师")
	private Integer level;

	@ApiModelProperty(value = "入驻时间")
	private String joinDateBegin;

	@ApiModelProperty(value = "入驻时间")
	private String joinDateEnd;


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.7.3 编写controller

TeacherController.java:

 //3 条件查询分页
    @ApiOperation("条件查询分页")
    @PostMapping("findQueryPage/{current}/{limit}")
    public Result findPage(@PathVariable long current,
                           @PathVariable long limit,
                           @RequestBody(required = false)TeacherQueryVo teacherQueryVo){
        //创建page对象
        Page<Teacher> pageParam=new Page<>(current,limit);
        //判断teacherQueryVo对象是否为空
        if(teacherQueryVo==null){  //查询全部
            IPage<Teacher> pageModel =
                    teacherService.page(pageParam,null);
            return Result.ok(pageModel);
        }else{
         //获取条件值
            String name=teacherQueryVo.getName();
            Integer level=teacherQueryVo.getLevel();
            String joinDateBegin=teacherQueryVo.getJoinDateBegin();
            String joinDateEnd=teacherQueryVo.getJoinDateEnd();

            //进行非空判断，条件封装
            QueryWrapper<Teacher> wrapper=new QueryWrapper<>();
            if(!StringUtils.isEmpty(name)){
                wrapper.like("name",name);
            }
            if(!StringUtils.isEmpty(level)) {
                wrapper.eq("level",level);
            }
            if(!StringUtils.isEmpty(joinDateBegin)){
                wrapper.ge("join_date",joinDateBegin);
            }
            if(!StringUtils.isEmpty(joinDateEnd)){
                wrapper.le("join_date",joinDateEnd);
            }

            //调用方法分页查询
            IPage<Teacher> pageModel=teacherService.page(pageParam,wrapper);
            //返回
            return Result.ok(pageModel);
        }
    }
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

3.8 添加讲师接口

3.8.1 编写controller

//4 添加讲师
    @ApiOperation("添加讲师")
    @PostMapping("saveTeacher")
    public Result saveTeacher(@RequestBody Teacher teacher){
        boolean isSuccess=teacherService.save(teacher);
        if(isSuccess){
            return Result.ok(null);
        }else{
            return Result.fail(null);
        }
    }
1
2
3
4
5
6
7
8
9
10
11

3.9 修改讲师接口

3.9.1 编写id查询方法

//5 修改-根据id查询
    @ApiOperation("根据id查询")
    @GetMapping("getTeacher/{id}")
    public Result getTeacher(@PathVariable Long id){
        Teacher teacher=teacherService.getById(id);
        return Result.ok(teacher);
    }
1
2
3
4
5
6
7

3.9.2 编写修改方法

//6 修改-最终实现    ?????
    //{...}
    @ApiOperation("修改最终实现")
    @PostMapping("updateTeacher")
    public Result updateTeacher(@RequestBody Teacher teacher){
        boolean isSuccess=teacherService.updateById(teacher);
        if(isSuccess) {
            return Result.ok(null);
        } else {
            return Result.fail(null);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12

3.10 批量删除讲师接口

3.10.1 编写controller

//7 批量删除讲师
    //json数组 [1,2,3]
    @ApiOperation("批量删除讲师")
    @DeleteMapping("removeBatch")
    public Result removeBatch(@RequestBody List<Long> idList){
        boolean isSuccess=teacherService.removeByIds(idList);
        if(isSuccess) {
            return Result.ok(null);
        } else {
            return Result.fail(null);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12

4.统一异常处理

4.1 制造异常

除以0

int a = 10/0;
1

我们想让异常结果也显示为统一的返回结果对象，并且统一处理系统的异常信息，那么需要统一异常处理。

4.2 全局异常处理

4.2.1 创建统一异常处理器

在service_utils中创建统一异常处理类GlobalExceptionHandler.java：

package com.gerrard.olclass.exception;


import com.gerrard.olclass.result.Result;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

@ControllerAdvice  //aop
public class GlobalExceptionHandler {

    //全局异常处理
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public Result error(Exception e){
        System.out.println("全局......");
        e.printStackTrace();
        return Result.fail(null).message("执行全局异常处理");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

4.2.2 测试

TeacherController中制造一下异常：

 // http://localhost:8301/admin/vod/teacher/findAll
    //1.查询所有讲师
    @ApiOperation("查询所有讲师")
    @GetMapping("findAll")  //一定要注意格式格式，这里之前为List<Teacher> 与前端解析的格式不匹配！！！！
    public Result findAllTeacher(){
        //调用service方法
        int a = 10/0;
        List<Teacher> list=teacherService.list();
        return Result.ok(list);
    }

1
2
3
4
5
6
7
8
9
10
11

测试结果：

4.3 处理特定异常

4.3.1 添加异常处理方法

GlobalExceptionHandler.java中添加特定异常处理

package com.gerrard.olclass.exception;


import com.gerrard.olclass.result.Result;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

@ControllerAdvice  //aop
public class GlobalExceptionHandler {

    //全局异常处理
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public Result error(Exception e){
        System.out.println("全局......");
        e.printStackTrace();
        return Result.fail(null).message("执行全局异常处理");
    }

    //特定异常处理ArithmeticException
    @ExceptionHandler(ArithmeticException.class)
    @ResponseBody
    public Result error(ArithmeticException e){
        System.out.println("特定......");
        e.printStackTrace();
        return Result.fail(null).message("执行ArithmeticException异常处理");
    }
}

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

4.3.2 测试

依旧是刚才的TeacherController中抛出的异常：

 // http://localhost:8301/admin/vod/teacher/findAll
    //1.查询所有讲师
    @ApiOperation("查询所有讲师")
    @GetMapping("findAll")  //一定要注意格式格式，这里之前为List<Teacher> 与前端解析的格式不匹配！！！！
    public Result findAllTeacher(){
        //调用service方法
        int a = 10/0;
        List<Teacher> list=teacherService.list();
        return Result.ok(list);
    }

1
2
3
4
5
6
7
8
9
10
11

4.4 处理自定义异常

4.4.1 创建自定义异常类

GgktException.java:

package com.gerrard.olclass.exception;

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

@Data
@AllArgsConstructor
@NoArgsConstructor
public class GgktException extends RuntimeException {
    private Integer code;
    private String msg;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

4.4.2 业务中需要位置抛出

try {
    int a = 10/0;
}catch(Exception e) {
    throw new GgktException(20001,"出现自定义异常");
}
1
2
3
4
5

4.4.3 添加异常处理方法

GlobalExceptionHandler.java中添加自定义异常处理

package com.gerrard.olclass.exception;


import com.gerrard.olclass.result.Result;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

@ControllerAdvice  //aop
public class GlobalExceptionHandler {

    //全局异常处理
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public Result error(Exception e){
        System.out.println("全局......");
        e.printStackTrace();
        return Result.fail(null).message("执行全局异常处理");
    }
    //特定异常处理ArithmeticException
    @ExceptionHandler(ArithmeticException.class)
    @ResponseBody
    public Result error(ArithmeticException e){
        System.out.println("特定......");
        e.printStackTrace();
        return Result.fail(null).message("执行ArithmeticException异常处理");
    }
    //自定义异常处理
    @ExceptionHandler(GgktException.class)
    @ResponseBody
    public Result error(GgktException e){
        e.printStackTrace();
        return Result.fail(null).code(e.getCode()).message(e.getMsg());
    }
}

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

4.4.4 测试

TeacherController中制造一下自定义异常：

  // http://localhost:8301/admin/vod/teacher/findAll
    //1.查询所有讲师
    @ApiOperation("查询所有讲师")
    @GetMapping("findAll")  //一定要注意格式格式，这里之前为List<Teacher> 与前端解析的格式不匹配！！！！
    public Result findAllTeacher(){
//        调用service方法
        try {
            int a = 10/0;
        }catch(Exception e) {
            throw new GgktException(20001,"出现自定义异常");
        }
        
        List<Teacher> list=teacherService.list();
        return Result.ok(list);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

测试结果：