今日重点

内容管理需求（第二层业务支持系统管理）：
内容管理概述： CMS 利用计算机技术，解决企业的数据管理！
比如：新闻媒体对新闻信息进行管理
物流对订单内容进行管理
本项目的内容管理主要是对课程内容进行管理，课程的录入，上传审核等等！
内容管理主体流程：
教育机构：  开始----> 添加课程和课程营销内容（课程基本信息，课程营销） ---> 添加课程计划（大纲） ----> 添加课程教师信息 --->结束
教育机构通过内容管理可以对课程内容、课程营销、课程计划、课程教师进行操作
学成在线： 分布式业务结构，将一个大业务，拆分成很多小业务来进行具体实现！
数据模型： 表结构
项目开发步骤说明（面试）
            项目基于前后的分离架构进行开发，前后端分离架构总体是包括前端和服务端，通常是多人协作并进行开发：
    1. 需求分析
      梳理用户需要，分析业务流程（思路以及项目业务很重要，对业务不懂 代码完成不了！）
  2. 接口定义
          根据上一步的基础下定义微服务接口，提供前端调用
    3.服务端和前端并行开发
          对业务接口进行开发，并自行使用工具测试（POSTMAN,JUNIT）
           前端开发用户操作界面，也会进行伪数据填充查看页面显示效果！
    4.前后端集成测试
          在前后的完成各自的开发后，对其整个业务进行前后端集成测试
课程查询接口业务说明：
接口业务需求：      
                   分页查询课程基本信息  多条件查询如果没有条件就查所有   课程机构只能查属于自己的课程(数据隔离)                                          
基于Http请求，响应json数据
接口规范说明：     
 查询 GET  添加POST 修改 PUT 删除 DELETE 
        前面动词集合，每个动词都有相对于规范的功能不可以乱用）
         后面url路径就不能写动词了（多个单词之间用 "-" 间隔开）尽量使用复数！
      qo（请求对象） Query  Object： 此包内主要放置前端传输的Requestbody对象方便后端接收！
     接口参数规范： 
     POST请求   ： 分页数据 QuerySting
               查询条件 RequestBody
         虽然查询数据按需求文档应该使用GET请求，但是多条件查询只有param传参是不满足我们的需求的，
         所以为了能够使用@RequestBody 接收前端传送的JSON格式的对象 只能使用带请求体的POST请求！
     请求对象封装命名：  Query+功能名称+model
     Response响应封装为Pagevo：       
                                 当前页       Page  
                  每页条数     Pagesize
                  总条数          counts        
                  当前页数据的集合   items           
nacos如何配置区分   ：   不同开发环境下的配置     namespace
      一个公司不同项目组   group
      一个项目不同工程     DataId
      同一环境下，同一个项目不同种类的配置  profile
nacos如何减少冗余配置：     使用公共配置          bootstrap.yml      share.config   公共的配置会优先读取，如果自己模块的配置文件也配置了相同的会覆盖掉公共的配置！   dateifd
数据传输返回对象的设置 ： 
POJO中是整个对应数据库表结构的，如果直接将查询出来的所有结果返回给前端是不安全的，并且前端如果不需要全部参数         
传输多余的参数也是会带来程序转换json时负担的，解决此问题 数据传输的实体类（entity）会单独定义，称为DTO  
 解决三个问题：
1.保护后端数据库的表字段 不直接暴露给前端完整的数据库结构
2.前端需要什么参数就给什么参数 （尽量避免资源的浪费）
3.数据量变小后转换JSON的效率就会大大提高！
DTO(Data Transfer Object，数据传送对象) 是一个普通的Java类，它封装了要传送的数据。当前端需要读取服务器端的数据的时候，服务器端将数据封装在DTO中，这样前端就可以获得它需要的所有数据。
MapStruct工具介绍：
    代码生成器，基于约定优于配置的方法简化java bean直接的属性映射，生成映射代码使用简单的方法调用！
     source（表对应对象属性）    target（DTO对应对象属性）  
    底层源代码实现也是基于get，set方法，如果要批量转换集合类型单个对象转换必须要有 因为集合转换是基于单个对象转换实现的，如果有多个属性名不一致可以使用@Mappers设置多个属性的映射关系！
机构隔离的依据数据获得：
教学机构 登陆后会带着令牌（存在用户本地浏览器） 
 放置在请求头中 key ：authorization  value：Bearer es。。。。
1.教育机构需要通过第三方登录系统完成登录操作。（会面课程会讲解并实现）
2.登录成功后会向教学机构的客户端保存一份token（令牌，相当于电影票）。
3.教学机构每次在使用前端系统访问后端微服务时都会将token以请求头的方式发送后端。
        请求头的key：authorization
        请求头的value：Bear ewogICAgImF1ZCI6IFsK..........
4.后端微服务接收到请求后需要从请求头中获得令牌，并解析后拿到教学机构的id值。
5.通过教学机构的id值来查询本公司下的课程数据，并返回结果。
关于1.mapper.xml 文件在本项目中为什么可以放到 src/main/java 路径下，而非resource目录下
MP的公共配置信息中做了配置设置！
什么是jsr，java 8日期
java 8 日期/时间 API 是 JSR-310 的实现，它的实现目标是克服旧的日期时间实现中所有的缺陷，新的日期/时 间 API 的一些设计原则是： 
不变性：新的日期/时间 API 中，所有的类都是不可变的，这对多线程环境有好处。
 关注点分离：新的 API 将人可读的日期时间和机器时间（unix timestamp）明确分离，它为日期（Date）、时间 （Time）、日期时间（DateTime）、时间戳（unix timestamp）以及时区定义了不同的类。
 清晰：在所有的类中，方法都被明确定义用以完成相同的行为。举个例子，要拿到当前实例我们可以使用 now()方法， 在所有的类中都定义了 format()和 parse()方法，而不是像以前那样专门有一个独立的类。为了更好的处理问题，
所有的类都使用了工厂模式和策略模式，一旦你使用了其中某个类的方法，与其他类协同工作并不困难。
 实用操作：所有新的日期/时间 API 类都实现了一系列方法用以完成通用的任务，如：加、减、格式化、解析、从 日期/时间中提取单独部分，等等。
 可扩展性：新的日期/时间 API 是工作在 ISO-8601 日历系统上的，但我们也可以将其应用在非 ISO 的日历上

1. 内容管理需求

1.1 内容管理概述

1. 内容管理是什么 ？
内容管理系统（content management system ），是协助组织和个人，借助信息技术，实现内容的创建、储存、分享、应用、检索，并在企业个人、组织、业务、战略等诸方面产生价值的过程 。能够支撑内容管理的一种工具或一套工具的软件系统。 不同的项目对内容的定位不同，比如：新闻媒体对新闻信息的管理，公司管理对公司内部数据内容管理、物流对订单内容管理等。
2. 本项目的内容管理系统定位是什么？
本项目作为一个大型的在线教育平台，其内容管理主要对课程相关内容进行管理，从课程数据的录入、课程审批、课程内容发布等内容性的业务需求数据进行管理。

1.2 业务介绍（背）

教育机构通过内容管理可以对课程内容、课程营销、课程计划、课程教师等操作，流程如下：

