课程发布服务

/**
 * 课程预览
 */
@Data
public class CoursePreviewVO {

    // 课程基本信息, 营销信息
    private CourseBaseInfoVO courseBase;

    // 课程计划信息
    private List<TeachPlanVO> teachplans;
}

/**
 * <p>
 * 课程发布 服务类
 * </p>
 *
 * @author sw-code
 * @since 2023-08-18
 */
public interface CoursePublishService extends IService<CoursePublish> {

    /**
     * 获取课程预览信息
     *
     * @param courseId 课程ID
     * @return CoursePreviewVO 预览信息
     */
    public CoursePreviewVO getCoursePreviewInfo(Long courseId);

}

/**
 * <p>
 * 课程发布 服务实现类
 * </p>
 *
 * @author sw-code
 * @since 2023-08-18
 */
@Slf4j
@Service
public class CoursePublishServiceImpl extends ServiceImpl<CoursePublishMapper, CoursePublish> implements CoursePublishService {

    private final CourseBaseService courseBaseService;
    private final TeachPlanService teachPlanService;

    public CoursePublishServiceImpl(CourseBaseService courseBaseService, TeachPlanService teachPlanService) {
        this.courseBaseService = courseBaseService;
        this.teachPlanService = teachPlanService;
    }

    /**
     * 获取课程预览信息
     *
     * @param courseId 课程ID
     * @return CoursePreviewVO 预览信息
     */
    @Override
    public CoursePreviewVO getCoursePreviewInfo(Long courseId) {
        // 课程基本信息, 营销信息
        CourseBaseInfoVO courseBaseInfo = courseBaseService.getCourseBaseInfo(courseId);
        // 课程计划信息
        List<TeachPlanVO> teachPlans = teachPlanService.getTreeNodes(courseId);
        // 封装VO
        CoursePreviewVO previewVO = new CoursePreviewVO();
        previewVO.setCourseBase(courseBaseInfo);
        previewVO.setTeachplans(teachPlans);
        return previewVO;
    }
}

@Controller
public class CoursePublishController {

    private final CoursePublishService coursePublishService;

    public CoursePublishController(CoursePublishService coursePublishService) {
        this.coursePublishService = coursePublishService;
    }

    @GetMapping("/coursepreview/{courseId}")
    public ModelAndView preview(@PathVariable("courseId") @NotNull(message = "课程ID不能为空") Long courseId) {
        ModelAndView data = new ModelAndView();
        CoursePreviewVO previewInfo = coursePublishService.getCoursePreviewInfo(courseId);
        data.addObject("model", previewInfo);
        data.setViewName("course_template");
        return data;
    }
}

@RestController
@RequestMapping("/open")
public class CourseOpenController {

    private final CoursePublishService coursePublishService;

    public CourseOpenController(CoursePublishService coursePublishService) {
        this.coursePublishService = coursePublishService;
    }

    @GetMapping("/course/whole/{courseId}")
    public CoursePreviewVO preview(@PathVariable("courseId") @NotNull(message = "课程ID不能为空") Long courseId) {
        return coursePublishService.getCoursePreviewInfo(courseId);
    }

}

/**
 * 视频播放页面，openapi
 */

@RestController
@ResponseResult
@RequestMapping("/open")
public class MediaOpenController {

    private final MediaFilesService mediaFilesService;

    public MediaOpenController(MediaFilesService mediaFilesService) {
        this.mediaFilesService = mediaFilesService;
    }

    @GetMapping("/preview/{mediaId}")
    public R getPlayUrlByMediaId(@PathVariable("mediaId") String mediaId) {
        MediaFiles mediaFiles = mediaFilesService.getById(mediaId);
        if (mediaFiles == null || StringUtils.isEmpty(mediaFiles.getUrl())) {
            throw new BizException("视频还没有转码处理");
        }
        return R.success(mediaFiles.getUrl());
    }
}

/**
 * 提交审核
 * 将课程基本信息、课程计划信息和营销信息保存到预发布表
 *
 * @param companyId 机构ID
 * @param courseId  课程ID
 */
