推荐|3.2 内容管理模块 - 课程分类、新增课程、修改课程

内容管理模块-课程分类、新增课程、修改课程

一、课程分类

点击“添加课程”，之后随便选一个“课程形式”

然后有一个“课程分类”，我们下面就要实现课程分类，这个地方缺少一个课程分类的下拉框

1.1 课程分类表

典型的树形分类结构

@Data
@TableName("course_category")
public class CourseCategory implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    private String id;

    /**
     * 分类名称
     */
    private String name;

    /**
     * 分类标签默认和名称一样
     */
    private String label;

    /**
     * 父结点id（第一级的父节点是0，自关联字段id）
     */
    private String parentid;

    /**
     * 是否显示
     */
    private Integer isShow;

    /**
     * 排序字段
     */
    private Integer orderby;

    /**
     * 是否叶子
     */
    private Integer isLeaf;


}
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

创建一个Dto，方便之后向前端响应课程分类表数据

@Data
public class CourseCategoryTreeDto extends CourseCategory implements Serializable {

    //Serializable:在网络传输需要序列化的时候，需要实现Serializable接口
    private static final long serialVersionUID = 2950235607890841126L;

    //下级节点
    List<CourseCategoryTreeDto> childrenTreeNodes;
    
}
1
2
3
4
5
6
7
8
9
10

展示出来是下面这种格式

{
"id" : "1-2",
"isLeaf" : null,
"isShow" : null,
"label" : "移动开发",
"name" : "移动开发",
"orderby" : 2,
"parentid" : "1",
"childrenTreeNodes" : [
               {
                  "childrenTreeNodes" : null,
                  "id" : "1-2-1",
                  "isLeaf" : null,
                  "isShow" : null,
                  "label" : "微信开发",
                  "name" : "微信开发",
                  "orderby" : 1,
                  "parentid" : "1-2"
               }
 }

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

1.2 查询树形结构

1.2.1 表自连接

假如说数据层级比较固定，而且数据层级比较少，可以使用表自连接的方式

select one.id one_id, one.label one_label, 
       two.id two_id,two.label two_label,
			 three.id three_id,three.label three_label
from course_category one -- one是表的别名，表示一级分类

inner join course_category two -- two是表的别名，表示二级分类
      on two.parentid = one.id -- 子节点的parentid是父节点的id
inner join course_category three
       on  three.parentid = two.id
1
2
3
4
5
6
7
8
9

查询结果

1.2.2 SQL递归

灵活的方式实现树形表的查询，比如使用MYSQL递归实现，使用with语法

递归时MySQL8之后才有的

递归语法

WITH [RECURSIVE]
        cte_name [(col_name [, col_name] ...)] AS (subquery)
        [, cte_name [(col_name [, col_name] ...)] AS (subquery)] 

1
2
3
4

cte_name :公共表达式的名称,可以理解为表名,用来表示as后面跟着的子查询

col_name :公共表达式包含的列名,可以写也可以不写

有一个关键字RECURSIVE，就是递归的含义

cte_name相当于表的一个别名

(col_name [, col_name] …)]是表中的哪些字段

示例代码

--  t1J就是一个虚拟表
with RECURSIVE t1  AS
(
-- 这个t1表的初始数据就是1
  SELECT 1 as n
	
-- 将下面查询出的数据结果集放入t1虚拟表中
  UNION ALL
	
-- 下面是递归查询的内容
  SELECT n + 1 FROM t1 WHERE n < 5
)

-- 查询最终结果
SELECT * FROM t1;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

下面查询树形结果的SQL,向下递归

向下递归：先拿一级节点，拿到一级节点后找二级节点，拿到二级节点后找三级节点…

with RECURSIVE t1  AS(
--  初始数据，就认为是根节点
  select * from course_category as p where id = '1'

--  每递归一次就把数据放入t1
union all

--  由树根找叶子
select t2.* 
from course_category as t2
INNER JOIN t1
      ON t2.parentid =  t1.id 
 
--  当我们拿到id为1的结点，递归后就可以拿到1-1等子结点的结果集
--  当我们拿到id为1-1等结点后，递归后就可以拿到1-1-1等子结点结果集
--  .......
)

select * from t1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

向上递归

向上递归：拿到最下一级的节点后找次下及节点…

由子节点找父节点

with RECURSIVE t1  AS(
--  初始数据，就认为是根节点
  select * from course_category as p where id = '1-1-1'

--  每递归一次就把数据放入t1
union all

--  由树根找叶子
select t2.* 
from course_category as t2
INNER JOIN t1
      ON t2.id =  t1.parentid 
 
--  当我们拿到id为1的结点，递归后就可以拿到1-1等子结点的结果集
--  当我们拿到id为1-1等结点后，递归后就可以拿到1-1-1等子结点结果集
--  .......
)

select * from t1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

mysql为了避免无限递归默认递归次数为1000，可以通过设置cte_max_recursion_depth参数增加递归深度，还可以通过max_execution_time限制执行时间，超过此时间也会终止递归操作。

mysql递归相当于在存储过程中执行若干次sql语句，java程序仅与数据库建立一次链接执行递归操作，所以只要控制好递归深度，控制好数据量性能就没有问题。

1.3 Mapper

//使用递归查询分类
public List<CourseCategoryTreeDto> selectTreeNodes(@Param("id") String id);
1
2

    
    <select id="selectTreeNodes" resultType="com.xuecheng.content.model.dto.CourseCategoryTreeDto">
        with RECURSIVE t1 AS (
            select *
            from course_category as p
            where id = #{id}
            union all
            select t2.*
            from course_category as t2
                     INNER JOIN t1
                                ON t2.parentid = t1.id
        )

        select *
        from t1
        order by t1.id, t1.orderby

    select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

我们现在从数据库中查到的数据是下列这个模样

代码中查询出来的数据如下所示

1.4 Service

要将Mapper层返回的数据进行进一步的处理。

将根节点id=1舍弃不要，因为在业务上没什么需要了

我们要将子节点放入到父节点的childrenTreeNodes集合里面。比如将1-1-x的节点放入到1-1节点的childrenTreeNodes集合里面

@Slf4j
@Service
public class CourseCategoryServiceImpl implements CourseCategoryService {

    @Autowired
    private CourseCategoryMapper courseCategoryMapper;

    @Override
    public List<CourseCategoryTreeDto> queryTreeNodes(String id) {
        //TODO 数据库递归查询出课程分类信息
        List<CourseCategoryTreeDto> courseCategoryTreeDtos = courseCategoryMapper.selectTreeNodes(id);


        //TODO 找到每个节点的子节点，最终封装成List
        //将list转map,以备使用,排除根节点
        Map<String, CourseCategoryTreeDto> mapTemp = courseCategoryTreeDtos.stream()
                //!id.equals(item.getId()) 含义就是排除根节点
                .filter(item -> !id.equals(item.getId()))
                .collect(
                        //转Map是需要一个key，一个value的
                        //第一个key是代表元素的意思，key -> key.getId()是拿到key元素的id，然后充当Map的key
                        //value表示对象的本身，所以不需要任何的处理
                        //(key1, key2) -> key2 表示当key重复的时候（键相同），以后来的key为主
                        Collectors.toMap(key -> key.getId(), value -> value, (key1, key2) -> key2)
                );

        //最终返回的list
        List<CourseCategoryTreeDto> categoryTreeDtos = new ArrayList<>();

        //依次遍历每个元素,排除根节点
        //courseCategoryTreeDtos是从数据库查询出来的全部的数据
        courseCategoryTreeDtos.stream().filter(item -> !id.equals(item.getId())).forEach(item -> {
            if (item.getParentid().equals(id)) {
                //紧挨根节点下的节点
                categoryTreeDtos.add(item);
            }
            //找到当前节点的父节点
            CourseCategoryTreeDto courseCategoryTreeDto = mapTemp.get(item.getParentid());
            if (courseCategoryTreeDto != null) {
                if (courseCategoryTreeDto.getChildrenTreeNodes() == null) {
                    courseCategoryTreeDto.setChildrenTreeNodes(new ArrayList<CourseCategoryTreeDto>());
                }
                //下边开始往ChildrenTreeNodes属性中放子节点
                courseCategoryTreeDto.getChildrenTreeNodes().add(item);
            }
        });
        return categoryTreeDtos;
    }

}
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