需求列表如下：
1、课程内容：包括课程的基本信息和课程营销。
2、课程计划：包括课程授课的主体大纲和关联的大纲的资料。
3、课程教师：包括课程授课的教师信息（课程不讲解，留作课程作业）。

1.3 业务流程

1.3.1 课程内容管理
1.教育机构用户在门户管理界面中的课程管理链接进入课程管理界面。

2.在管理界面中可以对课程进行列表查询和管理

3.添加课程时选在课程的类型

4 选择课程类型后，添加课程基本信息和课程营销数据

1.3.2 课程计划管理
1 对课程基本信息保存后，填写课程计划，如果课程有课程计划需要将其查询出来

2 对新课程没有课程计划，需要填写课程计划大章节

3 在课程计划大章节下填写课程小章节

1.3.3 课程教师管理
1 保存课程计划，对课程的教师进行管理，如果课程有教师信息需要查询出来,并对课程的教师进行管理

PS:课程中不会进行实现，需要学员自行完成。

1.4 内容管理数据模型

学成在线整个数据结构体系是不同的微服务操作不同的数据库中的内容，而内容管理在 MySQL 数据库里单独操作 xc_content 数据库，如下图：
学成在线数据结构图

针对内容管理的业务需求，xc_content 数据库中的表主要包含下面内容：
内容管理数据模型（表结构）

PS：后面功能实现时，设计到哪个表，我们在对表哪个表再详讲。

2. 项目的开发步骤（背）

学成在线项目是基于前后端分离的架构进行开发，前后端分离架构总体上包括前端和服务端，通常是多人协作并行开发，开发步骤如下：

1.需求分析

梳理用户的需求，分析业务流程。

2.接口定义

根据需求分析定义服务端微服务接口,提供前端调用。

3.服务端和前端并行开发

●服务端依据接口进行服务端接口开发（Java后端开发人员）。
○对业务接口进行开发
○开发完接口要对其进行测试
●前端开发用户操作界面，并调用服务端接口完成业务处理（全栈或前端开发人员）。
○使用前端技术完成前端界面的构建
○调用服务端来获取数据

4.前后端集成测试

●在前后端完成各自的开发后，对其整个业务进行前后端集成测试。

PS：在上面的前后端开发步骤中，我们Java后端开发人员只关心以下事项(一般)
●功能的业务流程和分析
●后端接口定义
●后端微服务的开发
●后端接口的测试
●前后端集成测试

3. 课程基础信息查询

学成在线第一个后端业务模块 ‘内容管理系统’ 中有不少的数据和业务，大家可以学习前后端开发中的后端微服务接口开发。从中学习数据库表结构和数据库表间的关系、后端微服务开发步骤，并能根据开发规范来编写代码操作。
下面我们来开发第一个功能 ：‘课程基本信息管理’ 中的 ‘课程基本信息查询接口’ 。

3.1 课程查询接口业务需求

在开发之前，我们按照前后端开发步骤，先进行 ‘课程基本信息查询接口’ 需求分析，本次定义查询接口，接口中需要供前端请求查询课程基本列表，支持分页及自定义条件查询方式。

3.1.1 接口业务需求

具体需求如下：
1、分页查询 课程基本信息（CourseBase）集合数据
2、根据课程名称和审核状态条件进行数据查询
3、教学机构只能查询到属于自己机构下的课程基本信息
4、接口基于Http 请求，响应Json数据
页面操作：
课程列表示例图

3.1.2 数据模型（表结构）

查询数据来源于数据库，从内容管理数据库（xc_content）中 course_base 表中查询数据，下面我们来创建数据库和数据库表结构，并了解表中结构。
1. 导入数据库数据
在今天下发资料里的数据脚本导入到本地 MySQL 数据中，资料位置在 ‘资料/数据库脚本/xc_content.sql’ 。
导入后的数据库内容

2. 课程基本信息表说明
下面我来分析下这张表的主要字段。
课程基本信息(course_base)表结构

●课程基本信息表分析
机构相关数据
课程基本信息是附属于一个教育架构下，学成在线主要是提供在线教学的平台。教学机构入驻后，在平台创建课程数据。
课程自身信息
对课程数据基本信息的描述，说明课程的教学模式、课程名称等。
课程数据操作数据
课程数据的操作会在相关字段进行记录，例如：课程数据的创建时间、课程数据的修改时间、课程数据的创建者等。
课程审核信息
教育结构创建出课程后，学成在线运营商需要对其进行数据审核，审核的操作也会进行记录，例如：审核人、审核时间等。

3.1.3 实体类 PO定义

对于数据库中的表来说，开发工程中会定义一个类来描述这张表的结构，这个类一般称之为 PO（persistent Object）持久对象。下面我们要创建出课程基本数据（course_base）表的 PO 类，创建出的位置在工程项目包结构位置：com.xuecheng.content.entity 。具体代码如下：
●课程基本信息 CourseBase实体类（MP 代码生成器生成）

package com.xuecheng.content.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import lombok.Data;
import com.baomidou.mybatisplus.annotation.TableName;
/**
 * <p>
 * 课程基本信息
 * </p>
 */
@Data
@TableName("course_base")
public class CourseBase implements Serializable {
    /**
     * 主键
     */
    @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 mtName;
    /**
     * 小分类
     */
    private String st;
    /**
     * 课程小类名称
     */
    private String stName;
    /**
     * 课程等级
     */
    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 auditMind;
    /**
     * 审核次数
     */
    private Integer auditNums;
    /**
     * 审核时间
     */
    private LocalDateTime auditDate;
    /**
     * 审核人
     */
    private String auditPeople;
    /**
     * 是否删除：1为未删除，0为删除
     */
    private Integer status;
    /**
     * 课程发布标识
     */
    private Long coursePubId;
}

3.2 课程查询接口定义

下面开始课程查询接口定义，在定义接口前，我们先来讨论接口定义的规范，在熟悉规范后再来定义查询接口。为什么要根据规范来定义接口呢？
前端调用接口示意图

前后端分离开发中，前端会根据后端微服务所提供的 HTTP 访问接口地址来获得数据并在前端页面展示，那么前后端的数据交互的格式和规范就显得尤为重要。前端需要传入哪些参数、请求的方式是哪种、获得的数据格式和内容等等，都需要前后端进行讨论并定出接口的规范。<br />    项目在开发时，为了控制代码风格和接口规范，一般对其进行限定并制作文档。如：xxx开发手册、xxx开发文档、xxx开发规范文档。

3.2.1 接口开发规范文档

参照 ‘项目开发规范文档.md — 接口开发规范’ 文档。

3.2.2 接口定义

1.接口参数列表
根据前后端传入参数列表来定义接口
Http接口地址

接口传入传出列表

2. 查询条件封装类创建
在 xc-api 工程的 com.xuecheng.api.content.model.qo 包下创建类，如下：
●课程条件查询类

package com.xuecheng.api.content.model.qo;
import lombok.Data;
/**
 * <p>
 *     课程基本信息查询条件封装 QO （query object）
 * </p>
 *
 * @Description: 根据课程名称、审核状态条件进行数据查询
 */
