• 厂里资讯之自媒体文章自动审核

    自媒体文章-自动审核

    1)自媒体文章自动审核流程

    1 自媒体端发布文章后，开始审核文章

    2 审核的主要是审核文章的内容（文本内容和图片）

    3 借助第三方提供的接口审核文本

    4 借助第三方提供的接口审核图片，由于图片存储到minIO中，需要先下载才能审核

    5 如果审核失败，则需要修改自媒体文章的状态，status:2 审核失败 status:3 转到人工审核

    6 如果审核成功，则需要在文章微服务中创建app端需要的文章

    2)内容安全第三方接口

    2.1)概述

    内容安全是识别服务，支持对图片、视频、文本、语音等对象进行多样化场景检测，有效降低内容违规风险。

    目前很多平台都支持内容检测，如阿里云、腾讯云、百度AI、网易云等国内大型互联网公司都对外提供了API。

    按照性能和收费来看，黑马头条项目使用的就是阿里云的内容安全接口，使用到了图片和文本的审核。

    阿里云收费标准：https://www.aliyun.com/price/product/?spm=a2c4g.11186623.2.10.4146401eg5oeu8#/lvwang/detail

    2.2)准备工作

    您在使用内容检测API之前，需要先注册阿里云账号，添加Access Key并签约云盾内容安全。

    操作步骤

    1. 前往阿里云官网注册账号。如果已有注册账号，请跳过此步骤。

      进入阿里云首页后，如果没有阿里云的账户需要先进行注册，才可以进行登录。由于注册较为简单，课程和讲义不在进行体现（注册可以使用多种方式，如淘宝账号、支付宝账号、微博账号等...）。

      需要实名认证和活体认证。

    2. 打开云盾内容安全产品试用页面，单击立即开通，正式开通服务。

    内容安全控制台

    3.在AccessKey管理页面管理您的AccessKeyID和AccessKeySecret。

    管理自己的AccessKey,可以新建和删除AccessKey

    查看自己的AccessKey，

    AccessKey默认是隐藏的，第一次申请的时候可以保存AccessKey，点击显示，通过验证手机号后也可以查看

    2.3)文本内容审核接口

    文本垃圾内容检测：如何调用文本检测接口进行文本内容审核_内容安全(Content Moderation)-阿里云帮助中心

    文本垃圾内容Java SDK: 如何使用JavaSDK文本反垃圾接口_内容安全(Content Moderation)-阿里云帮助中心

    2.4)图片审核接口

    图片垃圾内容检测：调用图片同步检测接口/green/image/scan审核图片内容_内容安全(Content Moderation)-阿里云帮助中心

    图片垃圾内容Java SDK: 如何使用JavaSDK接口检测图片是否包含风险内容_内容安全(Content Moderation)-阿里云帮助中心

    2.5)项目集成

    ①：从官网上拷贝工具类到common模块下面，并添加到自动配置

    包括了GreenImageScan和GreenTextScan及对应的工具类

    添加到自动配置中

    ②： accessKeyId和secret（需自己申请）

    在changli-Information-wemedia中的nacos配置中心添加以下配置：

    1. aliyun:
    2.  accessKeyId: LTAI5tCWHCcfvqQzu8k2oKmX
    3.  secret: auoKUFsghimbfVQHpy7gtRyBkoR4vc
    4. #aliyun.scenes=porn,terrorism,ad,qrcode,live,logo
    5.  scenes: terrorism

    ③：在自媒体微服务中测试类中注入审核文本和图片的bean进行测试

    1. package com.kjz.wemedia;
    2. ​
    3. import com.kjz.common.aliyun.GreenImageScan;
    4. import com.kjz.common.aliyun.GreenTextScan;
    5. import com.kjz.file.service.FileStorageService;
    6. import org.junit.Test;
    7. import org.junit.runner.RunWith;
    8. import org.springframework.beans.factory.annotation.Autowired;
    9. import org.springframework.boot.test.context.SpringBootTest;
    10. import org.springframework.test.context.junit4.SpringRunner;
    11. ​
    12. import java.util.Arrays;
    13. import java.util.Map;
    14. ​
    15. @SpringBootTest(classes = WemediaApplication.class)
    16. @RunWith(SpringRunner.class)
    17. public class AliyunTest {
    18. ​
    19.     @Autowired
    20.     private GreenTextScan greenTextScan;
    21. ​
    22.     @Autowired
    23.     private GreenImageScan greenImageScan;
    24. ​
    25.     @Autowired
    26.     private FileStorageService fileStorageService;
    27. ​
    28.     @Test
    29.     public void testScanText() throws Exception {
    30.         Map map = greenTextScan.greeTextScan("我是一个好人,冰毒");
    31.         System.out.println(map);
    32.     }
    33. ​
    34.     @Test
    35.     public void testScanImage() throws Exception {
    36.         byte[] bytes = fileStorageService.downLoadFile("http://192.168.200.130:9000/leadnews/2021/04/26/ef3cbe458db249f7bd6fb4339e593e55.jpg");
    37.         Map map = greenImageScan.imageScan(Arrays.asList(bytes));
    38.         System.out.println(map);
    39.     }
    40. }

    3)app端文章保存接口

    3.1)表结构说明

    ap_article 文章信息表

    ap_article_config 文章配置表

    ap_article_content 文章内容表

    3.2)分布式id

    随着业务的增长，文章表可能要占用很大的物理存储空间，为了解决该问题，后期使用数据库分片技术。将一个数据库进行拆分，通过数据库中间件连接。如果数据库中该表选用ID自增策略，则可能产生重复的ID，此时应该使用分布式ID生成策略来生成ID。

    snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0

    文章端相关的表都使用雪花算法生成id,包括ap_article、 ap_article_config、 ap_article_content

    mybatis-plus已经集成了雪花算法，完成以下两步即可在项目中集成雪花算法

    第一：在实体类中的id上加入如下配置，指定类型为id_worker

    1. @TableId(value = "id",type = IdType.ID_WORKER)
    2. private Long id;

    第二：在application.yml文件中配置数据中心id和机器id

    1. mybatis-plus:
    2.   mapper-locations: classpath*:mapper/*.xml
    3.   # 设置别名包扫描路径，通过该属性可以给包中的类注册别名
    4.   type-aliases-package: com.kjz.model.article.pojos
    5.   global-config:
    6.     datacenter-id: 1
    7.     workerId: 1

    datacenter-id:数据中心id(取值范围：0-31)

    workerId:机器id(取值范围：0-31)

    3.3)思路分析

    在文章审核成功以后需要在app的article库中新增文章数据

    1.保存文章信息 ap_article

    2.保存文章配置信息 ap_article_config

    3.保存文章内容 ap_article_content

    实现思路：

    3.4)feign接口
    说明
    接口路径/api/v1/article/save
    请求方式POST
    参数ArticleDto
    响应结果ResponseResult

    ArticleDto

    1. package com.kjz.model.article.dtos;
    2. ​
    3. import com.kjz.model.article.pojos.ApArticle;
    4. import lombok.Data;
    5. ​
    6. @Data
    7. public class ArticleDto  extends ApArticle {
    8.     /**
    9.      * 文章内容
    10.      */
    11.     private String content;
    12. }

    成功：

    {
  "code": 200,
  "errorMessage" : "操作成功",
  "data":"1302864436297442242"
 }

    失败：

    {
  "code":501,
  "errorMessage":"参数失效",
 }
    {
  "code":501,
  "errorMessage":"文章没有找到",
 }

    功能实现：

    ①：在changli-Information-feign-api中新增接口

    第一：导入feign的依赖

    2.     org.springframework.cloud
    3.     spring-cloud-starter-openfeign

    第二：定义文章端的接口

    1. package com.kjz.apis.article;
    2. ​
    3. import com.kjz.model.article.dtos.ArticleDto;
    4. import com.kjz.model.common.dtos.ResponseResult;
    5. import org.springframework.cloud.openfeign.FeignClient;
    6. import org.springframework.web.bind.annotation.PostMapping;
    7. import org.springframework.web.bind.annotation.RequestBody;
    8. ​
    9. import java.io.IOException;
    10. ​
    11. ​
    12. @FeignClient(value = "Information-article")
    13. public interface IArticleClient {
    14. ​
    15.     @PostMapping("/api/v1/article/save")
    16.     public ResponseResult saveArticle(@RequestBody ArticleDto dto) ;
    17. }

    ②：在changli-Information-article中实现该方法

    1. package com.kjz.article.feign;
    2. ​
    3. import com.kjz.apis.article.IArticleClient;
    4. import com.kjz.article.service.ApArticleService;
    5. import com.kjz.model.article.dtos.ArticleDto;
    6. import com.kjz.model.common.dtos.ResponseResult;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.web.bind.annotation.*;
    9. ​
    10. import java.io.IOException;
    11. ​
    12. @RestController
    13. public class ArticleClient implements IArticleClient {
    14. ​
    15.     @Autowired
    16.     private ApArticleService apArticleService;
    17. ​
    18.     @Override
    19.     @PostMapping("/api/v1/article/save")
    20.     public ResponseResult saveArticle(@RequestBody ArticleDto dto) {
    21.         return apArticleService.saveArticle(dto);
    22.     }
    23. ​
    24. }

    ③：创建mapper

    创建ApArticleConfigMapper类到mapper文件夹中

    同时，修改ApArticleConfig类，添加如下构造函数

    1. package com.heima.model.article.pojos;
    2. ​
    3. import com.baomidou.mybatisplus.annotation.IdType;
    4. import com.baomidou.mybatisplus.annotation.TableField;
    5. import com.baomidou.mybatisplus.annotation.TableId;
    6. import com.baomidou.mybatisplus.annotation.TableName;
    7. import lombok.Data;
    8. import lombok.NoArgsConstructor;
    9. ​
    10. import java.io.Serializable;
    11. ​
    12. /**
    13.  * 
    14.  * APP已发布文章配置表
    15.  * 
    16.  *
    17.  * @author itheima
    18.  */
    19. ​
    20. @Data
    21. @NoArgsConstructor
    22. @TableName("ap_article_config")
    23. public class ApArticleConfig implements Serializable {
    24. ​
    25. ​
    26.     public ApArticleConfig(Long articleId){
    27.         this.articleId = articleId;
    28.         this.isComment = true;
    29.         this.isForward = true;
    30.         this.isDelete = false;
    31.         this.isDown = false;
    32.     }
    33. ​
    34.     @TableId(value = "id",type = IdType.ID_WORKER)
    35.     private Long id;
    36. ​
    37.     /**
    38.      * 文章id
    39.      */
    40.     @TableField("article_id")
    41.     private Long articleId;
    42. ​
    43.     /**
    44.      * 是否可评论
    45.      * true: 可以评论   1
    46.      * false: 不可评论  0
    47.      */
    48.     @TableField("is_comment")
    49.     private Boolean isComment;
    50. ​
    51.     /**
    52.      * 是否转发
    53.      * true: 可以转发   1
    54.      * false: 不可转发  0
    55.      */
    56.     @TableField("is_forward")
    57.     private Boolean isForward;
    58. ​
    59.     /**
    60.      * 是否下架
    61.      * true: 下架   1
    62.      * false: 没有下架  0
    63.      */
    64.     @TableField("is_down")
    65.     private Boolean isDown;
    66. ​
    67.     /**
    68.      * 是否已删除
    69.      * true: 删除   1
    70.      * false: 没有删除  0
    71.      */
    72.     @TableField("is_delete")
    73.     private Boolean isDelete;
    74. }

    ④：在ApArticleService中新增方法

    1. /**
    2.      * 保存app端相关文章
    3.      * @param dto
    4.      * @return
    5.      */
    6. ResponseResult saveArticle(ArticleDto dto) ;

    实现类：

    1. @Autowired
    2. private ApArticleConfigMapper apArticleConfigMapper;
    3. ​
    4. @Autowired
    5. private ApArticleContentMapper apArticleContentMapper;
    6. ​
    7. /**
    8.      * 保存app端相关文章
    9.      * @param dto
    10.      * @return
    11.      */
    12. @Override
    13. public ResponseResult saveArticle(ArticleDto dto) {
    14.     //1.检查参数
    15.     if(dto == null){
    16.         return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
    17.     }
    18. ​
    19.     ApArticle apArticle = new ApArticle();
    20.     BeanUtils.copyProperties(dto,apArticle);
    21. ​
    22.     //2.判断是否存在id
    23.     if(dto.getId() == null){
    24.         //2.1 不存在id  保存  文章  文章配置  文章内容
    25. ​
    26.         //保存文章
    27.         save(apArticle);
    28. ​
    29.         //保存配置
    30.         ApArticleConfig apArticleConfig = new ApArticleConfig(apArticle.getId());
    31.         apArticleConfigMapper.insert(apArticleConfig);
    32. ​
    33.         //保存 文章内容
    34.         ApArticleContent apArticleContent = new ApArticleContent();
    35.         apArticleContent.setArticleId(apArticle.getId());
    36.         apArticleContent.setContent(dto.getContent());
    37.         apArticleContentMapper.insert(apArticleContent);
    38. ​
    39.     }else {
    40.         //2.2 存在id   修改  文章  文章内容
    41. ​
    42.         //修改  文章
    43.         updateById(apArticle);
    44. ​
    45.         //修改文章内容
    46.         ApArticleContent apArticleContent = apArticleContentMapper.selectOne(Wrappers.lambdaQuery().eq(ApArticleContent::getArticleId, dto.getId()));
    47.         apArticleContent.setContent(dto.getContent());
    48.         apArticleContentMapper.updateById(apArticleContent);
    49.     }
    50. ​
    51. ​
    52.     //3.结果返回  文章的id
    53.     return ResponseResult.okResult(apArticle.getId());
    54. }

    ⑤：测试

    编写junit单元测试，或使用postman进行测试

    {
    "id":1390209114747047938,
    "title":"厂里资讯项目背景22222222222222",
    "authoId":1102,
    "layout":1,
    "labels":"厂里资讯",
    "publishTime":"2028-03-14T11:35:49.000Z",
    "images": "http://192.168.200.130:9000/leadnews/2021/04/26/5ddbdb5c68094ce393b08a47860da275.jpg",
    "content":"22222222222222222厂里资讯项目背景,厂里资讯项目背景,厂里资讯项目背景,厂里资讯项目背景，厂里资讯项目背景"
}

    4)自媒体文章自动审核功能实现

    4.1)表结构说明

    wm_news 自媒体文章表

    status字段：0 草稿 1 待审核 2 审核失败 3 人工审核 4 人工审核通过 8 审核通过（待发布） 9 已发布

    4.2)实现

    在changli-lnformation-wemedia中的service新增接口

    1. package com.kjz.wemedia.service;
    2. ​
    3. public interface WmNewsAutoScanService {
    4. ​
    5.     /**
    6.      * 自媒体文章审核
    7.      * @param id  自媒体文章id
    8.      */
    9.     public void autoScanWmNews(Integer id);
    10. }

    实现类：

    1. package com.kjz.wemedia.service.impl;
    2. ​
    3. import com.alibaba.fastjson.JSONArray;
    4. import com.heima.apis.article.IArticleClient;
    5. import com.heima.common.aliyun.GreenImageScan;
    6. import com.heima.common.aliyun.GreenTextScan;
    7. import com.heima.file.service.FileStorageService;
    8. import com.heima.model.article.dtos.ArticleDto;
    9. import com.heima.model.common.dtos.ResponseResult;
    10. import com.heima.model.wemedia.pojos.WmChannel;
    11. import com.heima.model.wemedia.pojos.WmNews;
    12. import com.heima.model.wemedia.pojos.WmUser;
    13. import com.heima.wemedia.mapper.WmChannelMapper;
    14. import com.heima.wemedia.mapper.WmNewsMapper;
    15. import com.heima.wemedia.mapper.WmUserMapper;
    16. import com.heima.wemedia.service.WmNewsAutoScanService;
    17. import lombok.extern.slf4j.Slf4j;
    18. import org.apache.commons.lang3.StringUtils;
    19. import org.springframework.beans.BeanUtils;
    20. import org.springframework.beans.factory.annotation.Autowired;
    21. import org.springframework.stereotype.Service;
    22. import org.springframework.transaction.annotation.Transactional;
    23. ​
    24. import java.util.*;
    25. import java.util.stream.Collectors;
    26. ​
    27. ​
    28. @Service
    29. @Slf4j
    30. @Transactional
    31. public class WmNewsAutoScanServiceImpl implements WmNewsAutoScanService {
    32. ​
    33.     @Autowired
    34.     private WmNewsMapper wmNewsMapper;
    35. ​
    36.     /**
    37.      * 自媒体文章审核
    38.      *
    39.      * @param id 自媒体文章id
    40.      */
    41.     @Override
    42.     public void autoScanWmNews(Integer id) {
    43.         //1.查询自媒体文章
    44.         WmNews wmNews = wmNewsMapper.selectById(id);
    45.         if(wmNews == null){
    46.             throw new RuntimeException("WmNewsAutoScanServiceImpl-文章不存在");
    47.         }
    48. ​
    49.         if(wmNews.getStatus().equals(WmNews.Status.SUBMIT.getCode())){
    50.             //从内容中提取纯文本内容和图片
    51.             Map textAndImages = handleTextAndImages(wmNews);
    52. ​
    53.             //2.审核文本内容  阿里云接口
    54.             boolean isTextScan = handleTextScan((String) textAndImages.get("content"),wmNews);
    55.             if(!isTextScan)return;
    56. ​
    57.             //3.审核图片  阿里云接口
    58.             boolean isImageScan =  handleImageScan((List) textAndImages.get("images"),wmNews);
    59.             if(!isImageScan)return;
    60. ​
    61.             //4.审核成功，保存app端的相关的文章数据
    62.             ResponseResult responseResult = saveAppArticle(wmNews);
    63.             if(!responseResult.getCode().equals(200)){
    64.                 throw new RuntimeException("WmNewsAutoScanServiceImpl-文章审核，保存app端相关文章数据失败");
    65.             }
    66.             //回填article_id
    67.             wmNews.setArticleId((Long) responseResult.getData());
    68.             updateWmNews(wmNews,(short) 9,"审核成功");
    69. ​
    70.         }
    71.     }
    72. ​
    73.     @Autowired
    74.     private IArticleClient articleClient;
    75. ​
    76.     @Autowired
    77.     private WmChannelMapper wmChannelMapper;
    78. ​
    79.     @Autowired
    80.     private WmUserMapper wmUserMapper;
    81. ​
    82.     /**
    83.      * 保存app端相关的文章数据
    84.      * @param wmNews
    85.      */
    86.     private ResponseResult saveAppArticle(WmNews wmNews) {
    87. ​
    88.         ArticleDto dto = new ArticleDto();
    89.         //属性的拷贝
    90.         BeanUtils.copyProperties(wmNews,dto);
    91.         //文章的布局
    92.         dto.setLayout(wmNews.getType());
    93.         //频道
    94.         WmChannel wmChannel = wmChannelMapper.selectById(wmNews.getChannelId());
    95.         if(wmChannel != null){
    96.             dto.setChannelName(wmChannel.getName());
    97.         }
    98. ​
    99.         //作者
    100.         dto.setAuthorId(wmNews.getUserId().longValue());
    101.         WmUser wmUser = wmUserMapper.selectById(wmNews.getUserId());
    102.         if(wmUser != null){
    103.             dto.setAuthorName(wmUser.getName());
    104.         }
    105. ​
    106.         //设置文章id
    107.         if(wmNews.getArticleId() != null){
    108.             dto.setId(wmNews.getArticleId());
    109.         }
    110.         dto.setCreatedTime(new Date());
    111. ​
    112.         ResponseResult responseResult = articleClient.saveArticle(dto);
    113.         return responseResult;
    114. ​
    115.     }
    116. ​
    117. ​
    118.     @Autowired
    119.     private FileStorageService fileStorageService;
    120. ​
    121.     @Autowired
    122.     private GreenImageScan greenImageScan;
    123. ​
    124.     /**
    125.      * 审核图片
    126.      * @param images
    127.      * @param wmNews
    128.      * @return
    129.      */
    130.     private boolean handleImageScan(List images, WmNews wmNews) {
    131. ​
    132.         boolean flag = true;
    133. ​
    134.         if(images == null || images.size() == 0){
    135.             return flag;
    136.         }
    137. ​
    138.         //下载图片 minIO
    139.         //图片去重
    140.         images = images.stream().distinct().collect(Collectors.toList());
    141. ​
    142.         List<byte[]> imageList = new ArrayList<>();
    143. ​
    144.         for (String image : images) {
    145.             byte[] bytes = fileStorageService.downLoadFile(image);
    146.             imageList.add(bytes);
    147.         }
    148. ​
    149. ​
    150.         //审核图片
    151.         try {
    152.             Map map = greenImageScan.imageScan(imageList);
    153.             if(map != null){
    154.                 //审核失败
    155.                 if(map.get("suggestion").equals("block")){
    156.                     flag = false;
    157.                     updateWmNews(wmNews, (short) 2, "当前文章中存在违规内容");
    158.                 }
    159. ​
    160.                 //不确定信息  需要人工审核
    161.                 if(map.get("suggestion").equals("review")){
    162.                     flag = false;
    163.                     updateWmNews(wmNews, (short) 3, "当前文章中存在不确定内容");
    164.                 }
    165.             }
    166. ​
    167.         } catch (Exception e) {
    168.             flag = false;
    169.             e.printStackTrace();
    170.         }
    171.         return flag;
    172.     }
    173. ​
    174.     @Autowired
    175.     private GreenTextScan greenTextScan;
    176. ​
    177.     /**
    178.      * 审核纯文本内容
    179.      * @param content
    180.      * @param wmNews
    181.      * @return
    182.      */
    183.     private boolean handleTextScan(String content, WmNews wmNews) {
    184. ​
    185.         boolean flag = true;
    186. ​
    187.         if((wmNews.getTitle()+"-"+content).length() == 0){
    188.             return flag;
    189.         }
    190. ​
    191.         try {
    192.             Map map = greenTextScan.greeTextScan((wmNews.getTitle()+"-"+content));
    193.             if(map != null){
    194.                 //审核失败
    195.                 if(map.get("suggestion").equals("block")){
    196.                     flag = false;
    197.                     updateWmNews(wmNews, (short) 2, "当前文章中存在违规内容");
    198.                 }
    199. ​
    200.                 //不确定信息  需要人工审核
    201.                 if(map.get("suggestion").equals("review")){
    202.                     flag = false;
    203.                     updateWmNews(wmNews, (short) 3, "当前文章中存在不确定内容");
    204.                 }
    205.             }
    206.         } catch (Exception e) {
    207.             flag = false;
    208.             e.printStackTrace();
    209.         }
    210. ​
    211.         return flag;
    212. ​
    213.     }
    214. ​
    215.     /**
    216.      * 修改文章内容
    217.      * @param wmNews
    218.      * @param status
    219.      * @param reason
    220.      */
    221.     private void updateWmNews(WmNews wmNews, short status, String reason) {
    222.         wmNews.setStatus(status);
    223.         wmNews.setReason(reason);
    224.         wmNewsMapper.updateById(wmNews);
    225.     }
    226. ​
    227.     /**
    228.      * 1。从自媒体文章的内容中提取文本和图片
    229.      * 2.提取文章的封面图片
    230.      * @param wmNews
    231.      * @return
    232.      */
    233.     private Map handleTextAndImages(WmNews wmNews) {
    234. ​
    235.         //存储纯文本内容
    236.         StringBuilder stringBuilder = new StringBuilder();
    237. ​
    238.         List images = new ArrayList<>();
    239. ​
    240.         //1。从自媒体文章的内容中提取文本和图片
    241.         if(StringUtils.isNotBlank(wmNews.getContent())){
    242.             List maps = JSONArray.parseArray(wmNews.getContent(), Map.class);
    243.             for (Map map : maps) {
    244.                 if (map.get("type").equals("text")){
    245.                     stringBuilder.append(map.get("value"));
    246.                 }
    247. ​
    248.                 if (map.get("type").equals("image")){
    249.                     images.add((String) map.get("value"));
    250.                 }
    251.             }
    252.         }
    253.         //2.提取文章的封面图片
    254.         if(StringUtils.isNotBlank(wmNews.getImages())){
    255.             String[] split = wmNews.getImages().split(",");
    256.             images.addAll(Arrays.asList(split));
    257.         }
    258. ​
    259.         Map resultMap = new HashMap<>();
    260.         resultMap.put("content",stringBuilder.toString());
    261.         resultMap.put("images",images);
    262.         return resultMap;
    263. ​
    264.     }
    265. }
    4.3)单元测试
    1. package com.kjz.wemedia.service;
    2. ​
    3. import com.heima.wemedia.WemediaApplication;
    4. import org.junit.Test;
    5. import org.junit.runner.RunWith;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.boot.test.context.SpringBootTest;
    8. import org.springframework.test.context.junit4.SpringRunner;
    9. ​
    10. import static org.junit.Assert.*;
    11. ​
    12. ​
    13. @SpringBootTest(classes = WemediaApplication.class)
    14. @RunWith(SpringRunner.class)
    15. public class WmNewsAutoScanServiceTest {
    16. ​
    17.     @Autowired
    18.     private WmNewsAutoScanService wmNewsAutoScanService;
    19. ​
    20.     @Test
    21.     public void autoScanWmNews() {
    22. ​
    23.         wmNewsAutoScanService.autoScanWmNews(6238);
    24.     }
    25. }
    4.4)feign远程接口调用方式

    在heima-leadnews-wemedia服务中已经依赖了heima-leadnews-feign-apis工程，只需要在自媒体的引导类中开启feign的远程调用即可

    注解为：@EnableFeignClients(basePackages = "com.heima.apis") 需要指向apis这个包

    4.5)服务降级处理

    • 服务降级是服务自我保护的一种方式，或者保护下游服务的一种方式，用于确保服务不会受请求突增影响变得不可用，确保服务不会崩溃

    • 服务降级虽然会导致请求失败，但是不会导致阻塞。

    实现步骤：

    ①：在heima-leadnews-feign-api编写降级逻辑

    1. package com.heima.apis.article.fallback;
    2. ​
    3. import com.heima.apis.article.IArticleClient;
    4. import com.heima.model.article.dtos.ArticleDto;
    5. import com.heima.model.common.dtos.ResponseResult;
    6. import com.heima.model.common.enums.AppHttpCodeEnum;
    7. import org.springframework.stereotype.Component;
    8. ​
    9. /**
    10.  * feign失败配置
    11.  * @author itheima
    12.  */
    13. @Component
    14. public class IArticleClientFallback implements IArticleClient {
    15.     @Override
    16.     public ResponseResult saveArticle(ArticleDto dto)  {
    17.         return ResponseResult.errorResult(AppHttpCodeEnum.SERVER_ERROR,"获取数据失败");
    18.     }
    19. }

    在自媒体微服务中添加类，扫描降级代码类的包

    1. package com.heima.wemedia.config;
    2. ​
    3. import org.springframework.context.annotation.ComponentScan;
    4. import org.springframework.context.annotation.Configuration;
    5. ​
    6. @Configuration
    7. @ComponentScan("com.heima.apis.article.fallback")
    8. public class InitConfig {
    9. }

    ②：远程接口中指向降级代码

    1. package com.heima.apis.article;
    2. ​
    3. import com.heima.apis.article.fallback.IArticleClientFallback;
    4. import com.heima.model.article.dtos.ArticleDto;
    5. import com.heima.model.common.dtos.ResponseResult;
    6. import org.springframework.cloud.openfeign.FeignClient;
    7. import org.springframework.web.bind.annotation.PostMapping;
    8. import org.springframework.web.bind.annotation.RequestBody;
    9. ​
    10. @FeignClient(value = "leadnews-article",fallback = IArticleClientFallback.class)
    11. public interface IArticleClient {
    12. ​
    13.     @PostMapping("/api/v1/article/save")
    14.     public ResponseResult saveArticle(@RequestBody ArticleDto dto);
    15. }

    ③：客户端开启降级heima-leadnews-wemedia

    在wemedia的nacos配置中心里添加如下内容，开启服务降级，也可以指定服务响应的超时的时间

    1. feign:
    2.   # 开启feign对hystrix熔断降级的支持
    3.   hystrix:
    4.     enabled: true
    5.   # 修改调用超时时间
    6.   client:
    7.     config:
    8.       default:
    9.         connectTimeout: 2000
    10.         readTimeout: 2000

    ④：测试

    在ApArticleServiceImpl类中saveArticle方法添加代码

    1. try {
    2.     Thread.sleep(3000);
    3. } catch (InterruptedException e) {
    4.     e.printStackTrace();
    5. }

    在自媒体端进行审核测试，会出现服务降级的现象

    5)发布文章提交审核集成

    5.1)同步调用与异步调用

    同步：就是在发出一个调用时，在没有得到结果之前， 该调用就不返回（实时处理）

    异步：调用在发出之后，这个调用就直接返回了，没有返回结果（分时处理）

    异步线程的方式审核文章

    5.2)Springboot集成异步线程调用

    ①：在自动审核的方法上加上@Async注解（标明要异步调用）

    1. @Override
    2. @Async  //标明当前方法是一个异步方法
    3. public void autoScanWmNews(Integer id) {
    4.     //代码略
    5. }

    ②：在文章发布成功后调用审核的方法

    1. @Autowired
    2. private WmNewsAutoScanService wmNewsAutoScanService;
    3. ​
    4. /**
    5.  * 发布修改文章或保存为草稿
    6.  * @param dto
    7.  * @return
    8.  */
    9. @Override
    10. public ResponseResult submitNews(WmNewsDto dto) {
    11. ​
    12.     //代码略
    13. ​
    14.     //审核文章
    15.     wmNewsAutoScanService.autoScanWmNews(wmNews.getId());
    16. ​
    17.     return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
    18. ​
    19. }

    ③：在自媒体引导类中使用@EnableAsync注解开启异步调用

    1. @SpringBootApplication
    2. @EnableDiscoveryClient
    3. @MapperScan("com.heima.wemedia.mapper")
    4. @EnableFeignClients(basePackages = "com.heima.apis")
    5. @EnableAsync  //开启异步调用
    6. public class WemediaApplication {
    7. ​
    8.     public static void main(String[] args) {
    9.         SpringApplication.run(WemediaApplication.class,args);
    10.     }
    11. ​
    12.     @Bean
    13.     public MybatisPlusInterceptor mybatisPlusInterceptor() {
    14.         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    15.         interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
    16.         return interceptor;
    17.     }
    18. }

    6)文章审核功能-综合测试

    6.1)服务启动列表

    1，nacos服务端

    2，article微服务

    3，wemedia微服务

    4，启动wemedia网关微服务

    5，启动前端系统wemedia

    6.2)测试情况列表

    1，自媒体前端发布一篇正常的文章

    审核成功后，app端的article相关数据是否可以正常保存，自媒体文章状态和app端文章id是否回显

    2，自媒体前端发布一篇包含敏感词的文章

    正常是审核失败， wm_news表中的状态是否改变，成功和失败原因正常保存

    3，自媒体前端发布一篇包含敏感图片的文章

    正常是审核失败， wm_news表中的状态是否改变，成功和失败原因正常保存

    7)新需求-自管理敏感词

    7.1)需求分析

    文章审核功能已经交付了，文章也能正常发布审核。突然，产品经理过来说要开会。

    会议的内容核心有以下内容：

    • 文章审核不能过滤一些敏感词：

      私人侦探、针孔摄象、信用卡提现、广告代理、代开发票、刻章办、出售答案、小额贷款…

    需要完成的功能：

    需要自己维护一套敏感词，在文章审核的时候，需要验证文章是否包含这些敏感词

    7.2)敏感词-过滤

    技术选型

    方案说明
    数据库模糊查询效率太低
    String.indexOf("")查找数据量大的话也是比较慢
    全文检索分词再匹配
    DFA算法确定有穷自动机(一种数据结构)
    7.3)DFA实现原理

    DFA全称为：Deterministic Finite Automaton,即确定有穷自动机。

    存储：一次性的把所有的敏感词存储到了多个map中，就是下图表示这种结构

    敏感词：冰毒、大麻、大坏蛋

    检索的过程

    7.4)自管理敏感词集成到文章审核中

    ①：创建敏感词表，导入资料中wm_sensitive到leadnews_wemedia库中

    1. package com.heima.model.wemedia.pojos;
    2. ​
    3. import com.baomidou.mybatisplus.annotation.IdType;
    4. import com.baomidou.mybatisplus.annotation.TableField;
    5. import com.baomidou.mybatisplus.annotation.TableId;
    6. import com.baomidou.mybatisplus.annotation.TableName;
    7. import lombok.Data;
    8. ​
    9. import java.io.Serializable;
    10. import java.util.Date;
    11. ​
    12. /**
    13.  * 
    14.  * 敏感词信息表
    15.  * 
    16.  *
    17.  * @author itheima
    18.  */
    19. @Data
    20. @TableName("wm_sensitive")
    21. public class WmSensitive implements Serializable {
    22. ​
    23.     private static final long serialVersionUID = 1L;
    24. ​
    25.     /**
    26.      * 主键
    27.      */
    28.     @TableId(value = "id", type = IdType.AUTO)
    29.     private Integer id;
    30. ​
    31.     /**
    32.      * 敏感词
    33.      */
    34.     @TableField("sensitives")
    35.     private String sensitives;
    36. ​
    37.     /**
    38.      * 创建时间
    39.      */
    40.     @TableField("created_time")
    41.     private Date createdTime;
    42. ​
    43. }

    ②：拷贝对应的wm_sensitive的mapper到项目中

    1. package com.heima.wemedia.mapper;
    2. ​
    3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    4. import com.heima.model.wemedia.pojos.WmSensitive;
    5. import org.apache.ibatis.annotations.Mapper;
    6. ​
    7. ​
    8. @Mapper
    9. public interface WmSensitiveMapper extends BaseMapper {
    10. }

    ③：在文章审核的代码中添加自管理敏感词审核

    第一：在WmNewsAutoScanServiceImpl中的autoScanWmNews方法上添加如下代码

    1. //从内容中提取纯文本内容和图片
    2. //.....省略
    3. ​
    4. //自管理的敏感词过滤
    5. boolean isSensitive = handleSensitiveScan((String) textAndImages.get("content"), wmNews);
    6. if(!isSensitive) return;
    7. ​
    8. //2.审核文本内容  阿里云接口
    9. //.....省略

    新增自管理敏感词审核代码

    1. @Autowired
    2. private WmSensitiveMapper wmSensitiveMapper;
    3. ​
    4. /**
    5.      * 自管理的敏感词审核
    6.      * @param content
    7.      * @param wmNews
    8.      * @return
    9.      */
    10. private boolean handleSensitiveScan(String content, WmNews wmNews) {
    11. ​
    12.     boolean flag = true;
    13. ​
    14.     //获取所有的敏感词
    15.     List wmSensitives = wmSensitiveMapper.selectList(Wrappers.lambdaQuery().select(WmSensitive::getSensitives));
    16.     List sensitiveList = wmSensitives.stream().map(WmSensitive::getSensitives).collect(Collectors.toList());
    17. ​
    18.     //初始化敏感词库
    19.     SensitiveWordUtil.initMap(sensitiveList);
    20. ​
    21.     //查看文章中是否包含敏感词
    22.     Map map = SensitiveWordUtil.matchWords(content);
    23.     if(map.size() >0){
    24.         updateWmNews(wmNews,(short) 2,"当前文章中存在违规内容"+map);
    25.         flag = false;
    26.     }
    27. ​
    28.     return flag;
    29. }

    8)新需求-图片识别文字审核敏感词

    8.1)需求分析

    产品经理召集开会，文章审核功能已经交付了，文章也能正常发布审核。对于上次提出的自管理敏感词也很满意，这次会议核心的内容如下：

    • 文章中包含的图片要识别文字，过滤掉图片文字的敏感词

    8.2)图片文字识别

    什么是OCR?

    OCR （Optical Character Recognition，光学字符识别）是指电子设备（例如扫描仪或数码相机）检查纸上打印的字符，通过检测暗、亮的模式确定其形状，然后用字符识别方法将形状翻译成计算机文字的过程

    方案说明
    百度OCR收费
    Tesseract-OCRGoogle维护的开源OCR引擎，支持Java，Python等语言调用
    Tess4J封装了Tesseract-OCR ，支持Java调用
    8.3)Tess4j案例

    ①：创建项目导入tess4j对应的依赖

    2.     net.sourceforge.tess4j
    3.     tess4j
    4.     4.1.1

    ②：导入中文字体库， 把资料中的tessdata文件夹拷贝到自己的工作空间下

    ③：编写测试类进行测试

    1. package com.heima.tess4j;
    2. ​
    3. import net.sourceforge.tess4j.ITesseract;
    4. import net.sourceforge.tess4j.Tesseract;
    5. ​
    6. import java.io.File;
    7. ​
    8. public class Application {
    9. ​
    10.     public static void main(String[] args) {
    11.         try {
    12.             //获取本地图片
    13.             File file = new File("D:\\26.png");
    14.             //创建Tesseract对象
    15.             ITesseract tesseract = new Tesseract();
    16.             //设置字体库路径
    17.             tesseract.setDatapath("D:\\workspace\\tessdata");
    18.             //中文识别
    19.             tesseract.setLanguage("chi_sim");
    20.             //执行ocr识别
    21.             String result = tesseract.doOCR(file);
    22.             //替换回车和tal键  使结果为一行
    23.             result = result.replaceAll("\\r|\\n","-").replaceAll(" ","");
    24.             System.out.println("识别的结果为："+result);
    25.         } catch (Exception e) {
    26.             e.printStackTrace();
    27.         }
    28.     }
    29. }
    8.4)管理敏感词和图片文字识别集成到文章审核

    ①：在heima-leadnews-common中创建工具类，简单封装一下tess4j

    需要先导入pom

    1. <dependency>
    2.     <groupId>net.sourceforge.tess4jgroupId>
    3.     <artifactId>tess4jartifactId>
    4.     <version>4.1.1version>
    5. dependency>

    工具类

    1. package com.heima.common.tess4j;
    2. ​
    3. import lombok.Getter;
    4. import lombok.Setter;
    5. import net.sourceforge.tess4j.ITesseract;
    6. import net.sourceforge.tess4j.Tesseract;
    7. import net.sourceforge.tess4j.TesseractException;
    8. import org.springframework.boot.context.properties.ConfigurationProperties;
    9. import org.springframework.stereotype.Component;
    10. ​
    11. import java.awt.image.BufferedImage;
    12. ​
    13. @Getter
    14. @Setter
    15. @Component
    16. @ConfigurationProperties(prefix = "tess4j")
    17. public class Tess4jClient {
    18. ​
    19.     private String dataPath;
    20.     private String language;
    21. ​
    22.     public String doOCR(BufferedImage image) throws TesseractException {
    23.         //创建Tesseract对象
    24.         ITesseract tesseract = new Tesseract();
    25.         //设置字体库路径
    26.         tesseract.setDatapath(dataPath);
    27.         //中文识别
    28.         tesseract.setLanguage(language);
    29.         //执行ocr识别
    30.         String result = tesseract.doOCR(image);
    31.         //替换回车和tal键  使结果为一行
    32.         result = result.replaceAll("\\r|\\n", "-").replaceAll(" ", "");
    33.         return result;
    34.     }
    35. ​
    36. }

    在spring.factories配置中添加该类,完整如下：

    1. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    2.   com.heima.common.exception.ExceptionCatch,\
    3.   com.heima.common.swagger.SwaggerConfiguration,\
    4.   com.heima.common.swagger.Swagger2Configuration,\
    5.   com.heima.common.aliyun.GreenTextScan,\
    6.   com.heima.common.aliyun.GreenImageScan,\
    7.   com.heima.common.tess4j.Tess4jClient

    ②：在heima-leadnews-wemedia中的配置中添加两个属性

    1. tess4j:
    2.   data-path: D:\workspace\tessdata
    3.   language: chi_sim

    ③：在WmNewsAutoScanServiceImpl中的handleImageScan方法上添加如下代码

    1. try {
    2.     for (String image : images) {
    3.         byte[] bytes = fileStorageService.downLoadFile(image);
    4. ​
    5.         //图片识别文字审核---begin-----
    6. ​
    7.         //从byte[]转换为butteredImage
    8.         ByteArrayInputStream in = new ByteArrayInputStream(bytes);
    9.         BufferedImage imageFile = ImageIO.read(in);
    10.         //识别图片的文字
    11.         String result = tess4jClient.doOCR(imageFile);
    12. ​
    13.         //审核是否包含自管理的敏感词
    14.         boolean isSensitive = handleSensitiveScan(result, wmNews);
    15.         if(!isSensitive){
    16.             return isSensitive;
    17.         }
    18. ​
    19.         //图片识别文字审核---end-----
    20. ​
    21. ​
    22.         imageList.add(bytes);
    23. ​
    24.     } 
    25. }catch (Exception e){
    26.     e.printStackTrace();
    27. }

    最后附上文章审核的完整代码如下：

    1. package com.heima.wemedia.service.impl;
    2. ​
    3. import com.alibaba.fastjson.JSONArray;
    4. import com.baomidou.mybatisplus.core.toolkit.Wrappers;
    5. import com.heima.apis.article.IArticleClient;
    6. import com.heima.common.aliyun.GreenImageScan;
    7. import com.heima.common.aliyun.GreenTextScan;
    8. import com.heima.common.tess4j.Tess4jClient;
    9. import com.heima.file.service.FileStorageService;
    10. import com.heima.model.article.dtos.ArticleDto;
    11. import com.heima.model.common.dtos.ResponseResult;
    12. import com.heima.model.wemedia.pojos.WmChannel;
    13. import com.heima.model.wemedia.pojos.WmNews;
    14. import com.heima.model.wemedia.pojos.WmSensitive;
    15. import com.heima.model.wemedia.pojos.WmUser;
    16. import com.heima.utils.common.SensitiveWordUtil;
    17. import com.heima.wemedia.mapper.WmChannelMapper;
    18. import com.heima.wemedia.mapper.WmNewsMapper;
    19. import com.heima.wemedia.mapper.WmSensitiveMapper;
    20. import com.heima.wemedia.mapper.WmUserMapper;
    21. import com.heima.wemedia.service.WmNewsAutoScanService;
    22. import lombok.extern.slf4j.Slf4j;
    23. import org.apache.commons.lang3.StringUtils;
    24. import org.springframework.beans.BeanUtils;
    25. import org.springframework.beans.factory.annotation.Autowired;
    26. import org.springframework.scheduling.annotation.Async;
    27. import org.springframework.stereotype.Service;
    28. import org.springframework.transaction.annotation.Transactional;
    29. ​
    30. import javax.imageio.ImageIO;
    31. import java.awt.image.BufferedImage;
    32. import java.io.ByteArrayInputStream;
    33. import java.util.*;
    34. import java.util.stream.Collectors;
    35. ​
    36. ​
    37. @Service
    38. @Slf4j
    39. @Transactional
    40. public class WmNewsAutoScanServiceImpl implements WmNewsAutoScanService {
    41. ​
    42.     @Autowired
    43.     private WmNewsMapper wmNewsMapper;
    44. ​
    45.     /**
    46.      * 自媒体文章审核
    47.      *
    48.      * @param id 自媒体文章id
    49.      */
    50.     @Override
    51.     @Async  //标明当前方法是一个异步方法
    52.     public void autoScanWmNews(Integer id) {
    53. ​
    54. //        int a = 1/0;
    55. ​
    56.         //1.查询自媒体文章
    57.         WmNews wmNews = wmNewsMapper.selectById(id);
    58.         if (wmNews == null) {
    59.             throw new RuntimeException("WmNewsAutoScanServiceImpl-文章不存在");
    60.         }
    61. ​
    62.         if (wmNews.getStatus().equals(WmNews.Status.SUBMIT.getCode())) {
    63.             //从内容中提取纯文本内容和图片
    64.             Map textAndImages = handleTextAndImages(wmNews);
    65. ​
    66.             //自管理的敏感词过滤
    67.             boolean isSensitive = handleSensitiveScan((String) textAndImages.get("content"), wmNews);
    68.             if(!isSensitive) return;
    69. ​
    70.             //2.审核文本内容  阿里云接口
    71.             boolean isTextScan = handleTextScan((String) textAndImages.get("content"), wmNews);
    72.             if (!isTextScan) return;
    73. ​
    74.             //3.审核图片  阿里云接口
    75.             boolean isImageScan = handleImageScan((List) textAndImages.get("images"), wmNews);
    76.             if (!isImageScan) return;
    77. ​
    78.             //4.审核成功，保存app端的相关的文章数据
    79.             ResponseResult responseResult = saveAppArticle(wmNews);
    80.             if (!responseResult.getCode().equals(200)) {
    81.                 throw new RuntimeException("WmNewsAutoScanServiceImpl-文章审核，保存app端相关文章数据失败");
    82.             }
    83.             //回填article_id
    84.             wmNews.setArticleId((Long) responseResult.getData());
    85.             updateWmNews(wmNews, (short) 9, "审核成功");
    86. ​
    87.         }
    88.     }
    89. ​
    90.     @Autowired
    91.     private WmSensitiveMapper wmSensitiveMapper;
    92. ​
    93.     /**
    94.      * 自管理的敏感词审核
    95.      * @param content
    96.      * @param wmNews
    97.      * @return
    98.      */
    99.     private boolean handleSensitiveScan(String content, WmNews wmNews) {
    100. ​
    101.         boolean flag = true;
    102. ​
    103.         //获取所有的敏感词
    104.         List wmSensitives = wmSensitiveMapper.selectList(Wrappers.lambdaQuery().select(WmSensitive::getSensitives));
    105.         List sensitiveList = wmSensitives.stream().map(WmSensitive::getSensitives).collect(Collectors.toList());
    106. ​
    107.         //初始化敏感词库
    108.         SensitiveWordUtil.initMap(sensitiveList);
    109. ​
    110.         //查看文章中是否包含敏感词
    111.         Map map = SensitiveWordUtil.matchWords(content);
    112.         if(map.size() >0){
    113.             updateWmNews(wmNews,(short) 2,"当前文章中存在违规内容"+map);
    114.             flag = false;
    115.         }
    116. ​
    117.         return flag;
    118.     }
    119. ​
    120.     @Autowired
    121.     private IArticleClient articleClient;
    122. ​
    123.     @Autowired
    124.     private WmChannelMapper wmChannelMapper;
    125. ​
    126.     @Autowired
    127.     private WmUserMapper wmUserMapper;
    128. ​
    129.     /**
    130.      * 保存app端相关的文章数据
    131.      *
    132.      * @param wmNews
    133.      */
    134.     private ResponseResult saveAppArticle(WmNews wmNews) {
    135. ​
    136.         ArticleDto dto = new ArticleDto();
    137.         //属性的拷贝
    138.         BeanUtils.copyProperties(wmNews, dto);
    139.         //文章的布局
    140.         dto.setLayout(wmNews.getType());
    141.         //频道
    142.         WmChannel wmChannel = wmChannelMapper.selectById(wmNews.getChannelId());
    143.         if (wmChannel != null) {
    144.             dto.setChannelName(wmChannel.getName());
    145.         }
    146. ​
    147.         //作者
    148.         dto.setAuthorId(wmNews.getUserId().longValue());
    149.         WmUser wmUser = wmUserMapper.selectById(wmNews.getUserId());
    150.         if (wmUser != null) {
    151.             dto.setAuthorName(wmUser.getName());
    152.         }
    153. ​
    154.         //设置文章id
    155.         if (wmNews.getArticleId() != null) {
    156.             dto.setId(wmNews.getArticleId());
    157.         }
    158.         dto.setCreatedTime(new Date());
    159. ​
    160.         ResponseResult responseResult = articleClient.saveArticle(dto);
    161.         return responseResult;
    162. ​
    163.     }
    164. ​
    165. ​
    166.     @Autowired
    167.     private FileStorageService fileStorageService;
    168. ​
    169.     @Autowired
    170.     private GreenImageScan greenImageScan;
    171. ​
    172.     @Autowired
    173.     private Tess4jClient tess4jClient;
    174. ​
    175.     /**
    176.      * 审核图片
    177.      *
    178.      * @param images
    179.      * @param wmNews
    180.      * @return
    181.      */
    182.     private boolean handleImageScan(List images, WmNews wmNews) {
    183. ​
    184.         boolean flag = true;
    185. ​
    186.         if (images == null || images.size() == 0) {
    187.             return flag;
    188.         }
    189. ​
    190.         //下载图片 minIO
    191.         //图片去重
    192.         images = images.stream().distinct().collect(Collectors.toList());
    193. ​
    194.         List<byte[]> imageList = new ArrayList<>();
    195. ​
    196.         try {
    197.             for (String image : images) {
    198.                 byte[] bytes = fileStorageService.downLoadFile(image);
    199. ​
    200.                 //图片识别文字审核---begin-----
    201. ​
    202.                 //从byte[]转换为butteredImage
    203.                 ByteArrayInputStream in = new ByteArrayInputStream(bytes);
    204.                 BufferedImage imageFile = ImageIO.read(in);
    205.                 //识别图片的文字
    206.                 String result = tess4jClient.doOCR(imageFile);
    207. ​
    208.                 //审核是否包含自管理的敏感词
    209.                 boolean isSensitive = handleSensitiveScan(result, wmNews);
    210.                 if(!isSensitive){
    211.                     return isSensitive;
    212.                 }
    213. ​
    214.                 //图片识别文字审核---end-----
    215. ​
    216. ​
    217.                 imageList.add(bytes);
    218. ​
    219.             }
    220.         }catch (Exception e){
    221.             e.printStackTrace();
    222.         }
    223. ​
    224. ​
    225.         //审核图片
    226.         try {
    227.             Map map = greenImageScan.imageScan(imageList);
    228.             if (map != null) {
    229.                 //审核失败
    230.                 if (map.get("suggestion").equals("block")) {
    231.                     flag = false;
    232.                     updateWmNews(wmNews, (short) 2, "当前文章中存在违规内容");
    233.                 }
    234. ​
    235.                 //不确定信息  需要人工审核
    236.                 if (map.get("suggestion").equals("review")) {
    237.                     flag = false;
    238.                     updateWmNews(wmNews, (short) 3, "当前文章中存在不确定内容");
    239.                 }
    240.             }
    241. ​
    242.         } catch (Exception e) {
    243.             flag = false;
    244.             e.printStackTrace();
    245.         }
    246.         return flag;
    247.     }
    248. ​
    249.     @Autowired
    250.     private GreenTextScan greenTextScan;
    251. ​
    252.     /**
    253.      * 审核纯文本内容
    254.      *
    255.      * @param content
    256.      * @param wmNews
    257.      * @return
    258.      */
    259.     private boolean handleTextScan(String content, WmNews wmNews) {
    260. ​
    261.         boolean flag = true;
    262. ​
    263.         if ((wmNews.getTitle() + "-" + content).length() == 0) {
    264.             return flag;
    265.         }
    266.         try {
    267.             Map map = greenTextScan.greeTextScan((wmNews.getTitle() + "-" + content));
    268.             if (map != null) {
    269.                 //审核失败
    270.                 if (map.get("suggestion").equals("block")) {
    271.                     flag = false;
    272.                     updateWmNews(wmNews, (short) 2, "当前文章中存在违规内容");
    273.                 }
    274. ​
    275.                 //不确定信息  需要人工审核
    276.                 if (map.get("suggestion").equals("review")) {
    277.                     flag = false;
    278.                     updateWmNews(wmNews, (short) 3, "当前文章中存在不确定内容");
    279.                 }
    280.             }
    281.         } catch (Exception e) {
    282.             flag = false;
    283.             e.printStackTrace();
    284.         }
    285. ​
    286.         return flag;
    287. ​
    288.     }
    289. ​
    290.     /**
    291.      * 修改文章内容
    292.      *
    293.      * @param wmNews
    294.      * @param status
    295.      * @param reason
    296.      */
    297.     private void updateWmNews(WmNews wmNews, short status, String reason) {
    298.         wmNews.setStatus(status);
    299.         wmNews.setReason(reason);
    300.         wmNewsMapper.updateById(wmNews);
    301.     }
    302. ​
    303.     /**
    304.      * 1。从自媒体文章的内容中提取文本和图片
    305.      * 2.提取文章的封面图片
    306.      *
    307.      * @param wmNews
    308.      * @return
    309.      */
    310.     private Map handleTextAndImages(WmNews wmNews) {
    311. ​
    312.         //存储纯文本内容
    313.         StringBuilder stringBuilder = new StringBuilder();
    314. ​
    315.         List images = new ArrayList<>();
    316. ​
    317.         //1。从自媒体文章的内容中提取文本和图片
    318.         if (StringUtils.isNotBlank(wmNews.getContent())) {
    319.             List maps = JSONArray.parseArray(wmNews.getContent(), Map.class);
    320.             for (Map map : maps) {
    321.                 if (map.get("type").equals("text")) {
    322.                     stringBuilder.append(map.get("value"));
    323.                 }
    324. ​
    325.                 if (map.get("type").equals("image")) {
    326.                     images.add((String) map.get("value"));
    327.                 }
    328.             }
    329.         }
    330.         //2.提取文章的封面图片
    331.         if (StringUtils.isNotBlank(wmNews.getImages())) {
    332.             String[] split = wmNews.getImages().split(",");
    333.             images.addAll(Arrays.asList(split));
    334.         }
    335. ​
    336.         Map resultMap = new HashMap<>();
    337.         resultMap.put("content", stringBuilder.toString());
    338.         resultMap.put("images", images);
    339.         return resultMap;
    340. ​
    341.     }
    342. }

    9)文章详情-静态文件生成

    9.1)思路分析

    文章端创建app相关文章时，生成文章详情静态页上传到MinIO中

    9.2)实现步骤

    1.新建ArticleFreemarkerService创建静态文件并上传到minIO中

    1. package com.heima.article.service;
    2. ​
    3. import com.heima.model.article.pojos.ApArticle;
    4. ​
    5. public interface ArticleFreemarkerService {
    6. ​
    7.     /**
    8.      * 生成静态文件上传到minIO中
    9.      * @param apArticle
    10.      * @param content
    11.      */
    12.     public void buildArticleToMinIO(ApArticle apArticle,String content);
    13. }

    实现

    1. package com.heima.article.service.impl;
    2. ​
    3. import com.alibaba.fastjson.JSON;
    4. import com.alibaba.fastjson.JSONArray;
    5. import com.baomidou.mybatisplus.core.toolkit.Wrappers;
    6. import com.heima.article.mapper.ApArticleContentMapper;
    7. import com.heima.article.service.ApArticleService;
    8. import com.heima.article.service.ArticleFreemarkerService;
    9. import com.heima.file.service.FileStorageService;
    10. import com.heima.model.article.pojos.ApArticle;
    11. import freemarker.template.Configuration;
    12. import freemarker.template.Template;
    13. import lombok.extern.slf4j.Slf4j;
    14. import org.apache.commons.lang3.StringUtils;
    15. import org.springframework.beans.BeanUtils;
    16. import org.springframework.beans.factory.annotation.Autowired;
    17. import org.springframework.scheduling.annotation.Async;
    18. import org.springframework.stereotype.Service;
    19. import org.springframework.transaction.annotation.Transactional;
    20. ​
    21. import java.io.ByteArrayInputStream;
    22. import java.io.InputStream;
    23. import java.io.StringWriter;
    24. import java.util.HashMap;
    25. import java.util.Map;
    26. ​
    27. @Service
    28. @Slf4j
    29. @Transactional
    30. public class ArticleFreemarkerServiceImpl implements ArticleFreemarkerService {
    31. ​
    32.     @Autowired
    33.     private ApArticleContentMapper apArticleContentMapper;
    34. ​
    35.     @Autowired
    36.     private Configuration configuration;
    37. ​
    38.     @Autowired
    39.     private FileStorageService fileStorageService;
    40. ​
    41.     @Autowired
    42.     private ApArticleService apArticleService;
    43. ​
    44.     /**
    45.      * 生成静态文件上传到minIO中
    46.      * @param apArticle
    47.      * @param content
    48.      */
    49.     @Async
    50.     @Override
    51.     public void buildArticleToMinIO(ApArticle apArticle, String content) {
    52.         //已知文章的id
    53.         //4.1 获取文章内容
    54.         if(StringUtils.isNotBlank(content)){
    55.             //4.2 文章内容通过freemarker生成html文件
    56.             Template template = null;
    57.             StringWriter out = new StringWriter();
    58.             try {
    59.                 template = configuration.getTemplate("article.ftl");
    60.                 //数据模型
    61.                 Map contentDataModel = new HashMap<>();
    62.                 contentDataModel.put("content", JSONArray.parseArray(content));
    63.                 //合成
    64.                 template.process(contentDataModel,out);
    65.             } catch (Exception e) {
    66.                 e.printStackTrace();
    67.             }
    68. ​
    69.             //4.3 把html文件上传到minio中
    70.             InputStream in = new ByteArrayInputStream(out.toString().getBytes());
    71.             String path = fileStorageService.uploadHtmlFile("", apArticle.getId() + ".html", in);
    72. ​
    73. ​
    74.             //4.4 修改ap_article表，保存static_url字段
    75.             apArticleService.update(Wrappers.lambdaUpdate().eq(ApArticle::getId,apArticle.getId())
    76.                     .set(ApArticle::getStaticUrl,path));
    77. ​
    78. ​
    79.         }
    80.     }
    81. ​
    82. }

    2.在ApArticleService的saveArticle实现方法中添加调用生成文件的方法

    1. /**
    2.      * 保存app端相关文章
    3.      * @param dto
    4.      * @return
    5.      */
    6. @Override
    7. public ResponseResult saveArticle(ArticleDto dto) {
    8. ​
    9.     //        try {
    10.     //            Thread.sleep(3000);
    11.     //        } catch (InterruptedException e) {
    12.     //            e.printStackTrace();
    13.     //        }
    14.     //1.检查参数
    15.     if(dto == null){
    16.         return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
    17.     }
    18. ​
    19.     ApArticle apArticle = new ApArticle();
    20.     BeanUtils.copyProperties(dto,apArticle);
    21. ​
    22.     //2.判断是否存在id
    23.     if(dto.getId() == null){
    24.         //2.1 不存在id  保存  文章  文章配置  文章内容
    25. ​
    26.         //保存文章
    27.         save(apArticle);
    28. ​
    29.         //保存配置
    30.         ApArticleConfig apArticleConfig = new ApArticleConfig(apArticle.getId());
    31.         apArticleConfigMapper.insert(apArticleConfig);
    32. ​
    33.         //保存 文章内容
    34.         ApArticleContent apArticleContent = new ApArticleContent();
    35.         apArticleContent.setArticleId(apArticle.getId());
    36.         apArticleContent.setContent(dto.getContent());
    37.         apArticleContentMapper.insert(apArticleContent);
    38. ​
    39.     }else {
    40.         //2.2 存在id   修改  文章  文章内容
    41. ​
    42.         //修改  文章
    43.         updateById(apArticle);
    44. ​
    45.         //修改文章内容
    46.         ApArticleContent apArticleContent = apArticleContentMapper.selectOne(Wrappers.lambdaQuery().eq(ApArticleContent::getArticleId, dto.getId()));
    47.         apArticleContent.setContent(dto.getContent());
    48.         apArticleContentMapper.updateById(apArticleContent);
    49.     }
    50. ​
    51.     //异步调用 生成静态文件上传到minio中
    52.     articleFreemarkerService.buildArticleToMinIO(apArticle,dto.getContent());
    53. ​
    54. ​
    55.     //3.结果返回  文章的id
    56.     return ResponseResult.okResult(apArticle.getId());
    57. }

    3.文章微服务开启异步调用

  • 相关阅读:
    java毕业设计——基于java+J2EE+sqlserver的音像店租赁管理系统设计与实现（毕业论文+程序源码）——租赁管理系统
    09 编译2022年最新的Linux kernel、U-Boot和BusyBox rootfs源码，并用QEMU模拟器运行
    ウクアージ / 小黑
    美团一面面经及详细答案
    208. 实现 Trie (前缀树)
    npm运行vue项目出现禁止运行脚本
    DS18B20U概述,VSC7429_VSC8572以太网(PHY)
    ptmalloc源码分析 - _int_malloc函数之largebins和Top chunk（08）
    Java技术学习|消息队列|初级RabbitMQ
    PIE：1979-2018年中国气温数据产品（空间分辨率为0.1º）
  • 原文地址：https://blog.csdn.net/m0_74229735/article/details/139723531