01-数据库设计

一、数据库设计

二、数据库设计规约

以下规约只针对本模块，更全面的文档参考《阿里巴巴Java开发手册》：五、MySQL数据库

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

02-搭建项目工程（父工程）

一、工程结构介绍

1、工程结构

2、模块说明

guli-parent：在线教学根目录（父工程），管理四个子模块：

canal-client：canal数据库表同步模块（统计同步数据）

common：公共模块父节点

common-util：工具类模块，所有模块都可以依赖于它

service-base：service服务的base包，包含service服务的公共配置类，所有service模块依赖于它

spring-security：认证与授权模块，需要认证授权的service服务依赖于它

infrastructure：基础服务模块父节点

api-gateway：api网关服务

service：api接口服务父节点

service-acl：用户权限管理api接口服务（用户管理、角色管理和权限管理等）

service-cms：cms api接口服务

service-edu：教学相关api接口服务

service-msm：短信api接口服务

service-order：订单相关api接口服务

service-oss：阿里云oss api接口服务

service-statistics：统计报表api接口服务

service-ucenter：会员api接口服务

service-vod：视频点播api接口服务

二、创建父工程

1、创建sprigboot工程guli-parent

在idea开发工具中，使用 Spring Initializr 快速初始化一个 Spring Boot 模块，版本使用：2.2.1.RELEASE

2、配置 pom.xml

<artifactId> 节点后面添加 pom类型

3、在pom.xml中添加依赖的版本

删除pom.xml中的<dependencies>内容

<dependencies>

.......................

</dependencies>

添加 <properties>确定依赖的版本

配置<dependencyManagement>锁定依赖的版本

03-搭建项目工程（service模块）

2 讲师管理接口开发

01-讲师管理模块配置和生成代码

一、讲师管理模块配置

1、在service下面service-edu模块中创建配置文件

resources目录下创建文件 application.properties

# 服务端口

server.port=8001

# 服务名

spring.application.name=service-edu

# 环境设置：dev、test、prod

spring.profiles.active=dev

spring.datasource.driver-class-name=com.mysql.jdbc.Driver

spring.datasource.url=jdbc:mysql://localhost:3306/guli?serverTimezone=GMT%2B8&characterEncoding=utf-8&useSSL=false

spring.datasource.username=root

spring.datasource.password=123456

#mybatis日志

mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

或者在resources目录下创建文件 application.yml

2、创建MP代码生成器

在test/java目录下创建包com.atguigu.eduservice，创建代码生成器：CodeGenerator.java

package com.atguigu.demo;

import com.baomidou.mybatisplus.annotation.DbType;

import com.baomidou.mybatisplus.annotation.IdType;

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.DateType;

import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

import org.junit.Test;

/**

* @author

* @since 2018/12/13

*/

public class CodeGenerator {

@Test

public void run() {

// 1、创建代码生成器

AutoGenerator mpg =new AutoGenerator();

// 2、全局配置

GlobalConfig gc =new GlobalConfig();

String projectPath =System.getProperty("user.dir");

gc.setOutputDir("E:\\blog\\guli_parent\\service\\service_edu" +"/src/main/java");

gc.setAuthor("testjava");

gc.setOpen(false);//生成后是否打开资源管理器

gc.setFileOverride(false);//重新生成时文件是否覆盖

//UserServie

gc.setServiceName("%sService");//去掉Service接口的首字母I

gc.setIdType(IdType.ID_WORKER_STR);//主键策略

gc.setDateType(DateType.ONLY_DATE);//定义生成的实体类中日期类型

gc.setSwagger2(true);//开启Swagger2模式

mpg.setGlobalConfig(gc);

// 3、数据源配置

DataSourceConfig dsc =new DataSourceConfig();

dsc.setUrl("jdbc:mysql://localhost:3306/guli?serverTimezone=GMT%2B8&characterEncoding=utf-8&useSSL=false");

dsc.setDriverName("com.mysql.jdbc.Driver");

dsc.setUsername("root");

dsc.setPassword("123456");

dsc.setDbType(DbType.MYSQL);

mpg.setDataSource(dsc);

// 4、包配置

PackageConfig pc =new PackageConfig();

pc.setModuleName("eduservice");//模块名

//包com.atguigu.eduservice

pc.setParent("com.atguigu");

//包com.atguigu.eduservice.controller

pc.setController("controller");

pc.setEntity("entity");

pc.setService("service");

pc.setMapper("mapper");

mpg.setPackageInfo(pc);

// 5、策略配置

StrategyConfig strategy =new StrategyConfig();

strategy.setInclude("edu_teacher");

strategy.setNaming(NamingStrategy.underline_to_camel);//数据库表映射到实体的命名策略

strategy.setTablePrefix(pc.getModuleName() +"_");//生成实体时去掉表前缀

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

}

}

