自媒体后台管理

@SpringBootApplication
@EnableDiscoveryClient
@MapperScan("com.swx.wemedia.mapper")
public class WemediaApplication {
    public static void main(String[] args) {
        SpringApplication.run(WemediaApplication.class, args);
    }
}

public class CodeGenerate {
    public static void OnMac() {
        // 代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        gc.setAuthor("sw-code");
        gc.setOpen(false); // 是否打开文件资源管理器
        gc.setFileOverride(true); // 是否覆盖
        gc.setServiceName("%sService"); // 去Service的I前缀
        gc.setSwagger2(false); // 实体属性 Swagger2 注解
        gc.setIdType(IdType.AUTO); // 主键策略
        gc.setDateType(DateType.ONLY_DATE); // 定义生成的实体类中日期类型
        mpg.setGlobalConfig(gc);

        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql:///leadnews_wemedia?useSSL=false&serverTimezone=UTC&characterEncoding=utf-8&nullCatalogMeansCurrent=true");
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("xxxxxx");
        mpg.setDataSource(dsc);

        /*
         * 包配置
         * 简单来讲 就是写绝对路径
         */
        PackageConfig pc = new PackageConfig();
        //  pc.setModuleName("code");
        pc.setParent("com.swx");
        //指定生成文件的绝对路径
        Map<String, String> pathInfo  = new HashMap<>();
        String packageName = "wemedia";
        String parentPath = "/src/main/java/com/swx";
        String otherPath ="/leadnews-service/leadnews-wemedia/src/main/java/com/swx/" + packageName;

        String entityPackageName = "wemedia";
        pc.setEntity("model." + entityPackageName + ".pojo");
        pc.setMapper(packageName + ".mapper");
        pc.setService(packageName + ".service");
        pc.setServiceImpl(packageName + ".service.impl");
        pc.setController(packageName + ".controller.v1");

        String entityPath = projectPath.concat("/leadnews-model").concat(parentPath).concat("/model/" + entityPackageName + "/pojo");
        String mapper_path = projectPath.concat(otherPath).concat("/mapper");
        String mapper_xml_path = projectPath.concat("/leadnews-service/leadnews-wemedia").concat("/src/main/resources/mapper");
        String service_path = projectPath.concat(otherPath).concat("/service");
        String service_impl_path = projectPath.concat(otherPath).concat("/service/impl");
        String controller_path = projectPath.concat(otherPath).concat("/controller/v1");

        pathInfo.put("entity_path",entityPath);
        pathInfo.put("mapper_path",mapper_path);
        pathInfo.put("xml_path",mapper_xml_path);
        pathInfo.put("service_path",service_path);
        pathInfo.put("service_impl_path",service_impl_path);
        pathInfo.put("controller_path",controller_path);
        pc.setPathInfo(pathInfo);
        mpg.setPackageInfo(pc);

        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("wm_user");
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setEntityLombokModel(true);
        // 字段注解
        strategy.setEntityTableFieldAnnotationEnable(true);
        strategy.setRestControllerStyle(true);
        strategy.setControllerMappingHyphenStyle(true);
        mpg.setStrategy(strategy);

        mpg.execute();
    }

    public static void main(String[] args) {
        OnMac();
    }
}

@Data
public class WmLoginDTO {
    private String name;
    private String password;
}

public interface WmUserService extends IService<WmUser> {

    /**
     * 自媒体端登录
     * @param dto   参数：用户名和密码
     * @return  用户信息
     */
    public Map<String,Object> login(WmLoginDTO dto);
}

public class WmUserServiceImpl extends ServiceImpl<WmUserMapper, WmUser> implements WmUserService {

    @Override
    public Map<String,Object> login(WmLoginDTO dto) {
        //1.检查参数
        if(StringUtils.isBlank(dto.getName()) || StringUtils.isBlank(dto.getPassword())){
            throw new BizException(ResultCodeEnum.PARAM_INVALID.code(), "用户名或密码为空");
        }

        //2.查询用户
        WmUser wmUser = getOne(Wrappers.<WmUser>lambdaQuery().eq(WmUser::getName, dto.getName()));
        if(wmUser == null){
            throw new BizException(ResultCodeEnum.DATA_NOT_EXIST);
        }

        //3.比对密码
        String salt = wmUser.getSalt();
        String pswd = dto.getPassword();
        pswd = DigestUtils.md5DigestAsHex((pswd + salt).getBytes());
        if(pswd.equals(wmUser.getPassword())){
            //4.返回数据  jwt
            Map<String,Object> map  = new HashMap<>();
            map.put("token", AppJwtUtil.getToken(wmUser.getId().longValue()));
            wmUser.setSalt("");
            wmUser.setPassword("");
            map.put("user",wmUser);
            return map;
        }else {
            throw new BizException(ResultCodeEnum.LOGIN_PWD_ERROR);
        }
    }
}

/**
 * <p>
 * 自媒体用户信息表 前端控制器
 * </p>
 *
 * @author sw-code
 * @since 2023-08-06
 */
@RestController
@ResponseResult
@RequestMapping("/login")
public class LoginController {

    private final WmUserService wmUserService;

    public LoginController(WmUserService wmUserService) {
        this.wmUserService = wmUserService;
    }

    @PostMapping("/in")
    public Map<String, Object> login(@RequestBody WmLoginDTO dto) {
        return wmUserService.login(dto);
    }
}

// 获取用户信息
Object userId = claimsBody.get("id");
ServerHttpRequest serverHttpRequest = request.mutate().headers(httpHeaders -> {
    httpHeaders.add("userId", userId + "");
}).build();
// 重置请求
exchange.mutate().request(serverHttpRequest);

public class WmTokenInterceptor implements HandlerInterceptor {

    /**
     * 获取header中的用户信息，并且存入到当前线程中
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String userId = request.getHeader("userId");
        if (userId != null) {
            // 存入到当前线程中
            IdThreadUtil.setId(Long.valueOf(userId));
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        IdThreadUtil.clear();
    }
}

package com.swx.utils.thread;

public class IdThreadUtil {

    private final static ThreadLocal<Long> USER_ID_THREAD_LOCAL = new ThreadLocal<>();

    public static void setId(Long userId) {
        USER_ID_THREAD_LOCAL.set(userId);
    }

    // 从线程中获取
    public static Long getId() {
        return USER_ID_THREAD_LOCAL.get();
    }

    // 清理
    public static void clear() {
        USER_ID_THREAD_LOCAL.remove();
    }
}

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new WmTokenInterceptor())
            .addPathPatterns("/**");
    }
}

public interface WmMaterialService extends IService<WmMaterial> {

    /**
     * 图片上传
     *
     * @param multipartFile 文件信息
     * @return
     */
    public WmMaterial uploadPicture(MultipartFile multipartFile);

}