@Data
@ApiModel("课程基础信息查询QO对象")
public class QueryCourseModel {
    @ApiModelProperty("课程审核状态")
    private String auditStatus;
    @ApiModelProperty("课程名称")
    private String courseName;
}

3. 接口编写
在 xc-api 接口工程专门定义接口，在Api工程单独定义接口的原因如下：
1.接口集中管理
2.Api工程的接口将作为各微服务远程调用使用
在 com.xuecheng.api.content 包下创建接口类，页面查询接口定义如下：
●课程基本信息 Api 接口

package com.xuecheng.api.content;
import com.xuecheng.api.content.model.qo.QueryCourseModel;
import com.xuecheng.common.domain.page.PageRequestParams;
import com.xuecheng.common.domain.page.PageVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
/**
 * <p>
 *     课程基本信息Api接口
 * </p>
 *
 * @Description:
 */
@Api(value = "课程基本信息Api接口",tags = "内容-课程基本业务信息Api接口",description = "课程基本业务信息Api接口")
public interface CourseBaseApi {
    /**
     * 分页条件查询课程基本信息
     * @param params
     * @param model
     * @return
     */
    @ApiOperation("分页条件查询课程基本信息")
    PageVO queryCourseList(PageRequestParams params, QueryCourseModel model);
}

此接口编写后会在内容管理服务工程编写Controller类实现此接口。
4. 编写 Controller 控制层
在xc-content-service 的 controller 包下创建 CourseBaseController 接口，并实现 CourseBaseApi 接口，如下：

package com.xuecheng.content.controller;
import com.xuecheng.api.content.CourseBaseApi;
import com.xuecheng.api.content.model.qo.QueryCourseModel;
import com.xuecheng.common.domain.page.PageRequestParams;
import com.xuecheng.common.domain.page.PageVO;
import com.xuecheng.content.service.CourseBaseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
/**
 * <p>
 * 课程基本信息 前端控制器
 * </p>
 *
 * @author itcast
 */
@RestController
public class CourseBaseController implements CourseBaseApi {
    @Autowired
    private CourseBaseService  courseBaseService;
    @PostMapping("course/list")
    public PageVO queryCourseList(PageRequestParams params,
                                  @RequestBody QueryCourseModel model) {
        return null;
    }
}

3.2.3 接口数据传输

通过上面的代码编写，我们已经将 Controller 对外暴露 Http 请求接口并使用 Swagger 生成文档并测试通过，Service层也可调用 Mapper 获得数据库数据。最后只需要在 Controller 层调用 Service 方法便可以将整个业务员实现。虽然功能实现了，但问题也出现。
前后端数据交换示意图

从上图我们可以看到 DAO 从数据库取出的数据会封装到 PO 类对象中，而且 PO 类对象数据会以 Json 格式一直传送到前端，整个过程是将 PO 作为业务数据传输对象。这样传递数据会出现三个问题：<br />●问题一：假设数据库一张表的字段非常多，前端并非想获得一张表的全部字段值，只是获得关键的数据。<br />●问题二：数据库表字段越多，则 PO 中的属性就越多，从而导致 PO 对象转为 Json 时，由于字段多引起转换效率问题。<br />●问题三：PO 中的属性名称一般情况下会和数据库字段名称保持一致，前端获得 PO 中的数据，可能会暴露数据库字段名称。<br />上述问题解决方案：在微服务开发时，数据传输的实体类（entity）会单独定义，并称为 DTO。

3.2.3.1 数据传输对象
DTO(Data Transfer Object，数据传送对象) 是一个普通的Java类，它封装了要传送的数据。当前端需要读取服务器端的数据的时候，服务器端将数据封装在DTO中，这样前端就可以获得它需要的所有数据。
由于 DTO 中的属性都是前端所需要的。相比 PO 来说，属性会精简，这样在转换 Json 时，效率会好。
DTO 中的属性名称可以定义和 PO 属性名称不一致，这样前端工程获得 DTO 对象中的数据，其属性名称不一致，从而提高了应用的安全性。
DTO 数据传输示意图

1.课程数据传输对象定义
其实 DTO 为微服务提供对外的数据封装类，那么，DTO 实体类就会作为接口响应数据，要定义到基础工程 xc-api 中。
创建课程基本信息 DTO 位置

●课程基本信息 DTO 信息 PS：可以通过xc-mp-generator 来快速生成DTO数据。

package com.xuecheng.api.content.model;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
 * <p>
 *     课程基本信息数据传输实体类
 * </p>
 */
@Data
@ApiModel(value="CourseBaseDTO", description="课程基本信息DTO")
public class CourseBaseDTO implements Serializable {
    @ApiModelProperty(value = "courseBaseId")
    private Long courseBaseId;
    @ApiModelProperty(value = "机构Id")
    private Long companyId;
    @ApiModelProperty(value = "机构名称")
    private String companyName;
    @ApiModelProperty(value = "课程名称")
    private String name;
    @ApiModelProperty(value = "适用人群")
    private String users;
    @ApiModelProperty(value = "课程标签")
    private String tags;
    @ApiModelProperty(value = "大分类")
    private String mt;
    @ApiModelProperty(value = "大分类名称")
    private String mtName;
    @ApiModelProperty(value = "小分类")
    private String st;
    @ApiModelProperty(value = "小分类名称")
    private String stName;
    @ApiModelProperty(value = "课程等级")
    private String grade;
    @ApiModelProperty(value = "教育模式(common普通，record 录播，live直播等）")
    private String teachmode;
    @ApiModelProperty(value = "课程介绍")
    private String description;
    @ApiModelProperty(value = "课程图片")
    private String pic;
    @ApiModelProperty(value = "创建时间")
    private LocalDateTime createDate;
    @ApiModelProperty(value = "修改时间")
    private LocalDateTime changeDate;
    @ApiModelProperty(value = "审核状态：CourseAuditEnum")
    private String auditStatus;
    @ApiModelProperty(value = "审核意见")
    private String auditMind;
    @ApiModelProperty(value = "审核次数")
    private Integer auditNums;
    @ApiModelProperty(value = "审核时间")
    private LocalDateTime auditDate;
    @ApiModelProperty(value = "审核人")
    private String auditPeople;
}

上述代码解释：
1.已经将与前端业务无关的属性删除
2.其中 Id 的属性名称改为 courseId
PS：为数据安全性，DTO 中的属性名称可以和 PO 属性名称不一致。

3.3 课程查询接口开发

学成在线作为微服务后端的接口开发，也是有对应的开发规范文档。其中对命名规范、常量定义规范、注释、方法等都进行了一定的规范说明，代码要按照开发规范文档来进行开发后端。我们先来了解开发的规范，在去做接口开发。

3.3.1 代码开发规范文档

参照 ‘项目开发规范文档.md’ 文档。

3.3.2 微服务工程结构

1.微服务工程 xc-content-service
下面将在内容管理微服务进行开发查询功能。
内容管理微服务工程示例图

2. 工程结构
●包结构本工程为内容管理系统微服务，其包的结构为：
○基础包结构为：com.xuecheng.content
○控制层包：com.xuecheng.content.controller
○服务层包：com.xuecheng.content.service
○持久层：com.xuecheng.content.mapper
○配置文件：com.xuecheng.content.config
●启动类 在基础包结构下 Spring Boot 启动类