public void commitAudit(Long companyId, Long courseId);

/**
 * 提交审核
 * 将课程基本信息、课程计划信息和营销信息保存到预发布表
 *
 * @param companyId 机构ID
 * @param courseId  课程ID
 */
@Override
@Transactional(rollbackFor = Exception.class)
public void commitAudit(Long companyId, Long courseId) {
    // 查询课程基本信息
    CourseBase courseBase = Optional.ofNullable(courseBaseService.getById(courseId)).orElseThrow(() -> new BizException("课程信息不存在"));
    // 如果课程的审核状态为已提交则不允许提交
    if ("202003".equals(courseBase.getAuditStatus())) {
        throw new BizException("当前为等待审核状态，审核完成可以再次提交");
    }
    if (!courseBase.getCompanyId().equals(companyId)) {
        throw new BizException("不允许提交其它机构的课程");
    }
    // 课程的图片
    if (StringUtils.isEmpty(courseBase.getPic())) {
        throw new BizException("提交失败，请上传课程图片");
    }

    // 查询课程计划信息
    List<TeachPlanVO> teachPlans = teachPlanService.getTreeNodes(courseId);
    // 计划信息没有填写也不允许提交
    if (teachPlans.isEmpty()) {
        throw new BizException("提交失败，还没有添加课程计划");
    }

    // 查询营销信息
    CourseMarket courseMarket = Optional.ofNullable(courseMarketService.getById(courseId)).orElseThrow(() -> new BizException("请完善课程营销信息"));

    // 查询分类信息
    List<String> list = Arrays.asList(courseBase.getSt(), courseBase.getMt());
    String join = StringUtils.join(list, ",");
    List<CourseCategory> categories = courseCategoryService.list(Wrappers.<CourseCategory>lambdaQuery()
            .in(CourseCategory::getId, list).last("ORDER BY FIELD(id, '" + list.get(0) + "', '" + list.get(1) + "')"));

    // 查询课程基本信息、营销信息、计划等信息插入到课程预发布表
    CoursePublishPre coursePublishPre = new CoursePublishPre();
    // 设置分类名
    coursePublishPre.setStName(categories.get(0) == null ? "" : categories.get(0).getName());
    coursePublishPre.setMtName(categories.get(1) == null ? "" : categories.get(1).getName());
    BeanUtils.copyProperties(courseMarket, coursePublishPre);
    // 设置基本信息
    BeanUtils.copyProperties(courseBase, coursePublishPre);
    // 设置营销信息
    coursePublishPre.setMarket(JSON.toJSONString(courseMarket));
    // 设置课程计划
    coursePublishPre.setTeachplan(JSON.toJSONString(teachPlans));

    //设置预发布记录状态,已提交
    coursePublishPre.setStatus("202003");
    //教学机构id
    coursePublishPre.setCompanyId(companyId);
    //提交时间
    coursePublishPre.setCreateDate(LocalDateTime.now());

    // 保存预发布信息
    CoursePublishPre coursePublishPreUpdate = coursePublishPreService.getById(courseId);
    if (coursePublishPreUpdate == null) {
        //添加课程预发布记录
        coursePublishPreService.save(coursePublishPre);
    } else {
        coursePublishPreService.updateById(coursePublishPre);
    }

    //更新课程基本表的审核状态
    courseBase.setAuditStatus("202003");
    courseBaseService.updateById(courseBase);

}

@Api(value = "课程发布审核接口", tags = "课程发布审核接口")
@ResponseResult
@RestController
public class CoursePublishController {

    private final CoursePublishService coursePublishService;

    public CoursePublishController(CoursePublishService coursePublishService) {
        this.coursePublishService = coursePublishService;
    }

    @ApiOperation("提交审核")
    @PostMapping("/courseaudit/commit/{courseId}")
    public void commitAudit(@PathVariable("courseId") Long courseId) {
        Long companyId = 1232141425L;
        coursePublishService.commitAudit(companyId, courseId);
    }
}