@Slf4j
@Service
public class WmMaterialServiceImpl extends ServiceImpl<WmMaterialMapper, WmMaterial> implements WmMaterialService {

    private final FileStorageService fileStorageService;

    public WmMaterialServiceImpl(FileStorageService fileStorageService) {
        this.fileStorageService = fileStorageService;
    }

    /**
     * 图片上传
     *
     * @param multipartFile 文件信息
     * @return
     */
    @Override
    public WmMaterial uploadPicture(MultipartFile multipartFile) {
        // 参数校验
        if (multipartFile == null || multipartFile.getSize() == 0) {
            throw new BizException(ResultCodeEnum.PARAM_INVALID);
        }

        // 上传图片到minIO中
        String filename = UUID.randomUUID().toString().replace("-", "");
        String originalFilename = multipartFile.getOriginalFilename();
        String prefix = originalFilename.substring(originalFilename.lastIndexOf("."));
        String fileId = null;
        try {
            fileId = fileStorageService.uploadImgFile("", filename + prefix, multipartFile.getInputStream());
            log.info("上传图片到MinIO中，fileId: {}", fileId);
        } catch (IOException e) {
            e.printStackTrace();
            log.info("WmMaterialServiceImpl-上传文件失败");
        }

        // 保持到数据库中
        WmMaterial wmMaterial = new WmMaterial();
        // 获取userId
        wmMaterial.setUserId(IdThreadUtil.getId().intValue());
        wmMaterial.setUrl(fileId);
        wmMaterial.setIsCollection((short)0);
        wmMaterial.setType(0);
        wmMaterial.setCreatedTime(new Date());
        save(wmMaterial);

        return wmMaterial;

    }
}

@RestController
@ResponseResult
@RequestMapping("/api/v1/material")
public class WmMaterialController {

    private final WmMaterialService wmMaterialService;

    public WmMaterialController(WmMaterialService wmMaterialService) {
        this.wmMaterialService = wmMaterialService;
    }

    @PostMapping("/upload_picture")
    public WmMaterial uploadPicture(MultipartFile multipartFile) {
        return wmMaterialService.uploadPicture(multipartFile);
    }

}

/**
 * 素材列表查询
 *
 * @param dto 参数
 */
public PageR findList(WmMaterialDTO dto);

/**
 * 素材列表查询
 *
 * @param dto 参数
 */
@Override
public PageR findList(WmMaterialDTO dto) {
    // 检查参数
    dto.checkParam();

    // 分页查询
    IPage<WmMaterial> page = new Page<>(dto.getPage(), dto.getSize());
    LambdaQueryWrapper<WmMaterial> wrapper = new LambdaQueryWrapper<>();
    if (dto.getIsCollection() != null && dto.getIsCollection() == 1) {
        wrapper.eq(WmMaterial::getIsCollection, dto.getIsCollection());
    }

    // 安装用户查询
    wrapper.eq(WmMaterial::getUserId, IdThreadUtil.getId()).orderByDesc(WmMaterial::getCreatedTime);
    page = page(page, wrapper);

    PageR pageR = new PageR(dto.getPage(), dto.getSize(), (int) page.getTotal());
    pageR.setData(page.getRecords());
    return pageR;
} 

@PostMapping("/list")
public PageR findList(@RequestBody WmMaterialDTO dto) {
    return wmMaterialService.findList(dto);
}

@RestController
@ResponseResult
@RequestMapping("/api/v1/channel")
public class WmChannelController {

    private final WmChannelService wmChannelService;

    public WmChannelController(WmChannelService wmChannelService) {
        this.wmChannelService = wmChannelService;
    }

    @GetMapping("/channels")
    public List<WmChannel> findAll() {
        return wmChannelService.list();
    }

}

@Alias("WmNewsStatus")
public enum Status {
    NORMAL((short) 0, "草稿"),
    SUBMIT((short) 1, "提交（待审核）"),
    FAIL((short) 2, "审核失败"),
    ADMIN_AUTH((short) 3, "人工审核"),
    ADMIN_SUCCESS((short) 4, "人工审核通过"),
    SUCCESS((short) 8, "审核通过（待发布）"),
    PUBLISHED((short) 9, "已发布");
    short code;
    String desc;
    Status(short code, String desc) {
        this.code = code;
    }
    public short getCode() {
        return this.code;
    }
}

@Data
@EqualsAndHashCode(callSuper = true)
public class WmNewsPageReqDTO extends PageDTO {

    /**
     * 状态
     */
    private Short status;

    /**
     * 开始时间
     */
    private Date beginPubData;

    /**
     * 结束时间
     */
    private Date endPubData;

    /**
     * 所属频道
     */
    private Integer channelId;

    /**
     * 关键字
     */
    private String keyword;
}

/**
 * 条件查询文章列表
 * @param dto 查询条件
 * @return 分页信息
 */
public PageR findList(WmNewsPageReqDTO dto);

/**
 * 条件查询文章列表
 *
 * @param dto 查询条件
 * @return 分页信息
 */
@Override
public PageR findList(WmNewsPageReqDTO dto) {
    // 检查参数
    dto.checkParam();

    IPage<WmNews> page = new Page<>(dto.getPage(), dto.getSize());

    LambdaQueryWrapper<WmNews> wrapper = new LambdaQueryWrapper<>();

    wrapper
            // 状态精确查询
            .eq(dto.getStatus() != null, WmNews::getStatus, dto.getStatus())
            // 频道精确查询
            .eq(dto.getChannelId() != null, WmNews::getChannelId, dto.getChannelId())
            // 时间范围查询
            .between(dto.getBeginPubData() != null && dto.getEndPubData() != null,
                    WmNews::getPublishTime, dto.getBeginPubData(), dto.getEndPubData())
            // 关键字的模糊查询
            .like(StringUtils.hasText(dto.getKeyword()), WmNews::getTitle, dto.getKeyword())
            // 按照发布时间倒叙查询
            .eq(WmNews::getUserId, IdThreadUtil.getId())
            .orderByDesc(WmNews::getCreatedTime);

    page = page(page, wrapper);
    PageR pageR = new PageR(dto.getPage(), dto.getSize(), (int)page.getTotal());
    pageR.setData(page.getRecords());
    return pageR;
}

@RestController
@ResponseResult
@RequestMapping("/api/v1/news")
public class WmNewsController {

    private final WmNewsService wmNewsService;

    public WmNewsController(WmNewsService wmNewsService) {
        this.wmNewsService = wmNewsService;
    }