package com.xuecheng.content;
import com.spring4all.swagger.EnableSwagger2Doc;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
 * <p>
 *      内容管理启动类
 * </p>
 *
 * @Description:
 */
@EnableSwagger2Doc
@EnableApolloConfig
@SpringBootApplication
public class ContentApplication {
    public static void main(String[] args) {
        SpringApplication.run(ContentApplication.class);
    }
}

PS：启动类一定要放在基础包下。
3. 编写配置文件
●启动配置文件 application.yml 在 maven 的结构中的 src/main/resources 里创建。

#微服务配置
spring:
  application:
    name: content-service
  datasource:
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://ip:3306/xc_content?useUnicode=true&characterEncoding=utf8&useSSL=false
# MP 的配置信息
mybatis-plus:
  mapper-locations: classpath:com.xuecheng.content.mapper/*.xml  #加载 mybatis 映射文件的位置
# 日志文件配置路径
logging:
  config: classpath:log4j2-dev.xml
# swagger 文档配置
swagger:
  title: "学成在线内容管理系统"
  description: "内容系统管理系统对课程相关信息进行业务管理数据"
  base-package: com.xuecheng
  enabled: true
  version: 1.0.0

上面的配置文件主要信息包括三类：
1.微服务的基本信息
PS：数据库的配置以后有Nacos来管理，下面就有讲解。
2.MP配置
3.日志配置路径
4.swagger配置信息
PS：其他的配置会在配置中心 Nacos 中进行配置。

3.3.3 Nacos 多环境配置

1. Nacos 中的多环境
Nacos抽象定义了Namespace、Group、Data ID的概念，具体这几个概念代表什么，取决于我们把它们看成什么，这里推荐给大家一种用法，如下图：
●Namespace：代表不同环境，如开发、测试、生产环境。
●Group：代表某项目，如XX医疗项目、XX电商项目
●DataId：每个项目下往往有若干个工程，每个配置集(DataId)是一个工程的主配置文件
●profile: 在同一个环境下有不同的配置
下面我们需要在Nacos中创建内容：
①.在项目中我们需要创建出多个 Namespace 环境
②.指定组的名称
③.根据spring.application.name来指定Data Id 值

创建出多个 Namespace
创建 Namespace

指定环境的名称（开发环境）

指定环境的名称（正式环境）

在开发环境创建 groupid
在 dev 中创建配置

在配置中定义组名(xc-group)

2. 配置文件名称的命名
在项目的开发阶段，为了能够区分出不同环境下的配置，我们将使用 spring boot profile 来解决此问题。在Nacos中正好对此也进行了支持。下面是它的格式：

${prefix}-${spring.profiles.active}.${file-extension}

●prefix 默认为 spring.application.name 的值，也可以通过配置项 spring.cloud.nacos.config.prefix来配置。
●spring.profiles.active 即为当前环境对应的 profile
●file-extension 为配置内容的数据格式，可以通过配置项 spring.cloud.nacos.config.file-extension来配置。
内容管理配置文件的名称为：
①.content-service-dev.properties 开发环境（现阶段使用）
②.content-service-test.properties 测试环境
内容管理配置文件的名称

3.3.4 公共配置
考虑到 MP 的配置在开发阶段，很多服务都是通用的配置信息，所以需要配置公共信息，并在项目中引用，配置如下：
●MP 全局配置

#驼峰下划线转换
mybatis-plus.global-config.db-column-underline = true
#实体扫描，多个package用逗号或者分号分隔
mybatis-plus.typeAliasesPackage = com.xuecheng.*.entity
#字段策略 0:"忽略判断",1:"非 NULL 判断"),2:"非空判断"
mybatis-plus.global-config.field-strategy=2
#全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存，开发时不需要开启。
mybatis-plus.configuration.cache-enabled = false
#映射文件mapper文件存储位置
mybatis-plus.mapper-locations = classpath:com.xuecheng.*.mapper/*.xml
#主键类型  0:"数据库ID自增", 1:"用户输入ID",2:"全局唯一ID (数字类型唯一ID)", 3:"全局唯一ID UUID";
mybatis-plus.global-config.id-type = 0
#刷新mapper 调试神器
mybatis-plus.global-config.refresh-mapper = true

添加公共配置

添加mp公共配置信息

●添加 spring-http-config.properties 配置
spring-http-config.properties 配置信息

#srpingboot http 配置信息
spring.http.encoding.enabled = true
spring.http.encoding.charset = UTF-8
spring.http.encoding.force = true
server.use-forward-headers = true
server.servlet.context-path = /
server.port=8888

●添加 spring-druid-config.properties 配置
spring-druid-config.properties

#spring druid 配置信息
spring.datasource.driver-class-name = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://ip:3306/xc_content?userUnicode=true&useSSL=false&characterEncoding=utf8
spring.datasource.password = root
spring.datasource.username = root
#初始化连接池的的连接数据量
spring.datasource.druid.initial-size = 5
#连接池最小连接数 
spring.datasource.druid.min-idle = 5
#获取连接等待超时时间 
spring.datasource.druid.max-wait = 60000
# 要启用PreparedStatementCache,必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。
spring.datasource.druid.max-pool-prepared-statement-per-connection-size = 20
#连接池中最大激活连接数
spring.datasource.druid.max-active = 20

3.3.5 项目配置
在 Nacos 的 dev 命名空间 下 content-service-dev.properties 添加配置信息

#spring http 配置信息
server.servlet.context-path = /content
server.port=63040
#spring druid 配置信息
spring.datasource.url = jdbc:mysql://192.168.94.129:3306/xc_content?userUnicode=true&useSSL=false&characterEncoding=utf8

3.3.6 工程引用配置
对于 xc-content 引入 nacos 中的配置，我们需要在项目中创建 bootstrap.yml 文件，如下：

创建出后，需要在此配置文件中，配置下面的信息：<br />    1.nacos 的注册中心内容<br />    2.nacos 的配置中心内容<br />●添加配置信息

<!-- spring cloud nacos -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
<!-- druid 配置 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
</dependency>

●bootstrap.yml 配置

#微服务配置
spring:
  application:
    name: content-service
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.94.129:8848                 #注册中心nacos地址
        namespace: 修改为nacos dev 环境的id值              #dev环境的namespace配置
        group: ${dev.group}
      config:
        server-addr: 192.168.94.129:8848                 #配置中心nacos地址
        namespace: 修改为nacos dev 环境的id值              #dev环境的namespace配置
        file-extension: properties                       #文件的后缀名称
        group: ${dev.group}
        shared-configs:
          - dataId: mp-config.properties
            group: ${dev.group}
          - dataId: spring-http-config.properties
            group: ${dev.group}
          - dataId: spring-druid-config.properties
            group: ${dev.group}
  profiles:
    active: dev     #开启开发环境配置
#配置开发组的名称
dev:
  group: xc-group
# 日志文件配置路径
logging:
  config: classpath:log4j2-dev.xml
# swagger 文档配置
swagger:
  title: "学成在线内容管理系统"
  description: "内容系统管理系统对课程相关信息进行业务管理数据"
  base-package: com.xuecheng
  enabled: true
  version: 1.0.0

●启动类添加注解驱动

@RefreshScope            //开启动态刷新
@EnableDiscoveryClient   //开启注册中心
@EnableSwagger2Doc       //开启swagger
@SpringBootApplication   
public class ContentApplication {
    public static void main(String[] args) {
        SpringApplication.run(ContentApplication.class, args);
    }
}

**3.3.7 查询接口实现

3.3.7.1 DAO层代码实现
我们使用 Mybatis Plus来访问数据库，所有我们的 Mapper 会继承 MP 中的 BaseMapper接口。
●接口Mapper

package com.xuecheng.content.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.xuecheng.content.entity.CourseBase;
/**
 * <p>
 *     课程基本信息数据访问层
 * </p>
 *
 * @Description:
 */