1.5 Controller

/**
 * 课程分类相关接口
 */
@Slf4j
@RestController
public class CourseCategoryController {


    @Autowired
    private CourseCategoryService courseCategoryService;

    @GetMapping("/course-category/tree-nodes")
    public List<CourseCategoryTreeDto> queryTreeNodes() {
        return courseCategoryService.queryTreeNodes("1");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1.6 效果图

二、添加课程

2.1 需求分析

将来这些信息都会存储到“course_base”表中

点击“添加课程”选项

点击添加课程，选择课程形式为录播

选择完毕，点击下一步，进入课程基本信息添加界面

本界面分两部分信息，一部分是课程基本信息上，一部分是课程营销信息。

课程基本信息

课程营销信息：

下面的信息会存储在course_market表中

也就是说一个表单中的数据要存储到两张表中

在这个界面中填写课程的基本信息、课程营销信息上。

填写完毕，保存并进行下一步

2.2 数据表

course_base、course_market两张表存储

两张表是一对一的关系，一个课程只有一个营销信息

并且两张表的主键id是相同的

2.2.1 课程基础信息表

course_base

/**
 * 课程基本信息
 */
@Data
@TableName("course_base")
public class CourseBase implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    /**
     * 机构ID
     */
    private Long companyId;

    /**
     * 机构名称
     */
    private String companyName;

    /**
     * 课程名称
     */
    private String name;

    /**
     * 适用人群
     */
    private String users;

    /**
     * 课程标签
     */
    private String tags;

    /**
     * 大分类
     */
    private String mt;

    /**
     * 小分类
     */
    private String st;

    /**
     * 课程等级
     */
    private String grade;

    /**
     * 教育模式(common普通，record 录播，live直播等）
     */
    private String teachmode;

    /**
     * 课程介绍
     */
    private String description;

    /**
     * 课程图片
     */
    private String pic;

    /**
     * 创建时间
     */
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createDate;

    /**
     * 修改时间
     */
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime changeDate;

    /**
     * 创建人
     */
    private String createPeople;

    /**
     * 更新人
     */
    private String changePeople;

    /**
     * 审核状态
     */
    private String auditStatus;

    /**
     * 课程发布状态 未发布  已发布 下线
     */
    private String status;
}

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

2.2.2 课程营销信息表

course_market

/**
 * 课程营销信息
 */
@Data
@TableName("course_market")
public class CourseMarket implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键，课程id
     */
    private Long id;

    /**
     * 收费规则，对应数据字典
     */
    private String charge;

    /**
     * 现价
     */
    private Float price;

    /**
     * 原价
     */
    private Float originalPrice;

    /**
     * 咨询qq
     */
    private String qq;

    /**
     * 微信
     */
    private String wechat;

    /**
     * 电话
     */
    private String phone;

    /**
     * 有效期天数
     */
    private Integer validDays;


}

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

2.3 交互类

2.3.1 AddCourseDto

价格信息存Float是没有问题的，但是计算的时候是有问题的，我们要使用BigDecimal

/**
 * @description 添加课程dto
 */
@Data
@ApiModel(value = "AddCourseDto", description = "新增课程基本信息")
public class AddCourseDto {

    @NotEmpty(message = "课程名称不能为空")
    @ApiModelProperty(value = "课程名称", required = true)
    private String name;

    @NotEmpty(message = "适用人群不能为空")
    @Size(message = "适用人群内容过少", min = 10)
    @ApiModelProperty(value = "适用人群", required = true)
    private String users;

    @ApiModelProperty(value = "课程标签")
    private String tags;

    @NotEmpty(message = "课程分类不能为空")
    @ApiModelProperty(value = "大分类", required = true)
    private String mt;

    @NotEmpty(message = "课程分类不能为空")
    @ApiModelProperty(value = "小分类", required = true)
    private String st;

    @NotEmpty(message = "课程等级不能为空")
    @ApiModelProperty(value = "课程等级", required = true)
    private String grade;

    @ApiModelProperty(value = "教学模式（普通，录播，直播等）", required = true)
    private String teachmode;

    @ApiModelProperty(value = "课程介绍")
    private String description;

    @ApiModelProperty(value = "课程图片", required = true)
    private String pic;

    @NotEmpty(message = "收费规则不能为空")
    @ApiModelProperty(value = "收费规则，对应数据字典", required = true)
    private String charge;

    @ApiModelProperty(value = "价格")
    private BigDecimal price;
    @ApiModelProperty(value = "原价")
    private BigDecimal originalPrice;


    @ApiModelProperty(value = "qq")
    private String qq;

    @ApiModelProperty(value = "微信")
    private String wechat;
    @ApiModelProperty(value = "电话")
    private String phone;

    @ApiModelProperty(value = "有效期")
    private Integer validDays;
}
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

2.3.2 CourseBaseInfoDto

添加成功之后我们查询出来的课程的详细信息

/**
 * @description 课程基本信息dto
 * 添加上课程信息后我们再查询返回的信息
 */
@Data
public class CourseBaseInfoDto extends CourseBase {


    /**
     * 收费规则，对应数据字典
     */
    private String charge;

    /**
     * 价格
     */
    private Float price;


    /**
     * 原价
     */
    private Float originalPrice;

    /**
     * 咨询qq
     */
    private String qq;

    /**
     * 微信
     */
    private String wechat;

    /**
     * 电话
     */
    private String phone;

    /**
     * 有效期天数
     */
    private Integer validDays;

    /**
     * 大分类名称
     */
    private String mtName;

    /**
     * 小分类名称
     */
    private String stName;

}
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

2.3 Mapper

/**
 * 课程基本信息 Mapper 接口
 */
public interface CourseBaseMapper extends BaseMapper<CourseBase> {

}
1
2
3
4
5
6

/**
 * 课程营销信息 Mapper 接口
 */
public interface CourseMarketMapper extends BaseMapper<CourseMarket> {

}
1
2
3
4
5
6

2.4 Service

2.5 Controller

    @ApiOperation("新增课程")
    @PostMapping("/course")
    public CourseBaseInfoDto createCourseBase(@Validated @RequestBody AddCourseDto addCourseDto) {
//      将来会集成SpringSecurity框架，用户登录之后就可以获取到用户所属机构的ID
//      先把机构ID写死
        return courseBaseInfoService.createCourseBase(10086L,addCourseDto);
    }
1
2
3
4
5
6
7

2.6 效果图

之后点击保存，这个时候会报错一个404，因为后面课程大纲的内容还没有编写

再查看数据库

再通过页面查看一下，还是挺带劲的

三、修改课程

涉及的表也是course_base课程基本信息表、course_market课程营销表

其实就是比添加课程多了一个数据回显而已