/**
 * 发布课程
 *
 * @param companyId 机构ID
 * @param courseId  课程ID
 */
public void publish(Long companyId, Long courseId);

private final CoursePublishPreService coursePublishPreService;
private final CourseBaseService courseBaseService;
private final MqMessageService mqMessageService;

/**
 * 发布课程
 *
 * @param companyId 机构ID
 * @param courseId  课程ID
 */
@Override
@Transactional(rollbackFor = Exception.class)
public void publish(Long companyId, Long courseId) {
    // 查询预发布表
    CoursePublishPre coursePublishPre = Optional.ofNullable(coursePublishPreService.getById(courseId))
            .orElseThrow(() -> new BizException("未提交审核，不允许发布"));

    if (!coursePublishPre.getCompanyId().equals(companyId)) {
        throw new BizException("不允许发布其它机构的课程");
    }
    if (!coursePublishPre.getStatus().equals("202004")) {
        // 未通过审核
        throw new BizException("未通过审核，不允许发布");
    }
    // 向课程发布表写数据
    CoursePublish coursePublish = new CoursePublish();
    BeanUtils.copyProperties(coursePublishPre, coursePublish);
    // 查询是否有发布记录
    CoursePublish dbCoursePublish = getById(courseId);
    if (dbCoursePublish == null) {
        // 没有则新增
        save(coursePublish);
    } else {
        // 有则更新
        updateById(coursePublish);
    }

    // 更改文章状态为已经发布
    courseBaseService.update(Wrappers.<CourseBase>lambdaUpdate().eq(CourseBase::getId, courseId).set(CourseBase::getStatus, "203002"));

    // 向消息表写入数据
    saveCoursePublishMessage(courseId);

    // 删除预发布表数据
    coursePublishPreService.removeById(coursePublishPre);
}

/**
 * 保存消息记录
 *
 * @param courseId 课程id
 */
public void saveCoursePublishMessage(Long courseId) {
    // 使用消息SDK插入课程发布消息
    Optional.ofNullable(mqMessageService.addMessage("course_publish", String.valueOf(courseId), null, null))
            .orElseThrow(() -> new BizException("保存消息记录失败"));
}

@ApiOperation("课程发布")
@PostMapping("/coursepublish/{courseId}")
public void coursePublish(@PathVariable("courseId") Long courseId) {
    Long companyId = 1232141425L;
    coursePublishService.publish(companyId, courseId);
}

@Slf4j
@Configuration
public class XxlJonConfig {

    @Value("${xxl.job.admin.addresses}")
    private String adminAddresses;

    @Value("${xxl.job.executor.appname}")
    private String appname;

    @Value("${xxl.job.executor.address}")
    private String address;

    @Value("${xxl.job.executor.ip}")
    private String ip;

    @Value("${xxl.job.executor.port}")
    private int port;

    @Value("${xxl.job.accessToken}")
    private String accessToken;

    @Value("${xxl.job.executor.logpath}")
    private String logPath;

    @Value("${xxl.job.executor.logretentiondays}")
    private int logRetentionDays;


    @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {
        log.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appname);
        xxlJobSpringExecutor.setAddress(address);
        xxlJobSpringExecutor.setIp(ip);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        xxlJobSpringExecutor.setLogPath(logPath);
        xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);
        return xxlJobSpringExecutor;
    }
}

@Slf4j
@Service
public class CoursePublishTask extends MessageProcessAbstract {

    private final CoursePublishService coursePublishService;

    public CoursePublishTask(CoursePublishService coursePublishService) {
        this.coursePublishService = coursePublishService;
    }

    @XxlJob("CoursePublishJobHandler")
    public void coursePublishJobHandler() {
        // 分片参数
        int shardIndex = XxlJobHelper.getShardIndex();
        int shardTotal = XxlJobHelper.getShardTotal();

        // 执行任务
        this.process(shardIndex, shardTotal, "course_publish", 30, 60);

    }