public interface CourseBaseMapper extends BaseMapper<CourseBase> {
}

3.3.7.3 Service层代码实现
服务层代码的实现，需要我们先为服务层定义接口，接着再编写服务层实现类。实现类不仅实现我们编写的服务层接口，还会继承 MP 提供的 ServiceImpl 实现类，简化我们的开发。
1. 首先来编写 Service 接口，定义分页条件查询方法。
●Service接口定义

/**
 * <p>
 *      课程基本信息 服务类
 * </p>
 */
public interface CourseBaseService extends IService<CourseBase> {
    /**
     * 课程基础信息条件分页查询
     * @param params 分页数据
     * @param model 查询条件数据
     * @return PageVO
     */
    PageVO<CourseBaseDTO> queryCourseList(PageRequestParams params, QueryCourseModel model);
}

2. 编写服务实现类
服务实现类除了实现我们定义的接口，还可继承 MP 提供的 ServiceImpl 实现类。简化分页条件查询功能实现，我们先来实现分页并测试，在此基础上再去实现条件查询。
●分页查询实现 构建 MP 的分页组件，实现分页查询（项目中已经添加，无需添加）

package com.xuecheng.content.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;
/**
 * <p>
 *     Mybatis Plus 配置类
 * </p>
 *
 * @Description:
 */