3.1 需求分析

点击编辑按钮就可以修改课程信息

要修改的表单内容其实是和添加课程时的表单是一个样子的

然后这个地方点击编辑的时候要做一个数据回显

修改课程的请求数据只是比添加课程的请求数据多了一个课程id而已

但是没有营销信息

3.2 数据回显

3.2.1 Service类

这个方法之前其实写过

    @Override
    public CourseBaseInfoDto getCourseBaseInfo(Long courseId){

        //TODO 查询课程基本信息
        CourseBase courseBase = courseBaseMapper.selectById(courseId);
        if(courseBase == null){
            return null;
        }
        //TODO 查询课程营销信息
        CourseMarket courseMarket = courseMarketMapper.selectById(courseId);
        CourseBaseInfoDto courseBaseInfoDto = new CourseBaseInfoDto();
        BeanUtils.copyProperties(courseBase,courseBaseInfoDto);
        if(courseMarket != null){
            BeanUtils.copyProperties(courseMarket,courseBaseInfoDto);
        }

        //TODO 查询分类名称，是哪一级的
        CourseCategory courseCategoryBySt = courseCategoryMapper.selectById(courseBase.getSt());//小分类
        courseBaseInfoDto.setStName(courseCategoryBySt.getName());//小分类名称

        CourseCategory courseCategoryByMt = courseCategoryMapper.selectById(courseBase.getMt());//大分类
        courseBaseInfoDto.setMtName(courseCategoryByMt.getName());//大分类名称

        return courseBaseInfoDto;

    }
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

3.2.2 Controller类

    @ApiOperation("根据课程id查询接口")
    @GetMapping("/course/{courseId}")
    public CourseBaseInfoDto getCourseBaseById(@PathVariable("courseId") Long courseId) {
        return courseBaseInfoService.getCourseBaseInfo(courseId);
    }
1
2
3
4
5

3.3 修改课程

3.3.1 修改课程Dto

修改课程的请求数据只比增加课程的请求数据多一个课程id

/**
 * 修改课程Dto
 */
@Data
@ApiModel(value = "EditCourseDto",description = "修改课程基本信息")
public class EditCourseDto extends AddCourseDto{

    @ApiModelProperty(value = "课程id",required = true)
    private Long id;
}

1
2
3
4
5
6
7
8
9
10
11

3.3.2 Service

    /**
     * 修改课程
     *
     * @param companyId     机构id，后面做认证收取那使用
     * @param editCourseDto 要修改的课程信息
     * @return 修改之后的课程详细信息
     */
    @Override
    public CourseBaseInfoDto updateCourseBase(Long companyId, EditCourseDto editCourseDto) {
        //TODO 课程基本信息
        //获取到课程id
        Long courseId = editCourseDto.getId();
        //查询课程
        CourseBase courseBase = courseBaseMapper.selectById(courseId);

        if (courseBase == null) {
            XueChengPlusException.cast("课程不存在");
        }
        //数据合法性校验
        //根据具体的业务逻辑进行校验 - 本机构只能修改本机构的课程
        if (!companyId.equals(courseBase.getCompanyId())) {
            XueChengPlusException.cast("本机构只能修改本机构的课程");
        }

        //封装数据
        BeanUtils.copyProperties(editCourseDto, courseBase);
        //修改时间
        courseBase.setChangeDate(LocalDateTime.now());
        //更新数据库
        int i = courseBaseMapper.updateById(courseBase);
        if (i<=0){
            XueChengPlusException.cast("修改课程失败");
        }

        //TODO 更新课程营销信息
        CourseMarket courseMarketNew = new CourseMarket();
        BeanUtils.copyProperties(editCourseDto, courseMarketNew);
        int count = courseMarketMapper.updateById(courseMarketNew);
        if (count <= 0) {
            throw new RuntimeException("更新课程营销信息失败");
        }

        //查询课程信息
        CourseBaseInfoDto courseBaseInfo = getCourseBaseInfo(courseId);

        return courseBaseInfo;
    }
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.3.3 Controller

    @ApiOperation("修改课程接口")
    @PutMapping("/course")
    public CourseBaseInfoDto getCourseBaseById(@RequestBody EditCourseDto editCourseDto) {

        //机构id先写死，后面授权认证的时候后会改过来
        Long companyId = 1232141425L;
        return courseBaseInfoService.updateCourseBase(companyId,editCourseDto);
    }
1
2
3
4
5
6
7
8

内容管理模块-课程分类、新增课程、修改课程

一、课程分类

点击“添加课程”，之后随便选一个“课程形式”

然后有一个“课程分类”，我们下面就要实现课程分类，这个地方缺少一个课程分类的下拉框

1.1 课程分类表

典型的树形分类结构

@Data
@TableName("course_category")
public class CourseCategory implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    private String id;

    /**
     * 分类名称
     */
    private String name;

    /**
     * 分类标签默认和名称一样
     */
    private String label;

    /**
     * 父结点id（第一级的父节点是0，自关联字段id）
     */
    private String parentid;

    /**
     * 是否显示
     */
    private Integer isShow;

    /**
     * 排序字段
     */
    private Integer orderby;

    /**
     * 是否叶子
     */
    private Integer isLeaf;


}
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

创建一个Dto，方便之后向前端响应课程分类表数据

@Data
public class CourseCategoryTreeDto extends CourseCategory implements Serializable {

    //Serializable:在网络传输需要序列化的时候，需要实现Serializable接口
    private static final long serialVersionUID = 2950235607890841126L;

    //下级节点
    List<CourseCategoryTreeDto> childrenTreeNodes;
    
}
1
2
3
4
5
6
7
8
9
10

展示出来是下面这种格式

{
"id" : "1-2",
"isLeaf" : null,
"isShow" : null,
"label" : "移动开发",
"name" : "移动开发",
"orderby" : 2,
"parentid" : "1",
"childrenTreeNodes" : [
               {
                  "childrenTreeNodes" : null,
                  "id" : "1-2-1",
                  "isLeaf" : null,
                  "isShow" : null,
                  "label" : "微信开发",
                  "name" : "微信开发",
                  "orderby" : 1,
                  "parentid" : "1-2"
               }
 }

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

1.2 查询树形结构

1.2.1 表自连接

假如说数据层级比较固定，而且数据层级比较少，可以使用表自连接的方式

select one.id one_id, one.label one_label, 
       two.id two_id,two.label two_label,
			 three.id three_id,three.label three_label
from course_category one -- one是表的别名，表示一级分类

inner join course_category two -- two是表的别名，表示二级分类
      on two.parentid = one.id -- 子节点的parentid是父节点的id
inner join course_category three
       on  three.parentid = two.id
1
2
3
4
5
6
7
8
9

查询结果

1.2.2 SQL递归

灵活的方式实现树形表的查询，比如使用MYSQL递归实现，使用with语法

递归时MySQL8之后才有的

递归语法

WITH [RECURSIVE]
        cte_name [(col_name [, col_name] ...)] AS (subquery)
        [, cte_name [(col_name [, col_name] ...)] AS (subquery)] 

1
2
3
4

cte_name :公共表达式的名称,可以理解为表名,用来表示as后面跟着的子查询

col_name :公共表达式包含的列名,可以写也可以不写

有一个关键字RECURSIVE，就是递归的含义

cte_name相当于表的一个别名

(col_name [, col_name] …)]是表中的哪些字段

示例代码