    /**
     * 任务处理
     *
     * @param mqMessage 执行任务内容
     * @return boolean true:处理成功，false处理失败
     */
    @Override
    public boolean execute(MqMessage mqMessage) {
        if (StringUtils.isEmpty(mqMessage.getBusinessKey1())) {
            log.debug("消息参数错误，无业务ID: {}", mqMessage);
            return false;
        }
        long courseId = Long.parseLong(mqMessage.getBusinessKey1());

        // 生成并上传静态页面
        generateCourseHtml(mqMessage, courseId);
        // 创建索引
        saveCourseIndex(mqMessage, courseId);
        // 缓存至Redis
        save2Redis(mqMessage, courseId);
        return true;
    }

    /**
     * 生成静态化页面上传至文件系统
     *
     * @param mqMessage 消息
     * @param courseId  课程ID
     */
    private void generateCourseHtml(MqMessage mqMessage, long courseId) {
        Long taskId = mqMessage.getId();
        MqMessageService mqMessageService = this.getMqMessageService();
        // 任务幂等性处理
        int stageOne = mqMessageService.getStageOne(taskId);
        if (stageOne > 0) {
            log.debug("静态化页面已生成，无需处理");
            return;
        }
        // 生成静态页面
        // 上传静态页面
        // 置状态为已完成
        mqMessageService.completedStageOne(taskId);
    }

    /**
     * 保存课程索引到Elasticsearch
     *
     * @param mqMessage 消息
     * @param courseId  课程ID
     */
    private void saveCourseIndex(MqMessage mqMessage, long courseId) {
        Long taskId = mqMessage.getId();
        MqMessageService mqMessageService = this.getMqMessageService();
        // 任务幂等性处理
        int stageTwo = mqMessageService.getStageTwo(taskId);
        if (stageTwo > 0) {
            log.debug("课程索引已缓存，无需处理");
            return;
        }
		// 创建索引
        // 置状态为已完成
        mqMessageService.completedStageTwo(taskId);
    }
    
    /**
     * 缓存到Redis
     *
     * @param mqMessage 消息
     * @param courseId  课程ID
     */
    private void save2Redis(MqMessage mqMessage, long courseId) {
        Long taskId = mqMessage.getId();
        MqMessageService mqMessageService = this.getMqMessageService();
        // 任务幂等性处理
        int stageThree = mqMessageService.getStageThree(taskId);
        if (stageThree > 0) {
            log.debug("课程已缓存，无需处理");
            return;
        }
		// 保存到Redis
        // 置状态为已完成
        mqMessageService.completedStageThree(taskId);
    }
}

/**
 * 传输文件支持
 */
@Configuration
public class MultipartSupportConfig {

    private final ObjectFactory<HttpMessageConverters> messageConverters;

    public MultipartSupportConfig(ObjectFactory<HttpMessageConverters> messageConverters) {
        this.messageConverters = messageConverters;
    }

    @Bean
    @Primary//注入相同类型的bean时优先使用
    @Scope("prototype")
    public Encoder feignEncoder() {
        return new SpringFormEncoder(new SpringEncoder(messageConverters));
    }

    /**
     * 将file转为Multipart
     *
     * @param file 文件
     * @return MultipartFile
     */
    public static MultipartFile getMultipartFile(File file) {
        FileItem item = new DiskFileItemFactory().createItem("file", MediaType.MULTIPART_FORM_DATA_VALUE, true, file.getName());
        try (FileInputStream inputStream = new FileInputStream(file);
             OutputStream outputStream = item.getOutputStream();) {
            IOUtils.copy(inputStream, outputStream);

        } catch (Exception e) {
            e.printStackTrace();
        }
        return new CommonsMultipartFile(item);
    }