@Configuration
@MapperScan("com.xuecheng.content.mapper")
public class MybatisConfig {
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

上述代码存放的包为：com.xuecheng.content.config，此包下资源会被程序加载。
PS：此配置类已经使用 @MapperScan 注解，Spring Boot 启动应用类上就不需要在添加此注解配置。
●Service实现类实现分页查询

package com.xuecheng.content.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xuecheng.api.content.model.dto.CourseBaseDTO;
import com.xuecheng.api.content.model.qo.QueryCourseModel;
import com.xuecheng.common.domain.page.PageRequestParams;
import com.xuecheng.common.domain.page.PageVO;
import com.xuecheng.common.util.StringUtil;
import com.xuecheng.content.convert.CourseBaseConvert;
import com.xuecheng.content.entity.CourseBase;
import com.xuecheng.content.mapper.CourseBaseMapper;
import com.xuecheng.content.service.CourseBaseService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.Collections;
import java.util.List;
/**
 * <p>
 * 课程基本信息 服务实现类
 * </p>
 *
 * @author itcast
 */
@Slf4j
@Service
public class CourseBaseServiceImpl extends ServiceImpl<CourseBaseMapper, CourseBase> implements CourseBaseService {
    /*
    * 步骤分析：
    *  1.是否需要开启事务
    *  2.判断关键数据
    *       分页数据
    *       查询条件
    *  3.构建mp分页对象
    *  4.构建查询条件对象LambdaQueryWrapper
    *  5.查询数据
    *  6.获得数据并封装返回结果
    *       封装PageVo数据
    * */
    public PageVO queryCourseBaseList(PageRequestParams params, QueryCourseModel model) {
        // 1.判断业务数据
        // 1.1 判断分页数据
        if (params.getPageNo() < 1) {
            params.setPageNo(PageRequestParams.DEFAULT_PAGE_NUM);
        }
        if (params.getPageSize() < 1) {
            params.setPageSize(PageRequestParams.DEFAULT_PAGE_SIZE);
        }
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        // 1.2 判断条件查询数据（如果查询条件有数据，在sql中添加条）
        // 完整版
        // if (StringUtil.isNotBlank(model.getAuditStatus())) {
        //     // 添加的审核状态条件（eq）
        //     queryWrapper.eq(CourseBase::getAuditStatus, model.getAuditStatus());
        // }
        //
        //
        //
        // if (StringUtil.isNotBlank(model.getCourseName())) {
        //     // 添加的课程名称条件（like）
        //     queryWrapper.like(CourseBase::getName, model.getCourseName());
        // }
        // 简写版
        queryWrapper.eq(StringUtil.isNotBlank(model.getAuditStatus()),
                CourseBase::getAuditStatus, model.getAuditStatus());
        queryWrapper.like(StringUtil.isNotBlank(model.getCourseName()),
                CourseBase::getName, model.getCourseName());
        // 2.创建分页数据
        Page<CourseBase> page = new Page<>(params.getPageNo(),params.getPageSize());
        // 3.根据分页和查询调价查询list数据
        Page<CourseBase> pageResult = this.page(page, queryWrapper);
        List<CourseBase> records = pageResult.getRecords();
        long total = pageResult.getTotal();
        // 4.将查询结果封装到PageVO中
        /*
        * PageVO构造方法：
        *   1.当前页的集合数据
        *   2.数据库中的总条数
        *   3.当前页码
        *   4.每页条数
        * */
        PageVO pageVO = new PageVO(records,total,params.getPageNo(),params.getPageSize());
        return pageVO;
    }
}

分页功能测试

@SpringBootTest
@RunWith(SpringRunner.class)
public class CourseServiceImplTest {
    @Autowired
    private CourseBaseService courseBaseService;
    @Test
    public void testQueryCourseList() {
        //1.分页数据
        PageRequestParams params = new PageRequestParams();
        params.setPageSize(10);
        //2.查询条件数据
        QueryCourseModel model = new QueryCourseModel();
        model.setCourseName("SpringBoot");
        // model.setAuditStatus(CourseAuditEnum.AUDIT_PASTED_STATUS.getCode());
        PageVO<CourseBaseDTO> result = courseBaseService.queryCourseList(params, model, 1L);
        System.out.println("result =>"+result.getItems());
        System.out.println("total =>" + result.getCounts());
    }
}

1.在 Maven 的测试目录下（src/test/java）创建测试类，位置不要放错。
2.测试类一定要放在工程的基础包或基础包子包下：com.xuecheng.content ，否则会出错。原因是测试代码会依赖 Spring Boot 启动类（ContentApplication）。

3.3.7.4 对象属性映射
DTO 解决了数据传输问题，但新的问题出现。问题在于 Service层要将获得的 PO 实体类对象中的属性赋值到 DTO 实体类对象中属性里。如果属性较多，则赋值操作越来越多。
赋值问题示意图

针对上面的问题，通过工具 包来解决此问题：MapStruct
（1） MapStruct 工具介绍
MapStruct是一个代码生成器，它基于约定优于配置的方法大大简化了Java Bean之间属性映射。 生成的映射代码使用简单的方法调用，因此速度快，类型安全且易于理解。 通过使其尽可能自动化来简化两个类对象属性转换代码。
MapStruct使用注解的形式在代码编译是生成类对象属性的转换赋值，可在 Maven项目中进行构建，通过生成代码完成繁琐和容易出错的代码逻辑。
官方地址：https://mapstruct.org/
（2） MapStruct 使用说明
在官方文档中，MapStruct 上手使用也是比较简单的，我们根据官方文档步骤来完成两个实体类属性值的映射赋值。
1. 导入 Maven 相关坐标 (项目工程已经导入，无需再导入)

<dependencies>
    <!-- MapStruct 依赖包 -->
    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct-jdk8</artifactId>
        <version>1.3.0.Final</version>
    </dependency>
    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct-processor</artifactId>
        <version>1.3.0.Final</version>
     </dependency>    
</dependencies>
<!-- maven 编译插件 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.7.0</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>utf-8</encoding>
            </configuration>
        </plugin>
    </plugins>
</build>

PS：这里的 pom 文件坐标导入和官网不太一样，这是由于项目中同时使用 MapStruct 和 Lombok，MapStruct 会影响到 Lombok 代码的自动生成，所有将 MapStruct 坐标进行改进。
2. 构建实体类
实体类我们用之前创建好的 CourseBase 和 CourseBaseDTO即可。
3. 编写映射接口
在内容管理微服务 xc-content-service 的基础包 xc.xuecheng.content.convert 下创建课程基本信息转换接口。

package com.xuecheng.content.convert;
import com.xuecheng.api.content.model.dto.CourseBaseDTO;
import com.xuecheng.content.entity.CourseBase;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
 * <p>
 *     对象属性转换器：
 *      PS：将MapStruct依赖添加到工程中
 *      1.创建一个接口并在类上添加 @Mapper 注解
 *      2.在接口通过MapStruct的api创建出接口的实例对象
 *      3.转换方法
 *          传入参数、传出参数
 *          将传入参数里的数据会赋值给传出参数
 *
 *      特点：
 *          1.对象中的属性转换数据时，默认情况下将两个对象中的同属性名进行赋值操作
 *
 * </p>
 *
 * @Description:
 */
@Mapper
public interface CourseBaseConvert {
    CourseBaseConvert INSTANCE = Mappers.getMapper(CourseBaseConvert.class);
    // 将po转为dto数据
    @Mapping(source = "id",target = "courseBaseId")
    CourseBaseDTO entity2dto(CourseBase courseBase);
    // 将pos转为dtos数据
    /*
    * 集合的方法会依赖于单个数据转换的方法
    *       entitys2dtos-》entity2dto
    *       Mapping注解是使用在单个数据转换方法上的，不是在集合方法上来使用
    * */
    List<CourseBaseDTO> entitys2dtos(List<CourseBase> courseBase);
}

编写接口时细节：
1.必须要接口上编写 @Mapper 注解，标注为 MapStruct 属性转换器（映射器）
2.构建类的属性转换器实例对象。
3.构建转换的方法，方法的传入的参数是需要转换源对象，方法的传出参数是需要转换为目标对象。
4.如果遇到两个类的属性名称不一致，需要使用 @Mapping 注解来进行说明。
@Mapping 中的 source 属性是要转换源对象属性名称
@Mapping 中的 target属性是要转换为目标对象的属性名称
上面的编写的接口，MapStruct 会在代码编译期生成接口的实现类。
4. 代码测试

public class MapStructTest {
    @Test
    public void convert() {
        CourseBase base = new CourseBase();
        base.setId(Long.valueOf(i));
        base.setName("SpringBoot");
        CourseBaseDTO dto = CourseBaseConvert.INSTANCE.entity2dto(base);
        System.out.println(dtos);
    }
}

上面代码要在 Maven 的测试目录下（src/test/java）创建测试类
（4）MapStruct 单实体类属性映射
上面我们演示了 MapStruct 工具单个实体类属性的使用，从 CourseBase 属性映射到 CourseBaseDTO 属性上。当然，从 CourseBaseDTO 属性映射到 CourseBase 上也是同样的道理，我们在转换接口中接着添加方法，如下:

@Mapper
public interface CourseBaseConvert {
    //上面代码忽略
    //将 CourseBaseDTO  转为  CourseBase
    CourseBase dto2entity(CourseBaseDTO dto);
}

MapStruct 只关心传入的源对象和传出的目标对象，上面代码测试请大家自行测试
上面的转换中，CourseBase 和 CourseBaseDTO 属性名称不一致，MapStruct 对此提供了 相应的注解来使得不同属性命名间转换赋值，注解分别为 ：@Mapping 和 @Mappings。
@Mapping 注解：是单个属性间的映射。
@Mappings注解：是多个属性间的映射。
●下面修改转换接口中的方法:

@Mapper
public interface CourseBaseConvert {
    //构建属性转换示例
    CourseBaseConvert INSTANCE = Mappers.getMapper(CourseBaseConvert.class);
    //将 CourseBase 转为  CourseBaseDTO
    @Mapping(target = "courseBaseId",source = "id")
    CourseBaseDTO entity2dTO(CourseBase courseBase);
    //将 CourseBaseDTO  转为  CourseBase
    @Mappings({
        @Mapping(target = "id",source = "courseBaseId")
    })
    CourseBase dto2entity(CourseBaseDTO student);
}

上面的修改就可以达到类对象间的多个不同属性名间的赋值操作，代码同学们自行测试。
（5） MapStruct 集合类属性映射
MapStruct 除了可以进行单个类对象间的属性转换（映射），还可以对集合类进行属性间的转换。下面我们将 CourseBase 集合转换为 CourseBaseDTO 集合。
首先我们在转换接口类中添加对应的方法：

/**
 * <p>
 *      课程基本信息 PO -- DTO 转换器
 * </p>
 *
 * @Description:
 */
@Mapper
public interface CourseBaseConvert {
    //构建属性转换示例
    CourseBaseConvert INSTANCE = Mappers.getMapper(CourseBaseConvert.class);
    //将 CourseBase 转为  CourseBaseDTO
    @Mapping(target = "courseBaseId",source = "id")
    CourseBaseDTO entity2DTO(CourseBase courseBase);
    //将 CourseBase 集合转为  CourseBaseDTO 集合
    List<CourseBaseDTO> entities2dtos(List<CourseBase> courseBases);
    // 其他代码略
}

这里我们在注意两点：
1.使用集合类的属性映射必须要在转换接口中编写单个类的属性转换方法。
2.在转换接口中的转换集合方法上无法识别 @Mapping 和 @Mappings
测试代码为:

public class MapStructTest {
    @Test
    public void convert() {
        List<CourseBase> bases = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            CourseBase base = new CourseBase();
            base.setId(Long.valueOf(i));
            base.setName("SpringBoot");
            bases.add(base);
        }
        List<CourseBaseDTO> dtos = CourseBaseConvert.INSTANCE.entitys2dtos(bases);
        System.out.println(dtos);
    }
}

}

3.3.7.5 完善后端服务代码
现在 MapStruct 工具和 DTO 有了基本的认识，我们将修改 Service 业务代码。
●使用 MapStruct 来转换属性