--  t1J就是一个虚拟表
with RECURSIVE t1  AS
(
-- 这个t1表的初始数据就是1
  SELECT 1 as n
	
-- 将下面查询出的数据结果集放入t1虚拟表中
  UNION ALL
	
-- 下面是递归查询的内容
  SELECT n + 1 FROM t1 WHERE n < 5
)

-- 查询最终结果
SELECT * FROM t1;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

下面查询树形结果的SQL,向下递归

向下递归：先拿一级节点，拿到一级节点后找二级节点，拿到二级节点后找三级节点…

with RECURSIVE t1  AS(
--  初始数据，就认为是根节点
  select * from course_category as p where id = '1'

--  每递归一次就把数据放入t1
union all

--  由树根找叶子
select t2.* 
from course_category as t2
INNER JOIN t1
      ON t2.parentid =  t1.id 
 
--  当我们拿到id为1的结点，递归后就可以拿到1-1等子结点的结果集
--  当我们拿到id为1-1等结点后，递归后就可以拿到1-1-1等子结点结果集
--  .......
)

select * from t1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

向上递归

向上递归：拿到最下一级的节点后找次下及节点…

由子节点找父节点

with RECURSIVE t1  AS(
--  初始数据，就认为是根节点
  select * from course_category as p where id = '1-1-1'

--  每递归一次就把数据放入t1
union all

--  由树根找叶子
select t2.* 
from course_category as t2
INNER JOIN t1
      ON t2.id =  t1.parentid 
 
--  当我们拿到id为1的结点，递归后就可以拿到1-1等子结点的结果集
--  当我们拿到id为1-1等结点后，递归后就可以拿到1-1-1等子结点结果集
--  .......
)

select * from t1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

mysql为了避免无限递归默认递归次数为1000，可以通过设置cte_max_recursion_depth参数增加递归深度，还可以通过max_execution_time限制执行时间，超过此时间也会终止递归操作。

mysql递归相当于在存储过程中执行若干次sql语句，java程序仅与数据库建立一次链接执行递归操作，所以只要控制好递归深度，控制好数据量性能就没有问题。

1.3 Mapper

//使用递归查询分类
public List<CourseCategoryTreeDto> selectTreeNodes(@Param("id") String id);
1
2

    
    <select id="selectTreeNodes" resultType="com.xuecheng.content.model.dto.CourseCategoryTreeDto">
        with RECURSIVE t1 AS (
            select *
            from course_category as p
            where id = #{id}
            union all
            select t2.*
            from course_category as t2
                     INNER JOIN t1
                                ON t2.parentid = t1.id
        )

        select *
        from t1
        order by t1.id, t1.orderby

    select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

我们现在从数据库中查到的数据是下列这个模样

代码中查询出来的数据如下所示

1.4 Service

要将Mapper层返回的数据进行进一步的处理。

将根节点id=1舍弃不要，因为在业务上没什么需要了

我们要将子节点放入到父节点的childrenTreeNodes集合里面。比如将1-1-x的节点放入到1-1节点的childrenTreeNodes集合里面

@Slf4j
@Service
public class CourseCategoryServiceImpl implements CourseCategoryService {

    @Autowired
    private CourseCategoryMapper courseCategoryMapper;

    @Override
    public List<CourseCategoryTreeDto> queryTreeNodes(String id) {
        //TODO 数据库递归查询出课程分类信息
        List<CourseCategoryTreeDto> courseCategoryTreeDtos = courseCategoryMapper.selectTreeNodes(id);


        //TODO 找到每个节点的子节点，最终封装成List
        //将list转map,以备使用,排除根节点
        Map<String, CourseCategoryTreeDto> mapTemp = courseCategoryTreeDtos.stream()
                //!id.equals(item.getId()) 含义就是排除根节点
                .filter(item -> !id.equals(item.getId()))
                .collect(
                        //转Map是需要一个key，一个value的
                        //第一个key是代表元素的意思，key -> key.getId()是拿到key元素的id，然后充当Map的key
                        //value表示对象的本身，所以不需要任何的处理
                        //(key1, key2) -> key2 表示当key重复的时候（键相同），以后来的key为主
                        Collectors.toMap(key -> key.getId(), value -> value, (key1, key2) -> key2)
                );

        //最终返回的list
        List<CourseCategoryTreeDto> categoryTreeDtos = new ArrayList<>();

        //依次遍历每个元素,排除根节点
        //courseCategoryTreeDtos是从数据库查询出来的全部的数据
        courseCategoryTreeDtos.stream().filter(item -> !id.equals(item.getId())).forEach(item -> {
            if (item.getParentid().equals(id)) {
                //紧挨根节点下的节点
                categoryTreeDtos.add(item);
            }
            //找到当前节点的父节点
            CourseCategoryTreeDto courseCategoryTreeDto = mapTemp.get(item.getParentid());
            if (courseCategoryTreeDto != null) {
                if (courseCategoryTreeDto.getChildrenTreeNodes() == null) {
                    courseCategoryTreeDto.setChildrenTreeNodes(new ArrayList<CourseCategoryTreeDto>());
                }
                //下边开始往ChildrenTreeNodes属性中放子节点
                courseCategoryTreeDto.getChildrenTreeNodes().add(item);
            }
        });
        return categoryTreeDtos;
    }

}
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

1.5 Controller

/**
 * 课程分类相关接口
 */
@Slf4j
@RestController
public class CourseCategoryController {


    @Autowired
    private CourseCategoryService courseCategoryService;

    @GetMapping("/course-category/tree-nodes")
    public List<CourseCategoryTreeDto> queryTreeNodes() {
        return courseCategoryService.queryTreeNodes("1");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1.6 效果图

二、添加课程

2.1 需求分析

将来这些信息都会存储到“course_base”表中

点击“添加课程”选项

点击添加课程，选择课程形式为录播

选择完毕，点击下一步，进入课程基本信息添加界面

本界面分两部分信息，一部分是课程基本信息上，一部分是课程营销信息。

课程基本信息

课程营销信息：

下面的信息会存储在course_market表中

也就是说一个表单中的数据要存储到两张表中

在这个界面中填写课程的基本信息、课程营销信息上。

填写完毕，保存并进行下一步

2.2 数据表

course_base、course_market两张表存储

两张表是一对一的关系，一个课程只有一个营销信息

并且两张表的主键id是相同的

2.2.1 课程基础信息表

course_base

/**
 * 课程基本信息
 */
@Data
@TableName("course_base")
public class CourseBase implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    /**
     * 机构ID
     */
    private Long companyId;

    /**
     * 机构名称
     */
    private String companyName;

    /**
     * 课程名称
     */
    private String name;

    /**
     * 适用人群
     */
    private String users;

    /**
     * 课程标签
     */
    private String tags;

    /**
     * 大分类
     */
    private String mt;

    /**
     * 小分类
     */
    private String st;

    /**
     * 课程等级
     */
    private String grade;

    /**
     * 教育模式(common普通，record 录播，live直播等）
     */
    private String teachmode;

    /**
     * 课程介绍
     */
    private String description;

    /**
     * 课程图片
     */
    private String pic;

    /**
     * 创建时间
     */
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createDate;

    /**
     * 修改时间
     */
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime changeDate;

    /**
     * 创建人
     */
    private String createPeople;

    /**
     * 更新人
     */
    private String changePeople;

    /**
     * 审核状态
     */
    private String auditStatus;

    /**
     * 课程发布状态 未发布  已发布 下线
     */
    private String status;
}

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

2.2.2 课程营销信息表

course_market

/**
 * 课程营销信息
 */
@Data
@TableName("course_market")
public class CourseMarket implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键，课程id
     */
    private Long id;