    @PostMapping("/list")
    public PageR findAll(@RequestBody WmNewsPageReqDTO dto) {
        return wmNewsService.findList(dto);
    }

}

@Data
public class WmNewsDTO {
    private Integer id;
    
    /**
     * 标题
     */
    private String title;

    /**
     * 频道ID
     */
    private Integer channelId;

    /**
     * 文章标签
     */
    private String labels;

    /**
     * 发布时间
     */
    private Data publishTime;

    /**
     * 文章内容
     */
    private String content;

    /**
     * 文章封面类型，0 无图 1 单图 3 多图 -1 自动
     */
    private Short type;
    
    // 封面图片列表，多张图以逗号分隔开
    private List<String> images;
}

/**
 * 处理文章提交的逻辑，解决循环依赖问题
 */
public interface WmNewsSubmitService {

    /**
     * 保存、修改文章或保存为草稿
     * @param dto 文章信息
     */
    public void submitNews(WmNewsDTO dto);
}

@Slf4j
@Service
public class WmNewsSubmitServiceImpl implements WmNewsSubmitService {

    private final WmNewsMaterialMapper wmNewsMaterialMapper;
    private final WmMaterialMapper wmMaterialMapper;
    private final WmNewsTaskService wmNewsTaskService;
    private final WmNewsService wmNewsService;

    public WmNewsSubmitServiceImpl(WmNewsMaterialMapper wmNewsMaterialMapper, WmMaterialMapper wmMaterialMapper, WmNewsTaskService wmNewsTaskService, WmNewsService wmNewsService) {
        this.wmNewsMaterialMapper = wmNewsMaterialMapper;
        this.wmMaterialMapper = wmMaterialMapper;
        this.wmNewsTaskService = wmNewsTaskService;
        this.wmNewsService = wmNewsService;
    }

    /**
     * 保存、修改文章或保存为草稿
     *
     * @param dto 文章信息
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void submitNews(WmNewsDTO dto) {
        if (dto == null || dto.getContent() == null) {
            throw new BizException(ResultCodeEnum.PARAM_INVALID);
        }

        WmNews wmNews = new WmNews();
        BeanUtils.copyProperties(dto, wmNews);
        if (dto.getImages() != null && !dto.getImages().isEmpty()) {
            String imgStr = StringUtils.join(dto.getImages(), ",");
            wmNews.setImages(imgStr);
        }

        if (dto.getType().equals(WmNewsTypeEnum.AUTO.getType())) {
            wmNews.setType(null);
        }
        saveOrUpdateWmNews(wmNews);

        // 草稿
        if (dto.getStatus().equals(WmNews.Status.NORMAL.code())) {
            return;
        }

        // 不是草稿，保存文章内容图片与素材的关系
        List<String> materials = extractUrlInfo(dto.getContent());
        saveRelativeInfoForContent(materials, wmNews.getId());

        // 不是草稿，保存文章封面与素材的关系，布局自动，需要从内容中提起封面
        saveRelativeInfoForCover(dto, wmNews, materials);
    }

    /**
     * 保存或修改文章
     *
     * @param wmNews 文章
     */
    public void saveOrUpdateWmNews(WmNews wmNews) {
        wmNews.setUserId(IdThreadUtil.getId().intValue());
        wmNews.setCreatedTime(new Date());
        wmNews.setSubmitedTime(new Date());
        wmNews.setEnable((short) 1);

        if (wmNews.getId() == null) {
            // 保存
            wmNewsService.save(wmNews);
        } else {
            // 修改
            // 删除文章图片与素材的关系
            wmNewsMaterialMapper.delete(Wrappers.<WmNewsMaterial>lambdaQuery().eq(WmNewsMaterial::getNewsId, wmNews.getId()));
            wmNewsService.updateById(wmNews);
        }
    }

    /**
     * 提取文章内容中图片信息
     *
     * @param content 文章内容
     * @return 图片URL列表
     */
    private List<String> extractUrlInfo(String content) {
        List<String> materials = new ArrayList<>();
        List<Map> maps = JSON.parseArray(content, Map.class);
        for (Map map : maps) {
            if (map.get("type").equals("image")) {
                String imgUrl = (String) map.get("value");
                materials.add(imgUrl);
            }
        }
        return materials;
    }

    /**
     * 1.封面类型为自动，则从内容中提取封面信息
     * 提取规则
     * - 内容素材大于等于1，小于3 单图 type=1
     * - 内容素材大于等于3 多图 type=3
     * - 如果内容没有素材 无图 type=0
     * 2.保存封面图片和素材的关系
     *
     * @param dto       封面类型
     * @param wmNews    文章
     * @param materials 内容中的素材
     */
    private void saveRelativeInfoForCover(WmNewsDTO dto, WmNews wmNews, List<String> materials) {
        List<String> covers = dto.getImages();
        if (dto.getType().equals(WmNewsTypeEnum.AUTO.getType())) {
            // 多图
            if (materials.size() >= 3) {
                wmNews.setType(WmNewsTypeEnum.MULTI_IMAGE.getType());
                covers = materials.stream().limit(3).collect(Collectors.toList());
            } else if (!materials.isEmpty()) {
                // 单图
                wmNews.setType(WmNewsTypeEnum.SINGLE_IMAGE.getType());
                covers = materials.stream().limit(1).collect(Collectors.toList());
            } else {
                // 无图
                wmNews.setType(WmNewsTypeEnum.NONE_IMAGE.getType());
            }

            // 修改文章
            if (covers != null && !covers.isEmpty()) {
                wmNews.setImages(StringUtils.join(covers, ","));
            }
            wmNewsService.updateById(wmNews);
        }
        saveRelativeInfo(covers, wmNews.getId(), WmNewsMaterialReferenceEnum.COVER_REFERENCE.getRef());
    }

    /**
     * 保存内容中素材和文章的关系
     *
     * @param materials 素材url
     * @param newsId    文章ID
     */
    public void saveRelativeInfoForContent(List<String> materials, Integer newsId) {
        saveRelativeInfo(materials, newsId, WmNewsMaterialReferenceEnum.CONTENT_REFERENCE.getRef());
    }