@Service
public class CourseBaseServiceImpl extends ServiceImpl<CourseBaseMapper, CourseBase> implements CourseBaseService {
    @Override
    public PageVO queryCourseBasesByConditions(Integer page, Integer size, QueryCourseBaseModel queryModel) {
        //.....其他代码省略
        // 4.分页条件查询
        IPage<CourseBase> pageResult = page(page, queryWrapper);
        List<CourseBase> list = pageResult.getRecords();
        long total = pageResult.getTotal();
        // 5.将 po 数据转换为
        List<CourseBaseDTO> dtos = Collections.emptyList();
        if (!(CollectionUtils.isEmpty(records))) {
             dtos = CourseBaseConvert.INSTANCE.entitys2dtos(records);
        }
        // 6.封装PageVO数据
        PageVO pageVO = new PageVO(dtos,total,params.getPageNo(),params.getPageSize());
        return pageVO;
    }
}

3.4 机构查询数据隔离

学成在线定位为 B2B2C 的产品，提供平台给教学机构来使用。但是，不同的教学机构查询的数据应该为自己机构下的数据，其他的教学机构的数据是无法查询出来的。
机构数据隔离示意图

上面的数据隔离，在学成在线中将通过下面的两个方面进行实现。
1.机构隔离的依据数据。
2.机构隔离的依据数据的获得。

3.4.1 机构隔离的依据数据

在课程基本信息表中有这么几个字段，如下：
课程信息机构内容

既然课程基本信息由判断不同机构的依据数据，那么在对课程基本信息查询时，只需要在查询条件中添加下面的数据即可：

select * from course_base where company_id = xxxxx and .....

通过sql来获得不同机构的数据。

3.4.2 机构隔离的依据数据获得

既然我们可以通过 course_base 中的 company_id 来区分不同机构的数据。那么下面就来讨论依据数据如何获得，下面是获得机构id(company_id) 示意图。
机构id数据获得示意图（面试）

学成采用的是前后端分离开发，教学机构在使用前端工程访问后端微服务时，需要做以下事：
1.教育机构需要通过第三方登录系统完成登录操作。（会面课程会讲解并实现）
2.登录成功后会向教学机构的客户端保存一份token（令牌，相当于电影票）。
3.教学机构每次在使用前端系统访问后端微服务时，都会将token以请求头的方式发送给后端。
请求头的key：authorization
请求头的value：Bear ewogICAgImF1ZCI6IFsK……….
4.后端微服务接收到请求后需要从请求头中获得令牌，并解析后拿到教学机构的id值。
5.通过教学机构的id值来操作一个机构下的课程数据。

3.4.3 测试环境的结构

对于机构隔离的依据数据获得和操作，需要搭建下面的测试环境，如下图：
学成测试环境搭建

根据上面的前后端结构图中可以看到，后端运行环境为使用 Spring Cloud 来进行管理 Spring Boot 微服务。
● 微服务注册中心
业务服务注册到服务注册中心中
● 微服务网关
1.接收所有前端发送的请求
2.从请求头中获得令牌内容，如果获得不到令牌将会报错。
3.将令牌转发到各个微服务中
● 业务微服
接收来自网关的请求，并从请求头中获得令牌，解析后获得机构的id
通过前后端测试环境结构图中，需要我们构建后端运行环境。根据服务结构顺序我们依次进行构建：
1. 微服务注册中心 Nacos
2. 业务服务注册到服务注册中心中
3. 微服务网关 GateWay

3.4.3.1 微服务注册中心
Nacos 已经在项目中搭建完毕，并可以将项目注册到 Nacos 中，无需再次配置。
注册服务

3.4.3.3 微服务网关搭建
前端与后端交互主要是和服务网关进行接口调用，通过网关将前端请求转发到各个业务后端微服务中，最终由网关远程调用业务微服务接口。

3.4.3.3.1 工程导入
将今天下发资料中的后端网关(xc-gateway-server)工程导入到 xc-parent 工程下。
工程项目

服务注册中心工程导入后，在 xc-parent 工程的 pom 文件中添加为模块
添加 module

3.4.3.3.2 工程运行
工程导入后，里面已经配置类 Spring Cloud 环境。由于此工程为测试环境下的网关，后期要进行更换，所以对里面的配置内容，不在强调。
运行后会自动注册到注册中心中

3.4.4 后端接口测试

教学机构需要在教学管理中心中进行登录后，前端在调用内容管理微服务时，除了传入业务参数，还需要在请求头中添加访问的令牌，微服务端需要解析令牌来获得机构相关的信息。
机构访问示意图

下面针对内容管理查询课程基础信息数据接口测试，需要做以下几件事情。
1.修改CourseBaseService接口，添加 companyId 参数
2.修改CourseBaseServiceImpl 实现类，添加对公司id查询条件
3.修改CourseBaseController，使用工具类获得公司Id值
4.通过测试工具发送请求给网关进行测试
1. 修改Service 层，添加对机构数据的判断条件
接口修改：

public interface CourseBaseService extends IService<CourseBase> {
    /**
     * 课程基本信息分页条件查询
     * @param params
     * @param model
     * @param companyId  添加公司Id参数
     * @return
     */
    PageVO<CourseBaseDTO> queryCourseList(PageRequestParams params, QueryCourseModel model,Long companyId);
}

业务实现类修改：

@Service
public class CourseBaseServiceImpl extends ServiceImpl<CourseBaseMapper,CourseBase> implements CourseBaseService {
    public PageVO queryCourseList(PageRequestParams params, QueryCourseModel model,Long companyId) {
        // 其他代码省略
        // 添加对公司的查询条件
        queryWrapper.eq(CourseBase::getCompanyId, companyId);
        // 4.分页条件查询
        IPage<CourseBase> pageResult = page(page, queryWrapper);
        List<CourseBase> list = pageResult.getRecords();
        long total = pageResult.getTotal();
        // 5.将 po 数据转换为
        List<CourseBaseDTO> dtos = Collections.emptyList();
        if (!(ObjectUtils.isEmpty(list) && list.size() > 0)) {
            dtos = CourseBaseConvert.INSTANCE.entity2dtos(list);
        }
        // 6.封装PageVO数据
        PageVO pageVO = new PageVO(dtos,total,params.getPageNo(),params.getPageSize());
        return pageVO;
    }
}

2. 修改Controller 层，并返回数据
●Controller调用Service方法

@Slf4j
@RestController
public class CourseBaseController implements CourseBaseApi {
    @Autowired
    private CourseBaseService  courseBaseService;
    @PostMapping("/course/list")
    public PageVO queryCourseList(PageRequestParams params,
                                  @RequestBody QueryCourseModel model) {
        //1.获得访问令牌并从中解析出机构的信息Id数据
        Long companyId = SecurityUtil.getCompanyId();
        //2.调用service层的方法
        PageVO<CourseBaseDTO> pageVo = courseBaseService.queryCourseList(params, model, companyId);
        return pageVo;
    }
}