    /**
     * 收费规则，对应数据字典
     */
    private String charge;

    /**
     * 现价
     */
    private Float price;

    /**
     * 原价
     */
    private Float originalPrice;

    /**
     * 咨询qq
     */
    private String qq;

    /**
     * 微信
     */
    private String wechat;

    /**
     * 电话
     */
    private String phone;

    /**
     * 有效期天数
     */
    private Integer validDays;


}

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

2.3 交互类

2.3.1 AddCourseDto

价格信息存Float是没有问题的，但是计算的时候是有问题的，我们要使用BigDecimal

/**
 * @description 添加课程dto
 */
@Data
@ApiModel(value = "AddCourseDto", description = "新增课程基本信息")
public class AddCourseDto {

    @NotEmpty(message = "课程名称不能为空")
    @ApiModelProperty(value = "课程名称", required = true)
    private String name;

    @NotEmpty(message = "适用人群不能为空")
    @Size(message = "适用人群内容过少", min = 10)
    @ApiModelProperty(value = "适用人群", required = true)
    private String users;

    @ApiModelProperty(value = "课程标签")
    private String tags;

    @NotEmpty(message = "课程分类不能为空")
    @ApiModelProperty(value = "大分类", required = true)
    private String mt;

    @NotEmpty(message = "课程分类不能为空")
    @ApiModelProperty(value = "小分类", required = true)
    private String st;

    @NotEmpty(message = "课程等级不能为空")
    @ApiModelProperty(value = "课程等级", required = true)
    private String grade;

    @ApiModelProperty(value = "教学模式（普通，录播，直播等）", required = true)
    private String teachmode;

    @ApiModelProperty(value = "课程介绍")
    private String description;

    @ApiModelProperty(value = "课程图片", required = true)
    private String pic;

    @NotEmpty(message = "收费规则不能为空")
    @ApiModelProperty(value = "收费规则，对应数据字典", required = true)
    private String charge;

    @ApiModelProperty(value = "价格")
    private BigDecimal price;
    @ApiModelProperty(value = "原价")
    private BigDecimal originalPrice;


    @ApiModelProperty(value = "qq")
    private String qq;

    @ApiModelProperty(value = "微信")
    private String wechat;
    @ApiModelProperty(value = "电话")
    private String phone;

    @ApiModelProperty(value = "有效期")
    private Integer validDays;
}
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

2.3.2 CourseBaseInfoDto

添加成功之后我们查询出来的课程的详细信息

/**
 * @description 课程基本信息dto
 * 添加上课程信息后我们再查询返回的信息
 */
@Data
public class CourseBaseInfoDto extends CourseBase {


    /**
     * 收费规则，对应数据字典
     */
    private String charge;

    /**
     * 价格
     */
    private Float price;


    /**
     * 原价
     */
    private Float originalPrice;

    /**
     * 咨询qq
     */
    private String qq;

    /**
     * 微信
     */
    private String wechat;

    /**
     * 电话
     */
    private String phone;

    /**
     * 有效期天数
     */
    private Integer validDays;

    /**
     * 大分类名称
     */
    private String mtName;

    /**
     * 小分类名称
     */
    private String stName;

}
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

2.3 Mapper

/**
 * 课程基本信息 Mapper 接口
 */
public interface CourseBaseMapper extends BaseMapper<CourseBase> {

}
1
2
3
4
5
6

/**
 * 课程营销信息 Mapper 接口
 */
public interface CourseMarketMapper extends BaseMapper<CourseMarket> {

}
1
2
3
4
5
6

2.4 Service

2.5 Controller

    @ApiOperation("新增课程")
    @PostMapping("/course")
    public CourseBaseInfoDto createCourseBase(@Validated @RequestBody AddCourseDto addCourseDto) {
//      将来会集成SpringSecurity框架，用户登录之后就可以获取到用户所属机构的ID
//      先把机构ID写死
        return courseBaseInfoService.createCourseBase(10086L,addCourseDto);
    }
1
2
3
4
5
6
7

2.6 效果图

之后点击保存，这个时候会报错一个404，因为后面课程大纲的内容还没有编写

再查看数据库

再通过页面查看一下，还是挺带劲的

三、修改课程

涉及的表也是course_base课程基本信息表、course_market课程营销表

其实就是比添加课程多了一个数据回显而已

3.1 需求分析

点击编辑按钮就可以修改课程信息

要修改的表单内容其实是和添加课程时的表单是一个样子的

然后这个地方点击编辑的时候要做一个数据回显

修改课程的请求数据只是比添加课程的请求数据多了一个课程id而已

但是没有营销信息

3.2 数据回显

3.2.1 Service类

这个方法之前其实写过

    @Override
    public CourseBaseInfoDto getCourseBaseInfo(Long courseId){

        //TODO 查询课程基本信息
        CourseBase courseBase = courseBaseMapper.selectById(courseId);
        if(courseBase == null){
            return null;
        }
        //TODO 查询课程营销信息
        CourseMarket courseMarket = courseMarketMapper.selectById(courseId);
        CourseBaseInfoDto courseBaseInfoDto = new CourseBaseInfoDto();
        BeanUtils.copyProperties(courseBase,courseBaseInfoDto);
        if(courseMarket != null){
            BeanUtils.copyProperties(courseMarket,courseBaseInfoDto);
        }

        //TODO 查询分类名称，是哪一级的
        CourseCategory courseCategoryBySt = courseCategoryMapper.selectById(courseBase.getSt());//小分类
        courseBaseInfoDto.setStName(courseCategoryBySt.getName());//小分类名称

        CourseCategory courseCategoryByMt = courseCategoryMapper.selectById(courseBase.getMt());//大分类
        courseBaseInfoDto.setMtName(courseCategoryByMt.getName());//大分类名称

        return courseBaseInfoDto;

    }
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

3.2.2 Controller类

    @ApiOperation("根据课程id查询接口")
    @GetMapping("/course/{courseId}")
    public CourseBaseInfoDto getCourseBaseById(@PathVariable("courseId") Long courseId) {
        return courseBaseInfoService.getCourseBaseInfo(courseId);
    }
1
2
3
4
5

3.3 修改课程

3.3.1 修改课程Dto

修改课程的请求数据只比增加课程的请求数据多一个课程id

/**
 * 修改课程Dto
 */
@Data
@ApiModel(value = "EditCourseDto",description = "修改课程基本信息")
public class EditCourseDto extends AddCourseDto{

    @ApiModelProperty(value = "课程id",required = true)
    private Long id;
}

1
2
3
4
5
6
7
8
9
10
11