二、编写后台管理api接口

1、编写controller代码

public class EduTeacherController {

    //把service注入

@Autowired

private EduTeacherService teacherService;

    //1 查询讲师表所有数据

//rest风格

//@GetMapping是一个组合注解，是@RequestMapping(method = RequestMethod.GET)的缩写

@GetMapping("findAll")

    public List<EduTeacher> findAllTeacher(){

        //调用service的方法实现查询所有的操作

List<EduTeacher> list =teacherService.list(null);

        return list;

    }

}

2、创建SpringBoot启动类

创建启动类 EduApplication.java，注意启动类的创建位置

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class EduApplication {

    public static void main(String[] args) {

        SpringApplication.run(EduApplication.class, args);

    }

}

3、创建SpringBoot配置类

在edu包下创建config包，创建MyBatisPlusConfig.java

@Configuration

@MapperScan("com.atguigu.eduservice.mapper")

public class EduConfig {

}

4、配置SQL执行性能分析插件

/**

* SQL 执行性能分析插件

* 开发环境使用，线上不推荐。 maxTime 指的是 sql 最大执行时长

*

*三种环境

* dev:开发环境

* test:测试环境

* prod:生产环境

*/

@Bean

@Profile({"dev","test"})// 设置 dev test 环境开启

public PerformanceInterceptor performanceInterceptor() {

PerformanceInterceptor performanceInterceptor =new PerformanceInterceptor();

performanceInterceptor.setMaxTime(1000);//ms，超过此处设置的ms则sql不执行

performanceInterceptor.setFormat(true);

return performanceInterceptor;

}

5、运行启动类

访问http://localhost:8001/eduservice/teacher

得到json数据

成功：

6、统一返回的json时间格式

默认情况下json时间格式带有时区，并且是世界标准时间，和我们的时间差了八个小时

在application.properties中设置

#返回json的全局时间格式

spring.jackson.date-format=yyyy-MM-dd HH:mm:ss

spring.jackson.time-zone=GMT+8

三、讲师逻辑删除功能

1、配置逻辑删除插件

MyBatisPlusConfig中配置

/**

* 逻辑删除插件

*/

@Bean

public ISqlInjector sqlInjector() {

return new LogicSqlInjector();

}

逻辑删除注解：

@ApiModelProperty(value ="逻辑删除 1（true）已删除， 0（false）未删除")

@TableLogic

private Boolean isDeleted;

2、EduTeacherController添加删除方法

//2 逻辑删除讲师的方法

@DeleteMapping("{id}")

public boolean removeTeacher(@PathVariable String id){

return teacherService.removeById(id);

}

02-配置Swagger2生成API接口文档

一、Swagger2介绍

前后端分离开发模式中，api文档是最好的沟通方式。

Swagger 是一个规范和完整的框架，用于生成、描述、调用和可视化 RESTful 风格的 Web 服务。

1、及时性 (接口变更后，能够及时准确地通知相关前后端开发人员)

2、规范性 (并且保证接口的规范性，如接口的地址，请求方式，参数及响应格式和错误信息)

3、一致性 (接口信息一致，不会出现因开发人员拿到的文档版本不一致，而出现分歧)

4、可测性 (直接在接口文档上进行测试，以方便理解业务)

二、配置Swagger2

1、创建common模块

在guli-parent下创建模块common

配置：