PS：在Controller 代码中需要使用 xc-common 工程所提供的工具类 SecurityUtil 来从请求头中获得令牌数据，并解析后拿到公司id值。
3. 测试环境需要启动的服务
测试环境需要启动的微服务有：
1.注册中心 xc-discover-service （端口：63000）
2.服务网关 xc-gateway-service （端口：63010）
3.内容管理 xc-content-service （端口：63040）
4. 使用 postman 在请求信息中添加请求参数
测试环境搭建后，就不能通过 Swagger-ui 来测试内容管理微服务的接口。只能使用 postman 来发送请求到网关，具体需要提供下面的参数：
课程基本信息分页条件查询参数：
1.分页数据
通过QueryString(问号传参)方式来传递参数
2.查询条件
通过RequestBody(请求体中json格式数据)方式来传递参数
3.请求的令牌
通过请求头来传递令牌
●请求头（访问令牌）

请求头的 key 值： authorization
请求头的 value 值： 
Bearer ewogICAgImF1ZCI6IFsKICAgICAgICAieHVlY2hlbmctcmVzb3VyY2UiCiAgICBdLAogICAgInBheWxvYWQiOiB7CiAgICAgICAgIjExNzcxNDQyMDk0NjMxMjgxMjUiOiB7CiAgICAgICAgICAgICJyZXNvdXJjZXMiOiBbCiAgICAgICAgICAgIF0sCiAgICAgICAgICAgICJ1c2VyX2F1dGhvcml0aWVzIjogewogICAgICAgICAgICAgICAgInJfMDAxIjogWwogICAgICAgICAgICAgICAgICAgICJ4Y19jb21wYW55X21vZGlmeSIsCgkJCQkJInhjX2NvbXBhbnlfdmlldyIsCgkJCQkJInhjX2NvdXJzZV9iYXNlX2RlbCIsCgkJCQkJInhjX2NvdXJzZV9iYXNlX2VkaXQiLAoJCQkJCSJ4Y19jb3Vyc2VfYmFzZV9saXN0IiwKCQkJCQkieGNfY291cnNlX2Jhc2Vfc2F2ZSIsCgkJCQkJInhjX2NvdXJzZV9iYXNlX3ZpZXciLAoJCQkJCSJ4Y19jb3Vyc2VfcHVibGlzaCIsCgkJCQkJInhjX21hcmtldF9zYXZlX21vZGlmeSIsCgkJCQkJInhjX21hcmtldF92aWV3IiwKCQkJCQkieGNfbWVkaWFfZGVsIiwKCQkJCQkieGNfbWVkaWFfbGlzdCIsCgkJCQkJInhjX21lZGlhX3ByZXZpZXciLAoJCQkJCSJ4Y19tZWRpYV9zYXZlIiwKCQkJCQkieGNfdGVhY2hlcl9saXN0IiwKCQkJCQkieGNfdGVhY2hlcl9tb2RpZnkiLAoJCQkJCSJ4Y190ZWFjaGVyX3NhdmUiLAoJCQkJCSJ4Y193b3JrcmVjb3JkX2NvcnJlY3Rpb24iLAoJCQkJCSJ4Y193b3JrcmVjb3JkX2xpc3QiLAoJCQkJCSJ4Y190ZWFjaHBsYW53b3JrX2RlbCIsCgkJCQkJInhjX3RlYWNocGxhbndvcmtfbGlzdCIsCgkJCQkJInhjX3RlYWNocGxhbndvcmtfc2F2ZV9tb2RpZnkiLAoJCQkJCSJ4Y190ZWFjaHBsYW5fZGVsIiwKCQkJCQkieGNfdGVhY2hwbGFuX3NhdmVfbW9kaWZ5IiwKCQkJCQkieGNfdGVhY2hwbGFuX3ZpZXciCiAgICAgICAgICAgICAgICBdLAogICAgICAgICAgICAgICAgInJfMDAyIjogWwogICAgICAgICAgICAgICAgICAgICJ4Y19jb3Vyc2VfYWRtaW5fbGlzdCIsCgkJCQkJInhjX2NvdXJzZV9iYXNlX2NvbW1pdCIsCgkJCQkJInhjX3N5c3RlbV9jYXRlZ29yeSIsCgkJCQkJInhjX21fbWVkaWFfbGlzdCIsCgkJCQkJInhjX21lZGlhX2F1ZGl0IgogICAgICAgICAgICAgICAgXQogICAgICAgICAgICB9CiAgICAgICAgfQogICAgfSwKICAgICJ1c2VyX25hbWUiOiAieGMtdXNlci1maXJzdCIsCiAgICAic2NvcGUiOiBbCiAgICAgICAgInJlYWQiCiAgICBdLAogICAgIm1vYmlsZSI6ICIxNTAxMjM0NTY3OCIsCiAgICAiZXhwIjogMTYwNjUyNTEyMiwKICAgICJjbGllbnRfYXV0aG9yaXRpZXMiOiBbCiAgICAgICAgIlJPTEVfVVNFUiIKICAgIF0sCiAgICAianRpIjogIjFlYjdlOTg3LWQ3YzItNDBmNS1iMGQ2LWNkNjEzOWNiMThlMCIsCiAgICAiY2xpZW50X2lkIjogInhjLWNvbS1wbGF0Zm9ybSIsCiAgICAiY29tcGFueUlkIjogMTIzMjE0MTQyNQp9

●QueryString 信息（分页参数）

......?pageNo=1&pageSize=5

请求体信息（查询条件参数）

{
    "auditStatus":"202004",
    "courseName":"springboot"
}

示意图

3.5 功能接口实现小结

通过上面课程基本信息查询，我们将开发中重点的内容进行知识总结，这对后期的开发有很大的帮助。
3.3.10.1 开发规范小结
本次开发中设计到的规范，大致有分为两类，分别为：
1.开发代码规范
项目的功能实现编码，要根据开发规范文档来统一风格，这样利于代码可读性和后期的代码维护。
2.接口开发规范
前后端分离开发，遵循接口开发规范，便于多人协作并行开发。
3.3.10.2 开发步骤小结
学成在线项目是基于前后端分离的架构，其后端开发会按照一定的步骤来进行功能实现。其中 Java 后端开发人员只关心以下事项：
1.功能的需求分析
2.后端接口定义
3.后端微服务的开发
4.后端接口的测试
5.前后端集成测试
3.3.10.3 接口封装实体类小结
在前后端开发中，对于接口中的数据封装类，在本次的开发中使用相应的实体来进行接收和返回数据。
大致的实体为：
1.接收数据封装实体类
对于有查询条件的接口，对查询数据进行封装。
条件查询数据： Query*Model 为名称来定义查询实体类。
分页数据：使用工程中提供的 PageRequestParams 实体类封装分页数据。
2.传出数据封装实体类
微服务端对于接收前端的核心数据，会使用 *DTO 数据来进行数据传出。在后端使用工具 MapStruct 工具在Service层将 DTO 数据转为 PO 类数据。
3.3.10.4 后端获得登录状态信息小结
教学机构在教学管理中心登录后，前端调用后端接口的时候，会在请求都中添加下面列表中访问令牌，工程中的工具类 SecurityUtil 可以直接获得请求头中的内容，并解析访问令牌获得机构信息和用户信息。
机构访问示意图

| 请求头的Key

| 请求头的Value

| | —- | —- | | authorization

| Bearer eyJtZXJjaGFudElkIjoiMTIz…………

|

1