3.3.2 Service

    /**
     * 修改课程
     *
     * @param companyId     机构id，后面做认证收取那使用
     * @param editCourseDto 要修改的课程信息
     * @return 修改之后的课程详细信息
     */
    @Override
    public CourseBaseInfoDto updateCourseBase(Long companyId, EditCourseDto editCourseDto) {
        //TODO 课程基本信息
        //获取到课程id
        Long courseId = editCourseDto.getId();
        //查询课程
        CourseBase courseBase = courseBaseMapper.selectById(courseId);

        if (courseBase == null) {
            XueChengPlusException.cast("课程不存在");
        }
        //数据合法性校验
        //根据具体的业务逻辑进行校验 - 本机构只能修改本机构的课程
        if (!companyId.equals(courseBase.getCompanyId())) {
            XueChengPlusException.cast("本机构只能修改本机构的课程");
        }

        //封装数据
        BeanUtils.copyProperties(editCourseDto, courseBase);
        //修改时间
        courseBase.setChangeDate(LocalDateTime.now());
        //更新数据库
        int i = courseBaseMapper.updateById(courseBase);
        if (i<=0){
            XueChengPlusException.cast("修改课程失败");
        }

        //TODO 更新课程营销信息
        CourseMarket courseMarketNew = new CourseMarket();
        BeanUtils.copyProperties(editCourseDto, courseMarketNew);
        int count = courseMarketMapper.updateById(courseMarketNew);
        if (count <= 0) {
            throw new RuntimeException("更新课程营销信息失败");
        }

        //查询课程信息
        CourseBaseInfoDto courseBaseInfo = getCourseBaseInfo(courseId);

        return courseBaseInfo;
    }
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.3.3 Controller

    @ApiOperation("修改课程接口")
    @PutMapping("/course")
    public CourseBaseInfoDto getCourseBaseById(@RequestBody EditCourseDto editCourseDto) {

        //机构id先写死，后面授权认证的时候后会改过来
        Long companyId = 1232141425L;
        return courseBaseInfoService.updateCourseBase(companyId,editCourseDto);
    }
1
2
3
4
5
6
7
8

内容管理模块-课程分类、新增课程、修改课程

一、课程分类

点击“添加课程”，之后随便选一个“课程形式”

然后有一个“课程分类”，我们下面就要实现课程分类，这个地方缺少一个课程分类的下拉框

1.1 课程分类表

典型的树形分类结构

@Data
@TableName("course_category")
public class CourseCategory implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    private String id;

    /**
     * 分类名称
     */
    private String name;

    /**
     * 分类标签默认和名称一样
     */
    private String label;

    /**
     * 父结点id（第一级的父节点是0，自关联字段id）
     */
    private String parentid;

    /**
     * 是否显示
     */
    private Integer isShow;

    /**
     * 排序字段
     */
    private Integer orderby;

    /**
     * 是否叶子
     */
    private Integer isLeaf;


}
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

创建一个Dto，方便之后向前端响应课程分类表数据

@Data
public class CourseCategoryTreeDto extends CourseCategory implements Serializable {

    //Serializable:在网络传输需要序列化的时候，需要实现Serializable接口
    private static final long serialVersionUID = 2950235607890841126L;

    //下级节点
    List<CourseCategoryTreeDto> childrenTreeNodes;
    
}
1
2
3
4
5
6
7
8
9
10

展示出来是下面这种格式

{
"id" : "1-2",
"isLeaf" : null,
"isShow" : null,
"label" : "移动开发",
"name" : "移动开发",
"orderby" : 2,
"parentid" : "1",
"childrenTreeNodes" : [
               {
                  "childrenTreeNodes" : null,
                  "id" : "1-2-1",
                  "isLeaf" : null,
                  "isShow" : null,
                  "label" : "微信开发",
                  "name" : "微信开发",
                  "orderby" : 1,
                  "parentid" : "1-2"
               }
 }

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

1.2 查询树形结构

1.2.1 表自连接

假如说数据层级比较固定，而且数据层级比较少，可以使用表自连接的方式

select one.id one_id, one.label one_label, 
       two.id two_id,two.label two_label,
			 three.id three_id,three.label three_label
from course_category one -- one是表的别名，表示一级分类

inner join course_category two -- two是表的别名，表示二级分类
      on two.parentid = one.id -- 子节点的parentid是父节点的id
inner join course_category three
       on  three.parentid = two.id
1
2
3
4
5
6
7
8
9

查询结果

1.2.2 SQL递归

灵活的方式实现树形表的查询，比如使用MYSQL递归实现，使用with语法

递归时MySQL8之后才有的

递归语法

WITH [RECURSIVE]
        cte_name [(col_name [, col_name] ...)] AS (subquery)
        [, cte_name [(col_name [, col_name] ...)] AS (subquery)] 

1
2
3
4

cte_name :公共表达式的名称,可以理解为表名,用来表示as后面跟着的子查询

col_name :公共表达式包含的列名,可以写也可以不写

有一个关键字RECURSIVE，就是递归的含义

cte_name相当于表的一个别名

(col_name [, col_name] …)]是表中的哪些字段

示例代码

--  t1J就是一个虚拟表
with RECURSIVE t1  AS
(
-- 这个t1表的初始数据就是1
  SELECT 1 as n
	
-- 将下面查询出的数据结果集放入t1虚拟表中
  UNION ALL
	
-- 下面是递归查询的内容
  SELECT n + 1 FROM t1 WHERE n < 5
)

-- 查询最终结果
SELECT * FROM t1;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

下面查询树形结果的SQL,向下递归

向下递归：先拿一级节点，拿到一级节点后找二级节点，拿到二级节点后找三级节点…

with RECURSIVE t1  AS(
--  初始数据，就认为是根节点
  select * from course_category as p where id = '1'

--  每递归一次就把数据放入t1
union all

--  由树根找叶子
select t2.* 
from course_category as t2
INNER JOIN t1
      ON t2.parentid =  t1.id 
 
--  当我们拿到id为1的结点，递归后就可以拿到1-1等子结点的结果集
--  当我们拿到id为1-1等结点后，递归后就可以拿到1-1-1等子结点结果集
--  .......
)

select * from t1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

向上递归

向上递归：拿到最下一级的节点后找次下及节点…

由子节点找父节点

with RECURSIVE t1  AS(
--  初始数据，就认为是根节点
  select * from course_category as p where id = '1-1-1'

--  每递归一次就把数据放入t1
union all

--  由树根找叶子
select t2.* 
from course_category as t2
INNER JOIN t1
      ON t2.id =  t1.parentid 
 
--  当我们拿到id为1的结点，递归后就可以拿到1-1等子结点的结果集
--  当我们拿到id为1-1等结点后，递归后就可以拿到1-1-1等子结点结果集
--  .......
)

select * from t1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

mysql为了避免无限递归默认递归次数为1000，可以通过设置cte_max_recursion_depth参数增加递归深度，还可以通过max_execution_time限制执行时间，超过此时间也会终止递归操作。

mysql递归相当于在存储过程中执行若干次sql语句，java程序仅与数据库建立一次链接执行递归操作，所以只要控制好递归深度，控制好数据量性能就没有问题。

1.3 Mapper

//使用递归查询分类
public List<CourseCategoryTreeDto> selectTreeNodes(@Param("id") String id);
1
2

    
    <select id="selectTreeNodes" resultType="com.xuecheng.content.model.dto.CourseCategoryTreeDto">
        with RECURSIVE t1 AS (
            select *
            from course_category as p
            where id = #{id}
            union all
            select t2.*
            from course_category as t2
                     INNER JOIN t1
                                ON t2.parentid = t1.id
        )

        select *
        from t1
        order by t1.id, t1.orderby

    select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

我们现在从数据库中查到的数据是下列这个模样

代码中查询出来的数据如下所示

1.4 Service

要将Mapper层返回的数据进行进一步的处理。

将根节点id=1舍弃不要，因为在业务上没什么需要了

我们要将子节点放入到父节点的childrenTreeNodes集合里面。比如将1-1-x的节点放入到1-1节点的childrenTreeNodes集合里面

@Slf4j
@Service
public class CourseCategoryServiceImpl implements CourseCategoryService {

    @Autowired
    private CourseCategoryMapper courseCategoryMapper;