    /**
     * 保存文章与素材的关系
     *
     * @param materials 素材
     * @param newsId    文章ID
     * @param ref       哪种关系
     */
    private void saveRelativeInfo(List<String> materials, Integer newsId, Short ref) {
        if (materials == null || materials.isEmpty()) {
            return;
        }

        List<WmMaterial> dbMaterials = wmMaterialMapper.selectList(Wrappers.<WmMaterial>lambdaQuery().in(WmMaterial::getUrl, materials));

        // 判断素材是否有效
        if (dbMaterials == null || dbMaterials.isEmpty()) {
            throw new BizException(ResultCodeEnum.MATERIAL_REFERENCE_FAIL);
        }

        if (materials.size() != dbMaterials.size()) {
            throw new BizException(ResultCodeEnum.MATERIAL_REFERENCE_FAIL);
        }

        List<Integer> idList = dbMaterials.stream().map(WmMaterial::getId).collect(Collectors.toList());
        wmNewsMaterialMapper.saveRelations(idList, newsId, WmNewsMaterialReferenceEnum.CONTENT_REFERENCE.getRef());
    }

}

@Mapper
public interface WmNewsMaterialMapper extends BaseMapper<WmNewsMaterial> {

    void saveRelations(@Param("materialIds")List<Integer> materialIds, @Param("newsId") Integer newsId, @Param("type") Short type);
}

public enum WmNewsTypeEnum {
    NONE_IMAGE((short) 0, "无图"),
    SINGLE_IMAGE((short) 1, "单图"),
    MULTI_IMAGE((short) 2, "多图"),
    AUTO((short) -1, "自动");

    private final Short type;
    private final String desc;

    WmNewsMaterialTypeEnum(Short type, String desc) {
        this.type = type;
        this.desc = desc;
    }

    public Short getType() {
        return type;
    }

    public String getDesc() {
        return desc;
    }
}

public enum WmNewsMaterialReferenceEnum {

    CONTENT_REFERENCE((short) 0, "内容引用"),
    COVER_REFERENCE((short) 1, "封面引用");

    private final Short ref;
    private final String desc;

    WmNewsMaterialReferenceEnum(Short ref, String desc) {
        this.ref = ref;
        this.desc = desc;
    }

    public Short getRef() {
        return ref;
    }

    public String getDesc() {
        return desc;
    }
}

@PostMapping("/submit")
public void submitNews(@RequestBody WmNewsDTO dto) {
    wmNewsService.submitNews(dto);
}

@TableId(value = "id", type = IdType.ASSIGN_ID)
private Long id;

/**
 * 保存APP端相关文章
 *
 * @param dto 文章信息
 */
public Long saveArticle(ArticleDTO dto);

/**
 * 保存APP端相关文章
 *
 * @param dto 文章信息
 */
@Transactional(rollbackFor = RuntimeException.class)
@Override
public Long saveArticle(ArticleDTO dto) {
    if (dto == null) {
        throw new BizException(ResultCodeEnum.PARAM_INVALID);
    }

    ApArticle apArticle = new ApArticle();
    BeanUtils.copyProperties(dto, apArticle);

    if (dto.getId() == null) {
        // 不存在ID，保存
        save(apArticle);

        // 保存文章配置
        ApArticleConfig apArticleConfig = new ApArticleConfig(apArticle.getId());
        apArticleConfigMapper.insert(apArticleConfig);

        // 保存文章内容
        ApArticleContent apArticleContent = new ApArticleContent();
        apArticleContent.setArticleId(apArticle.getId());
        apArticleContent.setContent(dto.getContent());
        apArticleContentMapper.insert(apArticleContent);

    } else {
        // 存在ID，修改
        updateById(apArticle);

        // 修改文章内容
        ApArticleContent apArticleContent = apArticleContentMapper.selectOne(
                Wrappers.<ApArticleContent>lambdaQuery().eq(ApArticleContent::getArticleId, apArticle.getId()));
        apArticleContent.setContent(dto.getContent());
        apArticleContentMapper.updateById(apArticleContent);

    }

    return apArticle.getId();
}

@FeignClient("leadnews-article")
public interface IArticleClient {

    @PostMapping("/api/v1/article/save")
    public R saveArticle(ArticleDTO dto);
}

@RestController
public class ArticleClient implements IArticleClient {

    private final ApArticleService apArticleService;

    public ArticleClient(ApArticleService apArticleService) {
        this.apArticleService = apArticleService;
    }

    @PostMapping("/api/v1/article/save")
    @Override
    public R saveArticle(@RequestBody ArticleDTO dto) {
        Long articleId = apArticleService.saveArticle(dto);
        return R.success(articleId);
    }
}

public class AuthUtil {

    private static Calendar expireDate;
    private static boolean flag = false;
    private static String accessToken;

    static final OkHttpClient HTTP_CLIENT = new OkHttpClient().newBuilder().build();

    private static Boolean needAuth() {
        Calendar c = Calendar.getInstance();
        c.add(5, 1);
        return Boolean.valueOf(!flag || c.after(expireDate));
    }

    /**
     * 获取权限token
     * @return access_token
     */
    public static String getAccessToken(String clientId, String clientSecret) throws Exception {
        if (needAuth()) {
            flag = true;
            accessToken = getAuth(clientId, clientSecret);
        }
        return accessToken;
    }

    /**
     * 从用户的AK，SK生成鉴权签名（Access Token）
     *
     * @return 鉴权签名（Access Token）
     * @throws IOException IO异常
     */
    private static String getAuth(String clientId, String clientSecret) throws Exception {
        MediaType mediaType = MediaType.parse("application/json");
        RequestBody body = RequestBody.create(mediaType, "");
        Request request = new Request.Builder()
                .url(String.format(URLConstants.BAIDU_AUTH_TOKEN, clientId, clientSecret))
                .method("POST", body)
                .addHeader("Content-Type", "application/json")
                .addHeader("Accept", "application/json")
                .build();
        Response response = HTTP_CLIENT.newCall(request).execute();
        if (response.code() != HttpStatus.OK.value()) {
            throw new RuntimeException("百度云AccessToken获取失败");
        }
        JSONObject result = JSONObject.parseObject(response.body().string());
        String accessToken = result.getString("access_token");
        return accessToken;
    }
}

public class URLConstants {

    public static final String BAIDU_AUTH_TOKEN = "https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=%s&client_secret=%s";
    public static final String BAIDU_TEXT_CENSOR = "https://aip.baidubce.com/rest/2.0/solution/v1/text_censor/v2/user_defined?access_token=%s";

    public static final String BAIDU_IMG_CENSOR = "https://aip.baidubce.com/rest/2.0/solution/v1/img_censor/v2/user_defined?access_token=%s";
}

public enum TextCensorResultEnum {

    COMPLIANCE((short) 1, "合规"),
    NON_COMPLIANCE((short) 2, "不合规"),
    SUSPECTED((short) 3, "疑似"),
    AUDIT_FAILED((short) 4, "审核失败");

    private final Short type;
    private final String desc;

    TextCensorResultEnum(Short type, String desc) {
        this.type = type;
        this.desc = desc;
    }

    public Short type() {
        return type;
    }