groupId：com.atguigu

artifactId：common

2、在common中引入相关依赖

<dependencies>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

<scope>provided </scope>

</dependency>



<dependency>

<groupId>com.baomidou</groupId>

<artifactId>mybatis-plus-boot-starter</artifactId>

<scope>provided </scope>

</dependency>



<dependency>

<groupId>org.projectlombok</groupId>

<artifactId>lombok</artifactId>

<scope>provided </scope>

</dependency>



<dependency>

<groupId>io.springfox</groupId>

<artifactId>springfox-swagger2</artifactId>

<scope>provided </scope>

</dependency>

<dependency>

<groupId>io.springfox</groupId>

<artifactId>springfox-swagger-ui</artifactId>

<scope>provided </scope>

</dependency>



<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-data-redis</artifactId>

</dependency>



</dependencies>

3、在common下面创建子模块service-base

在模块service-base中，创建swagger的配置类

创建包com.atguigu.servicebase，创建类SwaggerConfig

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 //swagger注解

public class SwaggerConfig {

@Bean

public Docket webApiConfig(){

return new Docket(DocumentationType.SWAGGER_2)

.groupName("webApi")

.apiInfo(webApiInfo())

.select()

.paths(Predicates.not(PathSelectors.regex("/admin/.*")))

.paths(Predicates.not(PathSelectors.regex("/error.*")))

.build();

}

private ApiInfo webApiInfo(){

return new ApiInfoBuilder()

.title("网站-课程中心API文档")

.description("本文档描述了课程中心微服务接口定义")

.version("1.0")

.contact(new Contact("java", "http://atguigu.com", "123456@qq.com"))

.build();

}

}

4、在模块service模块中引入service-base

<dependency>

<groupId>com.atguigu</groupId>

<artifactId>service_base</artifactId>

<version>0.0.1-SNAPSHOT</version>

</dependency>

5、在service-edu启动类上添加注解，进行测试

访问：http://localhost:8001/swagger-ui.html

测试删除：

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

定义在类上：@Api

定义在方法上：@ApiOperation

定义在参数上：@ApiParam

@Api(description="讲师管理")

@RestController

@RequestMapping("/eduservice/teacher")

public class EduTeacherController {

//访问地址http://localhost:8001/eduservice/teacher/findAll

//把service注入

@Autowired

private EduTeacherService teacherService;

//1 查询讲师表所有数据

//rest风格

//@GetMapping是一个组合注解，是@RequestMapping(method = RequestMethod.GET)的缩写

@ApiOperation(value = "所有讲师列表")

@GetMapping("findAll")

public List<EduTeacher> findAllTeacher(){

//调用service的方法实现查询所有的操作

List<EduTeacher> list = teacherService.list(null);

return list;

}

//2 逻辑删除讲师的方法

@ApiOperation(value = "根据ID删除讲师")

@DeleteMapping("{id}")

public boolean removeTeacher( @ApiParam(name = "id", value = "讲师ID", required = true) @PathVariable String id){

return teacherService.removeById(id);

}

}

6、API模型

可以添加一些自定义设置，例如：

定义样例数据

03-统一返回结果对象

一、统一返回数据格式

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

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

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

列表：

分页：

没有返回数据：

失败：

因此，我们定义统一结果

{

    "success":布尔,//响应是否成功

    "code":数字,//响应码

    "message":字符串,//返回消息

    "data":HashMap//返回数据，放在键值对中

}

二、创建统一结果返回类

1、在common模块下创建子模块common-utils

2、创建接口定义返回码

创建包com.atguigu.commonutils，创建接口 ResultCode.java

package com.atguigu.commonutils;

public interface ResultCode {

public static Integer SUCCESS = 20000; //成功

public static Integer ERROR = 20001; //失败

}

4、创建结果类

创建类 R.java

package com.atguigu.commonutils;

import io.swagger.annotations.ApiModelProperty;

import lombok.Data;

import java.util.HashMap;

import java.util.Map;

//统一返回结果的类

@Data