    @Override
    public List<CourseCategoryTreeDto> queryTreeNodes(String id) {
        //TODO 数据库递归查询出课程分类信息
        List<CourseCategoryTreeDto> courseCategoryTreeDtos = courseCategoryMapper.selectTreeNodes(id);


        //TODO 找到每个节点的子节点，最终封装成List
        //将list转map,以备使用,排除根节点
        Map<String, CourseCategoryTreeDto> mapTemp = courseCategoryTreeDtos.stream()
                //!id.equals(item.getId()) 含义就是排除根节点
                .filter(item -> !id.equals(item.getId()))
                .collect(
                        //转Map是需要一个key，一个value的
                        //第一个key是代表元素的意思，key -> key.getId()是拿到key元素的id，然后充当Map的key
                        //value表示对象的本身，所以不需要任何的处理
                        //(key1, key2) -> key2 表示当key重复的时候（键相同），以后来的key为主
                        Collectors.toMap(key -> key.getId(), value -> value, (key1, key2) -> key2)
                );

        //最终返回的list
        List<CourseCategoryTreeDto> categoryTreeDtos = new ArrayList<>();

        //依次遍历每个元素,排除根节点
        //courseCategoryTreeDtos是从数据库查询出来的全部的数据
        courseCategoryTreeDtos.stream().filter(item -> !id.equals(item.getId())).forEach(item -> {
            if (item.getParentid().equals(id)) {
                //紧挨根节点下的节点
                categoryTreeDtos.add(item);
            }
            //找到当前节点的父节点
            CourseCategoryTreeDto courseCategoryTreeDto = mapTemp.get(item.getParentid());
            if (courseCategoryTreeDto != null) {
                if (courseCategoryTreeDto.getChildrenTreeNodes() == null) {
                    courseCategoryTreeDto.setChildrenTreeNodes(new ArrayList<CourseCategoryTreeDto>());
                }
                //下边开始往ChildrenTreeNodes属性中放子节点
                courseCategoryTreeDto.getChildrenTreeNodes().add(item);
            }
        });
        return categoryTreeDtos;
    }

}
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

1.5 Controller

/**
 * 课程分类相关接口
 */
@Slf4j
@RestController
public class CourseCategoryController {


    @Autowired
    private CourseCategoryService courseCategoryService;

    @GetMapping("/course-category/tree-nodes")
    public List<CourseCategoryTreeDto> queryTreeNodes() {
        return courseCategoryService.queryTreeNodes("1");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1.6 效果图

二、添加课程

2.1 需求分析

将来这些信息都会存储到“course_base”表中

点击“添加课程”选项

点击添加课程，选择课程形式为录播

选择完毕，点击下一步，进入课程基本信息添加界面

本界面分两部分信息，一部分是课程基本信息上，一部分是课程营销信息。

课程基本信息

课程营销信息：

下面的信息会存储在course_market表中

也就是说一个表单中的数据要存储到两张表中

在这个界面中填写课程的基本信息、课程营销信息上。

填写完毕，保存并进行下一步

2.2 数据表

course_base、course_market两张表存储

两张表是一对一的关系，一个课程只有一个营销信息

并且两张表的主键id是相同的

2.2.1 课程基础信息表

course_base

/**
 * 课程基本信息
 */
@Data
@TableName("course_base")
public class CourseBase implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    /**
     * 机构ID
     */
    private Long companyId;

    /**
     * 机构名称
     */
    private String companyName;

    /**
     * 课程名称
     */
    private String name;

    /**
     * 适用人群
     */
    private String users;

    /**
     * 课程标签
     */
    private String tags;

    /**
     * 大分类
     */
    private String mt;

    /**
     * 小分类
     */
    private String st;

    /**
     * 课程等级
     */
    private String grade;

    /**
     * 教育模式(common普通，record 录播，live直播等）
     */
    private String teachmode;

    /**
     * 课程介绍
     */
    private String description;

    /**
     * 课程图片
     */
    private String pic;

    /**
     * 创建时间
     */
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createDate;

    /**
     * 修改时间
     */
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime changeDate;

    /**
     * 创建人
     */
    private String createPeople;

    /**
     * 更新人
     */
    private String changePeople;

    /**
     * 审核状态
     */
    private String auditStatus;

    /**
     * 课程发布状态 未发布  已发布 下线
     */
    private String status;
}

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

2.2.2 课程营销信息表

course_market

/**
 * 课程营销信息
 */
@Data
@TableName("course_market")
public class CourseMarket implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键，课程id
     */
    private Long id;

    /**
     * 收费规则，对应数据字典
     */
    private String charge;

    /**
     * 现价
     */
    private Float price;

    /**
     * 原价
     */
    private Float originalPrice;

    /**
     * 咨询qq
     */
    private String qq;

    /**
     * 微信
     */
    private String wechat;

    /**
     * 电话
     */
    private String phone;

    /**
     * 有效期天数
     */
    private Integer validDays;


}

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

2.3 交互类

2.3.1 AddCourseDto

价格信息存Float是没有问题的，但是计算的时候是有问题的，我们要使用BigDecimal

/**
 * @description 添加课程dto
 */
@Data
@ApiModel(value = "AddCourseDto", description = "新增课程基本信息")
public class AddCourseDto {

    @NotEmpty(message = "课程名称不能为空")
    @ApiModelProperty(value = "课程名称", required = true)
    private String name;

    @NotEmpty(message = "适用人群不能为空")
    @Size(message = "适用人群内容过少", min = 10)
    @ApiModelProperty(value = "适用人群", required = true)
    private String users;

    @ApiModelProperty(value = "课程标签")
    private String tags;

    @NotEmpty(message = "课程分类不能为空")
    @ApiModelProperty(value = "大分类", required = true)
    private String mt;

    @NotEmpty(message = "课程分类不能为空")
    @ApiModelProperty(value = "小分类", required = true)
    private String st;

    @NotEmpty(message = "课程等级不能为空")
    @ApiModelProperty(value = "课程等级", required = true)
    private String grade;

    @ApiModelProperty(value = "教学模式（普通，录播，直播等）", required = true)
    private String teachmode;

    @ApiModelProperty(value = "课程介绍")
    private String description;

    @ApiModelProperty(value = "课程图片", required = true)
    private String pic;

    @NotEmpty(message = "收费规则不能为空")
    @ApiModelProperty(value = "收费规则，对应数据字典", required = true)
    private String charge;

    @ApiModelProperty(value = "价格")
    private BigDecimal price;
    @ApiModelProperty(value = "原价")
    private BigDecimal originalPrice;


    @ApiModelProperty(value = "qq")
    private String qq;

    @ApiModelProperty(value = "微信")
    private String wechat;
    @ApiModelProperty(value = "电话")
    private String phone;

    @ApiModelProperty(value = "有效期")
    private Integer validDays;
}
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

2.3.2 CourseBaseInfoDto

添加成功之后我们查询出来的课程的详细信息

/**
 * @description 课程基本信息dto
 * 添加上课程信息后我们再查询返回的信息
 */
@Data
public class CourseBaseInfoDto extends CourseBase {


    /**
     * 收费规则，对应数据字典
     */
    private String charge;

    /**
     * 价格
     */
    private Float price;


    /**
     * 原价
     */
    private Float originalPrice;

    /**
     * 咨询qq
     */
    private String qq;

    /**
     * 微信
     */
    private String wechat;

    /**
     * 电话
     */
    private String phone;

    /**
     * 有效期天数
     */
    private Integer validDays;

    /**
     * 大分类名称
     */
    private String mtName;

    /**
     * 小分类名称
     */
    private String stName;

}
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

2.3 Mapper