    public String desc() {
        return desc;
    }
}

@Getter
@Setter
@Slf4j
@Component
@ConfigurationProperties(prefix = "baiduyun")
public class ContentCensor {

    private String clientId;
    private String clientSecret;

    /**
     * 文本审核
     *
     * @param text 待审核文本
     * @return 审核结果 { log_id, conclusion, conclusionType }
     * @throws Exception 审核异常
     */
    public Map<String, Object> textCensor(String text) throws Exception {

        String accessToken = AuthUtil.getAccessToken(clientId, clientSecret);
        FormBody formBody = new FormBody.Builder().add("text", text).build();
        Request request = new Request.Builder()
                .url(String.format(URLConstants.BAIDU_TEXT_CENSOR, accessToken))
                .method("POST", formBody)
                .addHeader("Content-Type", "application/x-www-form-urlencoded")
                .addHeader("Accept", "application/json")
                .build();

        Response response = AuthUtil.HTTP_CLIENT.newCall(request).execute();
        String strBody = response.body().string();
        if (response.code() != HttpStatus.OK.value()) {
            JSONObject errObj = JSONObject.parseObject(strBody);
            log.error("百度文本审核接口调用失败：error_code: {}, error_msg: {}", errObj.getString("error_code"), errObj.getString("error_msg"));
            throw new RuntimeException("百度文本审核接口调用失败");
        }

        JSONObject resultObj = JSONObject.parseObject(strBody);
        Map<String, Object> result = new HashMap<>();
        result.put("log_id", resultObj.getString("log_id"));
        result.put("conclusion", resultObj.getString("conclusion"));
        result.put("conclusionType", resultObj.getShortValue("conclusionType"));
        return result;
    }

    /**
     * 图像审核
     *
     * @param imgParams 待审核图像列表
     * @return 审核结果 { log_id, conclusion, conclusionType }
     * @throws Exception 审核异常
     */
    public Map<String, Object> imgCensor(List<String> imgParams) throws Exception {

        String accessToken = AuthUtil.getAccessToken(clientId, clientSecret);
        Request.Builder builder = new Request.Builder()
                .url(String.format(URLConstants.BAIDU_IMG_CENSOR, accessToken))
                .addHeader("Content-Type", "application/x-www-form-urlencoded")
                .addHeader("Accept", "application/json");

        Map<String, Object> result = new HashMap<>();
        for (String imgParam : imgParams) {
            FormBody formBody = new FormBody.Builder().add("image", imgParam).build();
            Request request = builder.method("POST", formBody).build();
            Response response = AuthUtil.HTTP_CLIENT.newCall(request).execute();
            String strBody = response.body().string();
            if (response.code() != HttpStatus.OK.value()) {
                JSONObject errObj = JSONObject.parseObject(strBody);
                log.error("百度图像审核接口调用失败：error_code: {}, error_msg: {}", errObj.getString("error_code"), errObj.getString("error_msg"));
                throw new RuntimeException("百度文本审核接口调用失败");
            }
            JSONObject resultObj = JSONObject.parseObject(strBody);
            Short conclusionType = resultObj.getShort("conclusionType");
            // 审核不是通过
            if (!Objects.equals(conclusionType, TextCensorResultEnum.COMPLIANCE.type())) {
                result.put("log_id", resultObj.getString("log_id"));
                result.put("conclusion", resultObj.getString("conclusion"));
                result.put("conclusionType", resultObj.getShortValue("conclusionType"));
                return result;
            }
        }
        result.put("conclusionType", TextCensorResultEnum.COMPLIANCE.type());
        return result;
    }
}

public enum WmNewsContentTypeEnum {
    TEXT("text", "文本"),
    IMAGE("image", "图片");

    private String type;
    private String desc;

    WmNewsContentTypeEnum(String type, String desc) {
        this.type = type;
        this.desc = desc;
    }

    public String getType() {
        return type;
    }

    public String getDesc() {
        return desc;
    }
}

public interface WmNewsAutoScanService {

    /**
     * 自媒体文章审核
     *
     * @param id 自媒体文章ID
     */
    public void autoScanWmNews(Integer id);
}

@Service
public class WmNewsAutoScanServiceImpl implements WmNewsAutoScanService {

    private final WmNewsService wmNewsService;
    private final ContentCensor contentCensor;
    private final FileStorageService fileStorageService;
    private final IArticleClient articleClient;
    private final WmChannelService wmChannelService;
    private final WmUserService wmUserService;

    public WmNewsAutoScanServiceImpl(WmNewsService wmNewsService, ContentCensor contentCensor, FileStorageService fileStorageService, IArticleClient articleClient, WmChannelService wmChannelService, WmUserService wmUserService) {
        this.wmNewsService = wmNewsService;
        this.contentCensor = contentCensor;
        this.fileStorageService = fileStorageService;
        this.articleClient = articleClient;
        this.wmChannelService = wmChannelService;
        this.wmUserService = wmUserService;
    }

    /**
     * 自媒体文章审核
     *
     * @param id 自媒体文章ID
     */
    @Override
    @Transactional(rollbackFor = RuntimeException.class)
    public void autoScanWmNews(Integer id) {
        // 查询文章
        WmNews wmNews = wmNewsService.getById(id);
        if (wmNews == null) {
            throw new RuntimeException("WmNewsAutoScanServiceImpl-文章不存在");
        }

        if (!wmNews.getStatus().equals(WmNews.Status.SUBMIT.code())) {
            return;
        }

        // 从内容中提取文本和图片
        Map<String, Object> textAndImages = handleTextAndImages(wmNews);
        // 审核文本内容
        boolean isTextScan = handleTextScan((String) textAndImages.get("text"), wmNews);
        if (!isTextScan) return;
        // 审核图片
        boolean isImageScan = handleImageScan((List<String>) textAndImages.get("image"), wmNews);
        if (!isImageScan) return;

        // 审核成功，保存APP端的相关文章数据
        R r = saveAppArticle(wmNews);
        if (!r.getCode().equals(ResultCodeEnum.SUCCESS.code())) {
            throw new RuntimeException("WmNewsAutoScanServiceImpl-文章审核失败， 保存app端相关文章数据失败");
        }
        // 回填article_id
        wmNews.setArticleId((Long) r.getData());
        updateWmNews(wmNews, WmNews.Status.PUBLISHED.code(), "审核成功");
    }