    /**
     * 将 输入流 转为Multipart
     *
     * @param inputStream 输入流
     * @param filename    文件名
     * @return MultipartFile
     */
    public static MultipartFile getMultipartFile(InputStream inputStream, String filename) {
        FileItem item = new DiskFileItemFactory().createItem("file", MediaType.MULTIPART_FORM_DATA_VALUE, true, filename);
        try (OutputStream outputStream = item.getOutputStream()) {
            IOUtils.copy(inputStream, outputStream);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return new CommonsMultipartFile(item);
    }
}

@ApiOperation("上传文件")
@PostMapping(value = "/coursefile", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
public UploadFileResultVO upload(@RequestPart("filedata") MultipartFile filedata,
                                      @RequestParam(value = "objectName", required = false) String objectName) {
    Long companyId = 1232141425L;
    UploadFileParamDTO dto = new UploadFileParamDTO();
    dto.setFilename(filedata.getOriginalFilename());
    dto.setFileSize(filedata.getSize());
    return mediaFilesService.uploadFile(companyId, dto, filedata, objectName);
}

/**
 * 上传文件
 *
 * @param companyId     机构ID
 * @param dto           文件信息
 * @param multipartFile 文件信息
 * @param objectName    文件路径
 * @return UploadFileResultVO
 */
public UploadFileResultVO uploadFile(Long companyId, UploadFileParamDTO dto, MultipartFile multipartFile, String objectName);

/**
 * 上传文件
 *
 * @param companyId     机构ID
 * @param dto           文件信息
 * @param multipartFile 文件信息
 * @param objectName    文件路径
 * @return UploadFileResultVO
 */
@Override
public UploadFileResultVO uploadFile(Long companyId, UploadFileParamDTO dto, MultipartFile multipartFile, String objectName) {
    ....;
    try {
        ...;
        // 已存在数据库，直接返回
        ....;
        // 获取文章类型
        String mineType = getMineType(suffix);
        if (mineType.contains("image")) {
            dto.setFileType("001001");
        } else {
            dto.setFileType("001003");
        }

        // 上传到MinIO
        Map<String, String> result = null;
        if (StringUtils.hasText(objectName)) {
            result = fileStorageService.uploadMediaFile(objectName, mineType, multipartFile.getInputStream());
        } else {
            result = fileStorageService.uploadMediaFile("", prefix + suffix, mineType, multipartFile.getInputStream());
        }
        
        ....;
        // 保存到数据库，使用编程式事务
        ....;
        // 返回数据
    	....;
    } catch (IOException e) {
        ....;
    }
}

/**
 * @param dirPath
 * @param filename yyyy/mm/dd/file.jpg
 * @return
 */
public String builderFilePath(String dirPath, String filename) {
    StringBuilder stringBuilder = new StringBuilder(50);
    if (!StringUtils.isEmpty(dirPath)) {
        stringBuilder.append(dirPath).append(separator);
    }
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
    String todayStr = sdf.format(new Date());
    stringBuilder.append(todayStr).append(separator);
    stringBuilder.append(filename);
    return stringBuilder.toString();
}

/**
 * 上传文件
 *
 * @param prefix      文件前缀
 * @param filename    文件名
 * @param inputStream 文件流
 * @return 文件全路径
 */
@Override
public Map<String, String> uploadMediaFile(String prefix, String filename, String mineType, InputStream inputStream) {
    String filepath = builderFilePath(prefix, filename);
    String bucket = upload2Files(filepath, mineType, inputStream);
    Map<String, String> map = new HashMap<>();
    map.put("path", filepath);
    map.put("bucket", bucket);
    return map;
}

/**
 * 上传文件
 *
 * @param objectName  文件路径
 * @param inputStream 文件流
 * @return 桶和文件全路径
 */
@Override
public Map<String, String> uploadMediaFile(String objectName, String mineType, InputStream inputStream) {
    String bucket = upload2Files(objectName, mineType, inputStream);
    Map<String, String> map = new HashMap<>();
    map.put("path", objectName);
    map.put("bucket", bucket);
    return map;
}

/**
 * 远程调用媒资服务
 */
@FeignClient(value = "media-api", configuration = MultipartSupportConfig.class, fallbackFactory = MediaServiceClientFallbackFactory.class)
public interface MediaServiceClient {

    /**
     * 文件传输
     *
     * @param filedata   文件
     * @param objectName MinIO路径
     * @return String
     */
    @PostMapping(value = "/media/upload/coursefile", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public String upload(@RequestPart("filedata") MultipartFile filedata,
                              @RequestParam(value = "objectName", required = false) String objectName);
}

// 注意别导错包
import org.springframework.cloud.openfeign.FallbackFactory;

/**
 * 降级方法，可以拿到异常信息
 */
@Slf4j
@Component
public class MediaServiceClientFallbackFactory implements FallbackFactory<MediaServiceClient> {

    @Override
    public MediaServiceClient create(Throwable throwable) {
        return new MediaServiceClient() {
            @Override
            public String upload(MultipartFile filedata, String objectName) {
                log.debug("远程调用媒资上传文件的接口发生熔断: ", throwable);
                return null;
            }
        };
    }
}

/**
 * 生成课程静态化页面
 *
 * @param courseId 课程ID
 * @return InputStream
 */
public InputStream generateCourseHtml(Long courseId);

/**
 * 上传课程静态化页面
 *
 * @param courseId    课程ID
 * @param inputStream 文件流
 */
public void uploadCourseHtml(Long courseId, InputStream inputStream);

/**
 * 查询已发布课程的信息
 *
 * @param courseId 课程ID
 * @return com.swx.content.model.po.CoursePublish 课程发布信息
 */
public CoursePreviewVO getCoursePublish(Long courseId);

private final static String COURSE_TEMPLATE = "course_template";
private final static String HTML_PATH = "course/";

/**
 * 生成课程静态化页面
 *
 * @param courseId 课程ID
 * @return File
 */
@Override
public InputStream generateCourseHtml(Long courseId) {
    try {
        Template template = configuration.getTemplate(COURSE_TEMPLATE + ".ftl");
        StringWriter out = new StringWriter();
        // 数据模型
        HashMap<String, Object> params = new HashMap<>();
        // 获取发布课程的信息，作为静态页面的参数
        params.put("model", getCoursePublish(courseId));
        // 文章内容通过freemarker生成html文件
        template.process(params, out);
        // 返回文件流
        return new ByteArrayInputStream(out.toString().getBytes());
    } catch (Exception e) {
        log.error("页面静态化出现问题", e);
    }
    return null;
}

/**
 * 上传课程静态化页面
 *
 * @param courseId    课程ID
 * @param inputStream 文件流
 */
@Override
public void uploadCourseHtml(Long courseId, InputStream inputStream) {
    // 把html文件上传到minio中
    MultipartFile multipartFile = MultipartSupportConfig.getMultipartFile(inputStream, courseId + COURSE_TEMPLATE + ".html");
    // Feign调用接口
    String upload = mediaServiceClient.upload(multipartFile, HTML_PATH + courseId + ".html");
    if (upload == null) {
        log.debug("上传结果为null, 课程ID: {}", courseId);
    }
}

/**
 * 查询已发布课程的信息
 *
 * @param courseId 课程ID
 * @return com.swx.content.model.po.CoursePublish 课程发布信息
 */
public CoursePreviewVO getCoursePublish(Long courseId) {
    CoursePublish coursePublish = getById(courseId);
    if (coursePublish == null) {
        throw new BizException("课程未发布");
    }
    CoursePreviewVO coursePreviewVO = new CoursePreviewVO();

    // 解析课程基本信息和营销信息
    CourseBaseInfoVO courseBaseInfoVO = new CourseBaseInfoVO();
    BeanUtils.copyProperties(coursePublish, courseBaseInfoVO);
    coursePreviewVO.setCourseBase(courseBaseInfoVO);

    // 解析课程计划信息
    List<TeachPlanVO> teachPlans = JSON.parseArray(coursePublish.getTeachplan(), TeachPlanVO.class);
    coursePreviewVO.setTeachplans(teachPlans);

    return coursePreviewVO;
}

/**
 * 生成静态化页面上传至文件系统
 *
 * @param mqMessage 消息
 * @param courseId  课程ID
 */
private void generateCourseHtml(MqMessage mqMessage, long courseId) {
    Long taskId = mqMessage.getId();
    MqMessageService mqMessageService = this.getMqMessageService();
    // 任务幂等性处理
    int stageOne = mqMessageService.getStageOne(taskId);
    if (stageOne > 0) {
        log.debug("静态化页面已生成，无需处理");
        return;
    }
    // 生成静态页面
    InputStream inputStream = coursePublishService.generateCourseHtml(courseId);
    if (inputStream == null) {
        return;
    }
    // 上传静态页面
    coursePublishService.uploadCourseHtml(courseId, inputStream);
    // 置状态为已完成
    mqMessageService.completedStageOne(taskId);

}

/**
 * 远程调用搜索服务
 * 新增索引
 */
@FeignClient(value = "search", fallbackFactory = SearchServiceClientFallbackFactory.class)
public interface SearchServiceClient {

    @PostMapping("/search/index/course")
    public Boolean add(@RequestBody CourseIndex courseIndex);
}

@Slf4j
@Component
public class SearchServiceClientFallbackFactory implements FallbackFactory<SearchServiceClient> {

    @Override
    public SearchServiceClient create(Throwable throwable) {
        return courseIndex -> {
            log.debug("远程调用搜索服务创建课程索引接口发生熔断: ", throwable);
            return false;
        };
    }
}

private final SearchServiceClient searchServiceClient;

/**
 * 保存课程索引到Elasticsearch
 *
 * @param mqMessage 消息
 * @param courseId  课程ID
 */
private void saveCourseIndex(MqMessage mqMessage, long courseId) {
    Long taskId = mqMessage.getId();
    MqMessageService mqMessageService = this.getMqMessageService();
    // 任务幂等性处理
    int stageTwo = mqMessageService.getStageTwo(taskId);
    if (stageTwo > 0) {
        log.debug("课程索引已缓存，无需处理");
        return;
    }
    // 查询课程
    CoursePublish coursePublish = coursePublishService.getById(courseId);
    CourseIndex courseIndex = new CourseIndex();
    BeanUtils.copyProperties(coursePublish, courseIndex);
    // 远程调用
    Boolean add = searchServiceClient.add(courseIndex);
    if (!add) {
        throw new BizException("添加课程索引失败");
    }
    // 置状态为已完成
    mqMessageService.completedStageTwo(taskId);
}

/**
 * 查询已发布课程的信息
 *
 * @param courseId 课程ID
 * @return com.swx.content.model.po.CoursePublish 课程发布信息
 */
public CoursePreviewVO getCoursePublish(Long courseId);

/**
 * 查询已发布课程的信息
 *
 * @param courseId 课程ID
 * @return com.swx.content.model.po.CoursePublish 课程发布信息
 */
@Override
public CoursePreviewVO getCoursePublish(Long courseId) {
    CoursePublish coursePublish = getById(courseId);
    if (coursePublish == null) {
        throw new BizException("课程未发布");
    }
    CoursePreviewVO coursePreviewVO = new CoursePreviewVO();

    // 解析课程基本信息和营销信息
    CourseBaseInfoVO courseBaseInfoVO = new CourseBaseInfoVO();
    BeanUtils.copyProperties(coursePublish, courseBaseInfoVO);
    coursePreviewVO.setCourseBase(courseBaseInfoVO);

    // 解析课程计划信息
    List<TeachPlanVO> teachPlans = JSON.parseArray(coursePublish.getTeachplan(), TeachPlanVO.class);
    coursePreviewVO.setTeachplans(teachPlans);

    return coursePreviewVO;
}

@ApiOperation("获取课程发布信息")
@GetMapping("/course/whole/{courseId}")
public CoursePreviewVO getCOursePublish(@PathVariable("courseId") @NotNull(message = "课程ID不能为空") Long courseId) {
    return coursePublishService.getCoursePublish(courseId);
}