public class R {

@ApiModelProperty(value = "是否成功")

private Boolean success;

@ApiModelProperty(value = "返回码")

private Integer code;

@ApiModelProperty(value = "返回消息")

private String message;

@ApiModelProperty(value = "返回数据")

private Map<String, Object> data = new HashMap<String, Object>();

    //把构造方法私有

    private R(){};

    //成功静态方法

public static R ok(){

R r = new R();

r.setSuccess(true);

r.setCode(ResultCode.SUCCESS);

r.setMessage("成功");

return r;

}

    //失败静态方法

public static R error(){

R r = new R();

r.setSuccess(false);

r.setCode(ResultCode.ERROR);

r.setMessage("失败");

return r;

}

public R success(Boolean success){

this.setSuccess(success);

return this;

}

public R message(String message){

this.setMessage(message);

return this;

}

public R code(Integer code){

this.setCode(code);

return this;

}

public R data(String key, Object value){

this.data.put(key, value);

return this;

}

public R data(Map<String, Object> map){

this.setData(map);

return this;

}

}

return this;的目的是为了链式编程如R.ok().success().message().code()

三、统一返回结果使用

1、在service模块中添加依赖

<dependency>

<groupId>com.atguigu</groupId>

<artifactId>common_utils</artifactId>

<version>0.0.1-SNAPSHOT</version>

</dependency>

2、修改Controller中的返回结果

列表

//1 查询讲师表所有数据

//rest风格

//@GetMapping是一个组合注解，是@RequestMapping(method = RequestMethod.GET)的缩写

@ApiOperation(value = "所有讲师列表")

@GetMapping("findAll")

public R findAllTeacher(){

//调用service的方法实现查询所有的操作

List<EduTeacher> list = teacherService.list(null);

return R.ok().data("items",list);

}

删除

//2 逻辑删除讲师的方法

@ApiOperation(value = "根据ID删除讲师")

@DeleteMapping("{id}")

public R removeTeacher( @ApiParam(name = "id", value = "讲师ID", required = true) @PathVariable String id){

boolean flag = teacherService.removeById(id);

if (flag) {

return R.ok();

}else {

return R.error();

}

}

04-分页和条件查询接口开发

一、分页

1、MyBatisPlusConfig中配置分页插件

/**

* 分页插件

*/

@Bean

public PaginationInterceptor paginationInterceptor() {

return new PaginationInterceptor();

}

2、分页Controller方法

TeacherAdminController中添加分页方法

//3 分页查询讲师的方法

//current 当前页

//limit 每页记录数

@ApiOperation(value = "分页讲师列表")

@GetMapping("pageTeacher/{current}/{limit}")