    /**
     * 保存APP端的相关文章数据
     * @param wmNews 文章数据
     */
    private R saveAppArticle(WmNews wmNews) {
        ArticleDTO articleDTO = new ArticleDTO();
        BeanUtils.copyProperties(wmNews, articleDTO);

        articleDTO.setLayout(wmNews.getType());

        WmChannel wmChannel = wmChannelService.getById(wmNews.getChannelId());
        if (wmChannel != null) {
            articleDTO.setChannelName(wmChannel.getName());
        }

        articleDTO.setAuthorId(wmNews.getUserId());
        WmUser wmUser = wmUserService.getById(wmNews.getUserId());
        if (wmUser != null) {
            articleDTO.setAuthorName(wmUser.getName());
        }

        if (wmNews.getArticleId() != null) {
            articleDTO.setId(wmNews.getArticleId());
        }
        articleDTO.setCreatedTime(new Date());

        return articleClient.saveArticle(articleDTO);
    }

    /**
     * 审核图片内容
     *
     * @param images 图片列表
     * @param wmNews 文章信息
     * @return 是否审核通过
     */
    private boolean handleImageScan(List<String> images, WmNews wmNews) {

        if (images == null || images.isEmpty()) return true;

        List<String> imgParams = new ArrayList<>();
        // 下载MinIO
        // 图片去重
        images = images.stream().distinct().collect(Collectors.toList());
        for (String image : images) {
            byte[] imgData = fileStorageService.downLoadFile(image);
            String imgStr = Base64Util.encode(imgData);
            String imgParam = URLEncoder.encode(imgStr, StandardCharsets.UTF_8);
            imgParams.add(imgParam);
        }

        try {
            Map<String, Object> map = contentCensor.imgCensor(imgParams);
            Short conclusionType = (Short) map.get("conclusionType");
            // 存在违规内容
            if (conclusionType.equals(TextCensorResultEnum.NON_COMPLIANCE.type())) {
                updateWmNews(wmNews, WmNews.Status.FAIL.code(), "当前素材中存在违规内容");
            }

            // 文章疑似有违规内容
            if (conclusionType.equals(TextCensorResultEnum.SUSPECTED.type())) {
                updateWmNews(wmNews, WmNews.Status.ADMIN_AUTH.code(), "当前素材中存在不确定性内容");
            }

            // 自动审核失败，转人工审核
            if (conclusionType.equals(TextCensorResultEnum.AUDIT_FAILED.type())) {
                updateWmNews(wmNews, WmNews.Status.ADMIN_AUTH.code(), "自动审核失败");
            }
            return conclusionType.equals(TextCensorResultEnum.COMPLIANCE.type());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 审核文本内容
     *
     * @param text   文本内容
     * @param wmNews 文章信息
     * @return 是否审核通过
     */
    private boolean handleTextScan(String text, WmNews wmNews) {
        if ((wmNews.getTitle() + text).isEmpty()) return true;
        try {
            Map<String, Object> map = contentCensor.textCensor(wmNews.getTitle() + "-" + text);
            Short conclusionType = (Short) map.get("conclusionType");
            // 存在违规内容
            if (conclusionType.equals(TextCensorResultEnum.NON_COMPLIANCE.type())) {
                updateWmNews(wmNews, WmNews.Status.FAIL.code(), "当前文章中存在违规内容");
            }

            // 文章疑似有违规内容
            if (conclusionType.equals(TextCensorResultEnum.SUSPECTED.type())) {
                updateWmNews(wmNews, WmNews.Status.ADMIN_AUTH.code(), "当前文章中存在不确定性内容");
            }

            // 自动审核失败，转人工审核
            if (conclusionType.equals(TextCensorResultEnum.AUDIT_FAILED.type())) {
                updateWmNews(wmNews, WmNews.Status.ADMIN_AUTH.code(), "自动审核失败");
            }

            return conclusionType.equals(TextCensorResultEnum.COMPLIANCE.type());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 修改文章内容
     *
     * @param wmNews 文章
     * @param status 待修改文章状态
     * @param reason 待修改文章审核原因
     */
    private void updateWmNews(WmNews wmNews, short status, String reason) {
        wmNews.setStatus(status);
        wmNews.setReason(reason);
        wmNewsService.updateById(wmNews);
    }

    /**
     * 从内容和封面中提取文本和图片
     *
     * @param wnNews 内容
     * @return 文本和图片
     */
    private Map<String, Object> handleTextAndImages(WmNews wnNews) {
        if (!StringUtils.hasText(wnNews.getContent())) {
            return null;
        }

        // 存储纯文本内容
        StringBuilder texts = new StringBuilder();
        ArrayList<String> images = new ArrayList<>();

        List<Map> maps = JSON.parseArray(wnNews.getContent(), Map.class);
        for (Map map : maps) {
            if (map.get("type").equals(WmNewsContentTypeEnum.TEXT.getType())) {
                texts.append(map.get("value"));
            }
            if (map.get("type").equals(WmNewsContentTypeEnum.IMAGE.getType())) {
                images.add((String) map.get("value"));
            }
        }

        // 提取封面
        if (StringUtils.hasText(wnNews.getImages())) {
            String[] split = wnNews.getImages().split(",");
            images.addAll(Arrays.asList(split));
        }

        Map<String, Object> result = new HashMap<>();
        result.put("text", texts.toString());
        result.put("images", images);
        return result;
    }
}

/**
 * Base64 工具类
 */
public class Base64Util {
    private static final char last2byte = (char) Integer.parseInt("00000011", 2);
    private static final char last4byte = (char) Integer.parseInt("00001111", 2);
    private static final char last6byte = (char) Integer.parseInt("00111111", 2);
    private static final char lead6byte = (char) Integer.parseInt("11111100", 2);
    private static final char lead4byte = (char) Integer.parseInt("11110000", 2);
    private static final char lead2byte = (char) Integer.parseInt("11000000", 2);
    private static final char[] encodeTable = new char[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};

    public Base64Util() {
    }

    public static String encode(byte[] from) {
        StringBuilder to = new StringBuilder((int) ((double) from.length * 1.34D) + 3);
        int num = 0;
        char currentByte = 0;

        int i;
        for (i = 0; i < from.length; ++i) {
            for (num %= 8; num < 8; num += 6) {
                switch (num) {
                    case 0:
                        currentByte = (char) (from[i] & lead6byte);
                        currentByte = (char) (currentByte >>> 2);
                    case 1:
                    case 3:
                    case 5:
                    default:
                        break;
                    case 2:
                        currentByte = (char) (from[i] & last6byte);
                        break;
                    case 4:
                        currentByte = (char) (from[i] & last4byte);
                        currentByte = (char) (currentByte << 2);
                        if (i + 1 < from.length) {
                            currentByte = (char) (currentByte | (from[i + 1] & lead2byte) >>> 6);
                        }
                        break;
                    case 6:
                        currentByte = (char) (from[i] & last2byte);
                        currentByte = (char) (currentByte << 4);
                        if (i + 1 < from.length) {
                            currentByte = (char) (currentByte | (from[i + 1] & lead4byte) >>> 4);
                        }
                }

                to.append(encodeTable[currentByte]);
            }
        }

        if (to.length() % 4 != 0) {
            for (i = 4 - to.length() % 4; i > 0; --i) {
                to.append("=");
            }
        }

        return to.toString();
    }
}

@Component
public class IArticleClientFallback implements IArticleClient {
    @Override
    public R saveArticle(ArticleDTO dto) {
        return R.fail(ResultCodeEnum.SERVER_ERROR.code(), "获取数据失败");
    }
}

@FeignClient(value = "leadnews-article", fallback = IArticleClientFallback.class)
public interface IArticleClient {

    @PostMapping("/api/v1/article/save")
    public R saveArticle(ArticleDTO dto);
}

@Configuration
@ComponentScan("com.swx.apis.article.fallback")
public class InitConfig {
}

@EnableAsync
public class WemediaApplication {
    public static void main(String[] args) {
        SpringApplication.run(WemediaApplication.class, args);
    }
}

@Override
@Async
@Transactional(rollbackFor = RuntimeException.class)
public void autoScanWmNews(Integer id) {
	....
}

/**
 * 保存、修改文章或保存为草稿
 *
 * @param dto 文章信息
 */
@Override
@Transactional(rollbackFor = Exception.class)
public void submitNews(WmNewsDTO dto) {
    ....;
    // 异步调用自动审核
    wmNewsAutoScanService.autoScanWmNews(wmNews.getId());
}

public class SensitiveWordUtil {

    public static Map<String, Object> dictionaryMap = new HashMap<>();


    /**
     * 生成关键词字典库
     * @param words
     * @return
     */
    public static void initMap(Collection<String> words) {
        if (words == null) {
            System.out.println("敏感词列表不能为空");
            return ;
        }

        // map初始长度words.size()，整个字典库的入口字数(小于words.size()，因为不同的词可能会有相同的首字)
        Map<String, Object> map = new HashMap<>(words.size());
        // 遍历过程中当前层次的数据
        Map<String, Object> curMap = null;
        Iterator<String> iterator = words.iterator();

        while (iterator.hasNext()) {
            String word = iterator.next();
            curMap = map;
            int len = word.length();
            for (int i =0; i < len; i++) {
                // 遍历每个词的字
                String key = String.valueOf(word.charAt(i));
                // 当前字在当前层是否存在, 不存在则新建, 当前层数据指向下一个节点, 继续判断是否存在数据
                Map<String, Object> wordMap = (Map<String, Object>) curMap.get(key);
                if (wordMap == null) {
                    // 每个节点存在两个数据: 下一个节点和isEnd(是否结束标志)
                    wordMap = new HashMap<>(2);
                    wordMap.put("isEnd", "0");
                    curMap.put(key, wordMap);
                }
                curMap = wordMap;
                // 如果当前字是词的最后一个字，则将isEnd标志置1
                if (i == len -1) {
                    curMap.put("isEnd", "1");
                }
            }
        }

        dictionaryMap = map;
    }

    /**
     * 搜索文本中某个文字是否匹配关键词
     * @param text
     * @param beginIndex
     * @return
     */
    private static int checkWord(String text, int beginIndex) {
        if (dictionaryMap == null) {
            throw new RuntimeException("字典不能为空");
        }
        boolean isEnd = false;
        int wordLength = 0;
        Map<String, Object> curMap = dictionaryMap;
        int len = text.length();
        // 从文本的第beginIndex开始匹配
        for (int i = beginIndex; i < len; i++) {
            String key = String.valueOf(text.charAt(i));
            // 获取当前key的下一个节点
            curMap = (Map<String, Object>) curMap.get(key);
            if (curMap == null) {
                break;
            } else {
                wordLength ++;
                if ("1".equals(curMap.get("isEnd"))) {
                    isEnd = true;
                }
            }
        }
        if (!isEnd) {
            wordLength = 0;
        }
        return wordLength;
    }

    /**
     * 获取匹配的关键词和命中次数
     * @param text
     * @return
     */
    public static Map<String, Integer> matchWords(String text) {
        Map<String, Integer> wordMap = new HashMap<>();
        int len = text.length();
        for (int i = 0; i < len; i++) {
            int wordLength = checkWord(text, i);
            if (wordLength > 0) {
                String word = text.substring(i, i + wordLength);
                // 添加关键词匹配次数
                if (wordMap.containsKey(word)) {
                    wordMap.put(word, wordMap.get(word) + 1);
                } else {
                    wordMap.put(word, 1);
                }

                i += wordLength - 1;
            }
        }
        return wordMap;
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("法轮");
        list.add("法轮功");
        list.add("冰毒");
        initMap(list);
        String content="我是一个好人，并不会卖冰毒，也不操练法轮功,我真的不卖冰毒";
        Map<String, Integer> map = matchWords(content);
        System.out.println(map);
    }
}

/**
 * 自管理的敏感词审核
 *
 * @param text   文本
 * @param wmNews 文章信息
 * @return 是否审核通过
 */
private boolean handleSensitiveScan(String text, WmNews wmNews) {
    // 获取所有敏感词
    List<WmSensitive> wmSensitives = wmSensitiveMapper.selectList(Wrappers.<WmSensitive>lambdaQuery().select(WmSensitive::getSensitive));
    List<String> sensitives = wmSensitives.stream().map(WmSensitive::getSensitive).collect(Collectors.toList());

    // 初始化敏感词库
    SensitiveWordUtil.initMap(sensitives);

    // 查看文章中是否存在敏感词库
    Map<String, Integer> map = SensitiveWordUtil.matchWords(text);
    if (!map.isEmpty()) {
        updateWmNews(wmNews, WmNews.Status.FAIL.code(), "当前文章存在违规内容" + map);
        return false;
    }
    return true;
}

@Getter
@Setter
@Component
@ConfigurationProperties(prefix = "tess4j")
public class Tess4jClient {

    private String dataPath;
    private String language;

    public String doOCR(BufferedImage image) throws TesseractException {
        ITesseract tesseract = new Tesseract();
        tesseract.setDatapath(dataPath);
        tesseract.setLanguage(language);
        String result = tesseract.doOCR(image);
        result = result.replaceAll("\\r|\\n", "-").replaceAll(" ", "");
        return result;
    }
}

/**
 * 审核图片内容
 *
 * @param images 图片列表
 * @param wmNews 文章信息
 * @return 是否审核通过
 */
private boolean handleImageScan(List<String> images, WmNews wmNews) {

    if (images == null || images.isEmpty()) return true;

    List<String> imgParams = new ArrayList<>();
    try {
        // 图片去重
        images = images.stream().distinct().collect(Collectors.toList());
        for (String image : images) {
            // 下载MinIO
            byte[] imgData = fileStorageService.downLoadFile(image);
            ByteArrayInputStream in = new ByteArrayInputStream(imgData);
            BufferedImage bufferedImage = ImageIO.read(in);

            // 图片识别
            String result = tess4jClient.doOCR(bufferedImage);
            // 过滤文字
            boolean isSensitive = handleSensitiveScan(result, wmNews);
            if (!isSensitive) {
                return false;
            }
            // 转Base64
            String imgStr = Base64Util.encode(imgData);
            String imgParam = URLEncoder.encode(imgStr, StandardCharsets.UTF_8);
            imgParams.add(imgParam);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

    try {
        Map<String, Object> map = contentCensor.imgCensor(imgParams);
        Short conclusionType = (Short) map.get("conclusionType");
        // 存在违规内容
        if (conclusionType.equals(TextCensorResultEnum.NON_COMPLIANCE.type())) {
            updateWmNews(wmNews, WmNews.Status.FAIL.code(), "当前素材中存在违规内容");
        }

        // 图片疑似有违规内容
        if (conclusionType.equals(TextCensorResultEnum.SUSPECTED.type())) {
            updateWmNews(wmNews, WmNews.Status.ADMIN_AUTH.code(), "当前素材中存在不确定性内容");
        }

        // 自动审核失败，转人工审核
        if (conclusionType.equals(TextCensorResultEnum.AUDIT_FAILED.type())) {
            updateWmNews(wmNews, WmNews.Status.ADMIN_AUTH.code(), "自动审核失败");
        }
        return conclusionType.equals(TextCensorResultEnum.COMPLIANCE.type());
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

public interface ApArticleSaveService {

    /**
     * 保存APP端相关文章
     *
     * @param dto 文章信息
     */
    public Long saveArticle(ArticleDTO dto);
}

@Service
public class ApArticleSaveServiceImpl implements ApArticleSaveService {

    private final ApArticleConfigMapper apArticleConfigMapper;
    private final ApArticleContentMapper apArticleContentMapper;
    private final ArticleFreemarkerService articleFreemarkerService;
    private final ApArticleService apArticleService;


    public ApArticleSaveServiceImpl(ApArticleConfigMapper apArticleConfigMapper, ApArticleContentMapper apArticleContentMapper,
                                    ArticleFreemarkerService articleFreemarkerService, ApArticleService apArticleService) {
        this.apArticleConfigMapper = apArticleConfigMapper;
        this.apArticleContentMapper = apArticleContentMapper;
        this.articleFreemarkerService = articleFreemarkerService;
        this.apArticleService = apArticleService;
    }

    /**
     * 保存APP端相关文章
     *
     * @param dto 文章信息
     */
    @Transactional(rollbackFor = RuntimeException.class)
    @Override
    public Long saveArticle(ArticleDTO dto) {
        if (dto == null) {
            throw new BizException(ResultCodeEnum.PARAM_INVALID);
        }

        ApArticle apArticle = new ApArticle();
        BeanUtils.copyProperties(dto, apArticle);

        if (dto.getId() == null) {
            // 不存在ID，保存
            apArticleService.save(apArticle);

            // 保存文章配置
            ApArticleConfig apArticleConfig = new ApArticleConfig(apArticle.getId());
            apArticleConfigMapper.insert(apArticleConfig);

            // 保存文章内容
            ApArticleContent apArticleContent = new ApArticleContent();
            apArticleContent.setArticleId(apArticle.getId());
            apArticleContent.setContent(dto.getContent());
            apArticleContentMapper.insert(apArticleContent);

        } else {
            // 存在ID，修改
            apArticleService.updateById(apArticle);

            // 修改文章内容
            ApArticleContent apArticleContent = apArticleContentMapper.selectOne(
                    Wrappers.<ApArticleContent>lambdaQuery().eq(ApArticleContent::getArticleId, apArticle.getId()));
            apArticleContent.setContent(dto.getContent());
            apArticleContentMapper.updateById(apArticleContent);

        }

        // 异步调用，生成静态文件上传到MinIOn中
        articleFreemarkerService.buildArticleToMinIO(apArticle, dto.getContent());

        return apArticle.getId();
    }
}

@RestController
public class ArticleClient implements IArticleClient {

    private final ApArticleSaveService apArticleSaveService;

    public ArticleClient(ApArticleSaveService apArticleSaveService) {
        this.apArticleSaveService = apArticleSaveService;
    }

    @PostMapping("/api/v1/article/save")
    @Override
    public R saveArticle(@RequestBody ArticleDTO dto) {
        Long articleId = apArticleSaveService.saveArticle(dto);
        return R.success(articleId);
    }
}

public interface ArticleFreemarkerService {

    /**
     * 生成静态文件上传到MinIO中
     *
     * @param apArticle 文章
     * @param content   内容
     */
    public void buildArticleToMinIO(ApArticle apArticle, String content);
}

@Service
public class ArticleFreemarkerServiceImpl implements ArticleFreemarkerService {

    private final Configuration configuration;
    private final FileStorageService fileStorageService;
    private final ApArticleService apArticleService;

    public ArticleFreemarkerServiceImpl(Configuration configuration, FileStorageService fileStorageService, ApArticleService apArticleService) {
        this.configuration = configuration;
        this.fileStorageService = fileStorageService;
        this.apArticleService = apArticleService;
    }

    /**
     * 生成静态文件上传到MinIO中
     *
     * @param apArticle 文章
     * @param content   内容
     */
    @Async
    @Override
    public void buildArticleToMinIO(ApArticle apArticle, String content) {

       if (!StringUtils.hasText(content)) {
           return;
       }

        // 文章内容通过freemarker生成html文件
        Template template = null;
        try {
            template = configuration.getTemplate("article.ftl");
            StringWriter out = new StringWriter();
            // 数据模型
            HashMap<String, Object> params = new HashMap<>();
            params.put("content", JSONArray.parseArray(content));
            // 合成
            template.process(params, out);

            // 把html文件上传到minio中
            InputStream is = new ByteArrayInputStream(out.toString().getBytes());
            String url = fileStorageService.uploadHtmlFile("", apArticle.getId() + ".html", is);
            
			// 保存URL到数据库
            apArticleService.update(Wrappers.<ApArticle>lambdaUpdate()
                    .eq(ApArticle::getId, apArticle.getId())
                    .set(ApArticle::getStaticUrl, url));

        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    }
}