/**
 * 课程基本信息 Mapper 接口
 */
public interface CourseBaseMapper extends BaseMapper<CourseBase> {

}
1
2
3
4
5
6

/**
 * 课程营销信息 Mapper 接口
 */
public interface CourseMarketMapper extends BaseMapper<CourseMarket> {

}
1
2
3
4
5
6

2.4 Service

2.5 Controller

    @ApiOperation("新增课程")
    @PostMapping("/course")
    public CourseBaseInfoDto createCourseBase(@Validated @RequestBody AddCourseDto addCourseDto) {
//      将来会集成SpringSecurity框架，用户登录之后就可以获取到用户所属机构的ID
//      先把机构ID写死
        return courseBaseInfoService.createCourseBase(10086L,addCourseDto);
    }
1
2
3
4
5
6
7

2.6 效果图

之后点击保存，这个时候会报错一个404，因为后面课程大纲的内容还没有编写

再查看数据库

再通过页面查看一下，还是挺带劲的

三、修改课程

涉及的表也是course_base课程基本信息表、course_market课程营销表

其实就是比添加课程多了一个数据回显而已

3.1 需求分析

点击编辑按钮就可以修改课程信息

要修改的表单内容其实是和添加课程时的表单是一个样子的

然后这个地方点击编辑的时候要做一个数据回显

修改课程的请求数据只是比添加课程的请求数据多了一个课程id而已

但是没有营销信息

3.2 数据回显

3.2.1 Service类

这个方法之前其实写过

    @Override
    public CourseBaseInfoDto getCourseBaseInfo(Long courseId){

        //TODO 查询课程基本信息
        CourseBase courseBase = courseBaseMapper.selectById(courseId);
        if(courseBase == null){
            return null;
        }
        //TODO 查询课程营销信息
        CourseMarket courseMarket = courseMarketMapper.selectById(courseId);
        CourseBaseInfoDto courseBaseInfoDto = new CourseBaseInfoDto();
        BeanUtils.copyProperties(courseBase,courseBaseInfoDto);
        if(courseMarket != null){
            BeanUtils.copyProperties(courseMarket,courseBaseInfoDto);
        }

        //TODO 查询分类名称，是哪一级的
        CourseCategory courseCategoryBySt = courseCategoryMapper.selectById(courseBase.getSt());//小分类
        courseBaseInfoDto.setStName(courseCategoryBySt.getName());//小分类名称

        CourseCategory courseCategoryByMt = courseCategoryMapper.selectById(courseBase.getMt());//大分类
        courseBaseInfoDto.setMtName(courseCategoryByMt.getName());//大分类名称

        return courseBaseInfoDto;

    }
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

3.2.2 Controller类

    @ApiOperation("根据课程id查询接口")
    @GetMapping("/course/{courseId}")
    public CourseBaseInfoDto getCourseBaseById(@PathVariable("courseId") Long courseId) {
        return courseBaseInfoService.getCourseBaseInfo(courseId);
    }
1
2
3
4
5

3.3 修改课程

3.3.1 修改课程Dto

修改课程的请求数据只比增加课程的请求数据多一个课程id

/**
 * 修改课程Dto
 */
@Data
@ApiModel(value = "EditCourseDto",description = "修改课程基本信息")
public class EditCourseDto extends AddCourseDto{

    @ApiModelProperty(value = "课程id",required = true)
    private Long id;
}

1
2
3
4
5
6
7
8
9
10
11

3.3.2 Service

    /**
     * 修改课程
     *
     * @param companyId     机构id，后面做认证收取那使用
     * @param editCourseDto 要修改的课程信息
     * @return 修改之后的课程详细信息
     */
    @Override
    public CourseBaseInfoDto updateCourseBase(Long companyId, EditCourseDto editCourseDto) {
        //TODO 课程基本信息
        //获取到课程id
        Long courseId = editCourseDto.getId();
        //查询课程
        CourseBase courseBase = courseBaseMapper.selectById(courseId);

        if (courseBase == null) {
            XueChengPlusException.cast("课程不存在");
        }
        //数据合法性校验
        //根据具体的业务逻辑进行校验 - 本机构只能修改本机构的课程
        if (!companyId.equals(courseBase.getCompanyId())) {
            XueChengPlusException.cast("本机构只能修改本机构的课程");
        }

        //封装数据
        BeanUtils.copyProperties(editCourseDto, courseBase);
        //修改时间
        courseBase.setChangeDate(LocalDateTime.now());
        //更新数据库
        int i = courseBaseMapper.updateById(courseBase);
        if (i<=0){
            XueChengPlusException.cast("修改课程失败");
        }

        //TODO 更新课程营销信息
        CourseMarket courseMarketNew = new CourseMarket();
        BeanUtils.copyProperties(editCourseDto, courseMarketNew);
        int count = courseMarketMapper.updateById(courseMarketNew);
        if (count <= 0) {
            throw new RuntimeException("更新课程营销信息失败");
        }

        //查询课程信息
        CourseBaseInfoDto courseBaseInfo = getCourseBaseInfo(courseId);

        return courseBaseInfo;
    }
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.3.3 Controller

    @ApiOperation("修改课程接口")
    @PutMapping("/course")
    public CourseBaseInfoDto getCourseBaseById(@RequestBody EditCourseDto editCourseDto) {

        //机构id先写死，后面授权认证的时候后会改过来
        Long companyId = 1232141425L;
        return courseBaseInfoService.updateCourseBase(companyId,editCourseDto);
    }
1
2
3
4
5
6
7
8

内容管理模块-课程分类、新增课程、修改课程

文章目录

一、课程分类

1.1 课程分类表

1.2 查询树形结构

1.2.1 表自连接

1.2.2 SQL递归

1.3 Mapper

1.4 Service

1.5 Controller

1.6 效果图

二、添加课程

2.1 需求分析

2.2 数据表

2.2.1 课程基础信息表

2.2.2 课程营销信息表

2.3 交互类

2.3.1 AddCourseDto

2.3.2 CourseBaseInfoDto

2.3 Mapper

2.4 Service

2.5 Controller

2.6 效果图

三、修改课程

3.1 需求分析

3.2 数据回显

3.2.1 Service类

3.2.2 Controller类

3.3 修改课程

3.3.1 修改课程Dto

3.3.2 Service

3.3.3 Controller

内容管理模块-课程分类、新增课程、修改课程

文章目录

一、课程分类

1.1 课程分类表

1.2 查询树形结构

1.2.1 表自连接

1.2.2 SQL递归

1.3 Mapper

1.4 Service

1.5 Controller

1.6 效果图

二、添加课程

2.1 需求分析

2.2 数据表

2.2.1 课程基础信息表

2.2.2 课程营销信息表

2.3 交互类

2.3.1 AddCourseDto

2.3.2 CourseBaseInfoDto

2.3 Mapper

2.4 Service

2.5 Controller

2.6 效果图

三、修改课程

3.1 需求分析

3.2 数据回显

3.2.1 Service类

3.2.2 Controller类

3.3 修改课程

3.3.1 修改课程Dto

3.3.2 Service

3.3.3 Controller

内容管理模块-课程分类、新增课程、修改课程

文章目录

一、课程分类

1.1 课程分类表

1.2 查询树形结构

1.2.1 表自连接

1.2.2 SQL递归

1.3 Mapper

1.4 Service

1.5 Controller

1.6 效果图

二、添加课程

2.1 需求分析

2.2 数据表

2.2.1 课程基础信息表

2.2.2 课程营销信息表