public R pageListTeacher(@ApiParam(name = "current", value = "当前页码", required = true) @PathVariable long current,

@ApiParam(name = "limit", value = "每页记录数", required = true) @PathVariable long limit){

//创建page对象

Page<EduTeacher> pageTacher = new Page<>(current,limit);

//调用方法实现分页

//调用方法的时候，底层封装，把分页所有数据封装到pageTeacher对象里面

teacherService.page(pageTacher,null);

long total = pageTacher.getTotal(); //总记录数

List<EduTeacher> records = pageTacher.getRecords(); //数据list集合

// Map map = new HashMap();

// map.put("total",total);

// map.put("rows",records);

// return R.ok().data(map);

return R.ok().data("total",total).data("rows",records);

3、Swagger中测试

二、条件查询

根据讲师名称name，讲师头衔level、讲师入驻时间gmt_create（时间段）查询

1、创建查询对象

创建com.guli.edu.query包，创建TeacherQuery.java查询对象

import io.swagger.annotations.ApiModel;

import io.swagger.annotations.ApiModelProperty;

import lombok.Data;

@ApiModel(value = "Teacher查询对象", description = "讲师查询对象封装")

@Data

public class TeacherQuery {

@ApiModelProperty(value = "教师名称,模糊查询")

private String name;

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

private Integer level;

@ApiModelProperty(value = "查询开始时间",example = "2019-01-01 10:10:10")

private String begin;

@ApiModelProperty(value = "查询结束时间",example = "2019-12-01 10:10:10")

private String end;

}

2、service

接口

public interface EduTeacherService extends IService<EduTeacher> {

void pageQuery(Page<EduTeacher> pageParam,TeacherQuery teacherQuery);

}

实现

@Override

public void pageQuery(Page<EduTeacher> pageTacher, TeacherQuery teacherQuery) {

QueryWrapper<EduTeacher> wrapper = new QueryWrapper<>();

wrapper.orderByAsc("sort");

if (teacherQuery == null){

baseMapper.selectPage(pageTacher,wrapper);

return;

}

String name = teacherQuery.getName();

Integer level = teacherQuery.getLevel();

String begin = teacherQuery.getBegin();

String end = teacherQuery.getEnd();

if (!StringUtils.isEmpty(name)){

wrapper.like("name",name);

}

if (!StringUtils.isEmpty(level)){

wrapper.eq("level",level);

}

if (!StringUtils.isEmpty(begin)){

wrapper.ge("gmt_create",begin);

}

if (!StringUtils.isEmpty(end)){

wrapper.le("gmt_modified",end);

}

baseMapper.selectPage(pageTacher,wrapper);

}

3、controller

TeacherAdminController中修改 pageList方法：

增加参数TeacherQuery teacherQuery，非必选

//4 条件查询带分页的方法

@ApiOperation(value = "分页讲师列表")

@GetMapping("pageTeacherCondition/{current}/{limit}")

public R pageTeacherCondition(@ApiParam(name = "current", value = "当前页码", required = true) @PathVariable long current,

@ApiParam(name = "limit", value = "每页记录数", required = true) @PathVariable long limit,

TeacherQuery teacherQuery){

//创建page对象

Page<EduTeacher> pageTacher = new Page<>(current,limit);

//构建条件

QueryWrapper<EduTeacher> wrapper = new QueryWrapper<>();

//wrapper

//调用方法实现条件查询分页

teacherService.pageQuery(pageTacher,teacherQuery);

long total = pageTacher.getTotal(); //总记录数

List<EduTeacher> records = pageTacher.getRecords(); //数据list集合

// Map map = new HashMap();

// map.put("total",total);

// map.put("rows",records);

// return R.ok().data(map);

return R.ok().data("total",total).data("rows",records);

}

4、Swagger中测试

http://localhost:8001/swagger-ui.html#/

//4 条件查询带分页的方法

@ApiOperation(value = "分页讲师列表")

@PostMapping("pageTeacherCondition/{current}/{limit}")

public R pageTeacherCondition(@ApiParam(name = "current", value = "当前页码", required = true) @PathVariable long current,

@ApiParam(name = "limit", value = "每页记录数", required = true) @PathVariable long limit,

@RequestBody(required = false) TeacherQuery teacherQuery){

//创建page对象

Page<EduTeacher> pageTacher = new Page<>(current,limit);

//构建条件

QueryWrapper<EduTeacher> wrapper = new QueryWrapper<>();

//wrapper

//调用方法实现条件查询分页

teacherService.pageQuery(pageTacher,teacherQuery);

long total = pageTacher.getTotal(); //总记录数

List<EduTeacher> records = pageTacher.getRecords(); //数据list集合

// Map map = new HashMap();

// map.put("total",total);

// map.put("rows",records);

// return R.ok().data(map);

return R.ok().data("total",total).data("rows",records);

}

测试结果：

05-新增和修改讲师接口开发

一、自动填充封装

1、在service-base模块中添加

创建包handler，创建自动填充类 MyMetaObjectHandler

@Component

public class MyMetaObjectHandler implements MetaObjectHandler {

@Override

public void insertFill(MetaObject metaObject) {

this.setFieldValByName("gmtCreate",new Date(),metaObject);

this.setFieldValByName("gmtModified", new Date(), metaObject);

}

@Override

public void updateFill(MetaObject metaObject) {

this.setFieldValByName("gmtModified", new Date(), metaObject);

}

}

2、在实体类添加自动填充注解

@ApiModelProperty(value = "创建时间", example = "2019-01-01 8:00:00")

@TableField(fill = FieldFill.INSERT)

private Date gmtCreate;

@ApiModelProperty(value = "更新时间", example = "2019-01-01 8:00:00")

@TableField(fill = FieldFill.INSERT_UPDATE)

private Date gmtModified;

二、controller方法定义

1、新增

//5 添加讲师接口的方法

//通过对象传递数据@RequestBody

@ApiOperation(value = "新增讲师")

@PostMapping("addTeacher")

public R save(@ApiParam(name = "eduTeacher", value = "讲师对象", required = true)

@RequestBody EduTeacher eduTeacher){

boolean save = teacherService.save(eduTeacher);

if (save) {

return R.ok();

}else {

return R.error();

}

}

2、根据id查询

//根据讲师id查询

@ApiOperation(value = "根据id查询讲师")

@GetMapping("getTeacher/{id}")

public R getById(@ApiParam(name = "id", value = "讲师ID", required = true)

@PathVariable String id){

EduTeacher eduTeacher = teacherService.getById(id);

return R.ok().data("teacher",eduTeacher);

}

3、根据id修改

或：

//讲师修改功能

@ApiOperation(value = "根据ID修改讲师")

@PostMapping("updateTeacher")

public R updateTeacher(@RequestBody EduTeacher eduTeacher){

boolean flag = teacherService.updateById(eduTeacher);

if (flag) {

return R.ok();

}else {

return R.error();

}

}

06-统一异常处理

一、什么是统一异常处理

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

二、统一异常处理

1、创建统一异常处理器

在service-base中创建统一异常处理类GlobalExceptionHandler.java：

//统一异常处理类

@ControllerAdvice

public class GlobalExceptionHandler {

//指定出现什么异常执行这个方法

@ExceptionHandler(Exception.class)

@ResponseBody //为了返回数据

public R error(Exception e){

e.printStackTrace();

return R.error().message("执行了全局异常处理...");

}

}

在service_base中添加依赖：

删除service中的

测试：

三、处理特定异常

1、添加异常处理方法

@ExceptionHandler(Exception.class)

//特定异常

@ExceptionHandler(ArithmeticException.class)

@ResponseBody //为了返回数据

public R error(ArithmeticException e){

e.printStackTrace();

return R.error().message("执行了ArithmeticException异常处理...");

}

四、自定义异常

1、创建自定义异常类

@AllArgsConstructor //生成有参数的构造方法

@NoArgsConstructor //生成无参数的构造方法

@Data

@AllArgsConstructor //生成有参数的构造方法

@NoArgsConstructor //生成无参数的构造方法

public class GuliException extends RuntimeException {

@ApiModelProperty(value = "状态码")

private Integer code;

@ApiModelProperty(value = "异常信息")

private String msg;

}

2、业务中需要的位置抛出GuliException

try {

int a = 10/0;

}catch (Exception e){

//执行自定义异常

throw new GuliException(20001,"出现自定义异常");

}

3、添加异常处理方法

GlobalExceptionHandler.java中添加

//自定义异常

@ExceptionHandler(GuliException.class)

@ResponseBody //为了返回数据

public R error(GuliException e){

e.printStackTrace();

return R.error().code(e.getCode()).message(e.getMsg());

}

4、测试

07-统一日志处理

一、日志

1、配置日志级别

日志记录器（Logger）的行为是分等级的。如下表所示：

分为：OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL

默认情况下，spring boot从控制台打印出来的日志级别只有INFO及以上级别，可以配置日志级别

# 设置日志级别

logging.level.root=INFO

这种方式只能将日志打印在控制台上

二、Logback日志

spring boot内部使用Logback作为日志实现的框架。

Logback和log4j非常相似，如果你对log4j很熟悉，那对logback很快就会得心应手。

logback相对于log4j的一些优点：https://blog.csdn.net/caisini_vc/article/details/48551287

1、配置logback日志

删除application.properties中的日志配置

安装idea彩色日志插件：grep-console

resources 中创建 logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?>

<configuration scan="true" scanPeriod="10 seconds">









<contextName>logback</contextName>



<property name="log.path" value="D:/guli_log/edu" />















<property name="CONSOLE_LOG_PATTERN"

value="%yellow(%date{yyyy-MM-dd HH:mm:ss}) |%highlight(%-5level) |%blue(%thread) |%blue(%file:%line) |%green(%logger) |%cyan(%msg%n)"/>



<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">





<filter class="ch.qos.logback.classic.filter.ThresholdFilter">

<level>INFO</level>

</filter>

<encoder>

<Pattern>${CONSOLE_LOG_PATTERN}</Pattern>



<charset>UTF-8</charset>

</encoder>

</appender>





<appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">



<file>${log.path}/log_info.log</file>



<encoder>

<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>

<charset>UTF-8</charset>

</encoder>



<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">



<fileNamePattern>${log.path}/info/log-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>

<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">

<maxFileSize>100MB</maxFileSize>

</timeBasedFileNamingAndTriggeringPolicy>



<maxHistory>15</maxHistory>

</rollingPolicy>



<filter class="ch.qos.logback.classic.filter.LevelFilter">

<level>INFO</level>

<onMatch>ACCEPT</onMatch>

<onMismatch>DENY</onMismatch>

</filter>

</appender>



<appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">



<file>${log.path}/log_warn.log</file>



<encoder>

<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>

<charset>UTF-8</charset> 

</encoder>



<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">

<fileNamePattern>${log.path}/warn/log-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>

<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">

<maxFileSize>100MB</maxFileSize>

</timeBasedFileNamingAndTriggeringPolicy>



<maxHistory>15</maxHistory>

</rollingPolicy>



<filter class="ch.qos.logback.classic.filter.LevelFilter">

<level>warn</level>

<onMatch>ACCEPT</onMatch>

<onMismatch>DENY</onMismatch>

</filter>

</appender>



<appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">



<file>${log.path}/log_error.log</file>



<encoder>

<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>

<charset>UTF-8</charset> 

</encoder>



<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">

<fileNamePattern>${log.path}/error/log-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>

<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">

<maxFileSize>100MB</maxFileSize>

</timeBasedFileNamingAndTriggeringPolicy>



<maxHistory>15</maxHistory>

</rollingPolicy>



<filter class="ch.qos.logback.classic.filter.LevelFilter">

<level>ERROR</level>

<onMatch>ACCEPT</onMatch>

<onMismatch>DENY</onMismatch>

</filter>

</appender>







<springProfile name="dev">



<logger name="com.guli" level="INFO" />



<root level="INFO">

<appender-ref ref="CONSOLE" />

<appender-ref ref="INFO_FILE" />

<appender-ref ref="WARN_FILE" />

<appender-ref ref="ERROR_FILE" />

</root>

</springProfile>



<springProfile name="pro">

<root level="INFO">

<appender-ref ref="CONSOLE" />

<appender-ref ref="DEBUG_FILE" />

<appender-ref ref="INFO_FILE" />

<appender-ref ref="ERROR_FILE" />

<appender-ref ref="WARN_FILE" />

</root>

</springProfile>

</configuration>

2、将错误日志输出到文件

GlobalExceptionHandler.java 中

类上添加注解

异常输出语句

3、将日志堆栈信息输出到文件

定义工具类

guli-framework-common下创建util包，创建ExceptionUtil.java工具类

public class ExceptionUtil {

public static String getMessage(Exception e){

StringWriter sw =null;

PrintWriter pw = null;

try {

sw = new StringWriter();

pw = new PrintWriter(sw);

// 将出错的栈信息输出到printWriter中

e.printStackTrace(pw);

pw.flush();

sw.flush();

}finally {

if (sw!= null){

try {

sw.close();

}catch (IOException e1){

e1.printStackTrace();

}

}

if (pw!=null){

pw.close();

}

}

return sw.toString();

}

}

调用

log.error(ExceptionUtil.getMessage(e));

GuliException中创建toString方法

@Override

public String toString() {

return "GuliException{" +

"code=" + code +

", message='" + this.getMessage() + '\'' +

'}';

}

day02项目【环境搭建和讲师管理接口开发】