6.8

PAS/src/main/java/cn/cslg/pas/common/GlobalException.java

@@ -3,16 +3,20 @@ package cn.cslg.pas.common;
 import cn.cslg.pas.common.core.exception.PermissionException;
 import cn.cslg.pas.common.utils.Response;
 import cn.cslg.pas.common.utils.ResponseEnum;
+import cn.cslg.pas.exception.XiaoShiException;
 import cn.dev33.satoken.exception.NotLoginException;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
 
 /**
  * 全局异常处理
  */
+@Slf4j
 @RestControllerAdvice // 可指定包前缀，比如：(basePackages = "com.pj.admin")
 public class GlobalException {
 
@@ -30,4 +34,25 @@ public class GlobalException {
             return Response.error(ResponseEnum.SYSTEM_ERROR);
         }
     }
+
+    @ExceptionHandler
+    public Response handleXiaoShiException(XiaoShiException e) {
+        log.info("全局异常处理机制捕获到XiaoShiException，异常信息提示：{}", e.getMessage());
+        return Response.fail(e.getMessage());
+    }
+
+    @ExceptionHandler
+    public Response handleIOException(IOException e) {
+        log.info("全局异常处理机制捕获到IOException，异常信息打桩输出为：");
+        e.printStackTrace();
+        return Response.fail();
+    }
+
+    @ExceptionHandler
+    public Response handleThrowable(Throwable e) {
+        log.info("全局异常处理机制捕获到Throwable，异常信息打桩输出为：");
+        e.printStackTrace();
+        return Response.fail();
+    }
+
 }

PAS/src/main/java/cn/cslg/pas/common/core/CreateTaskThread.java

@@ -40,36 +40,37 @@ public class CreateTaskThread implements InitializingBean {
             pantentQueueService.queueAddTask(taskIds);
         }
 
-        //一个线程执行生产者
-        Thread threadProducer = new Thread(() -> {
-            pantentQueueService.addPatnetToQueue();
-        });
+        //生产者线程
+        Thread threadProducer = new Thread(pantentQueueService::addPatnetToQueue);
         threadProducer.start();
 
-        //一个线程执行消费者1（将专利信息从队列取出，摘要附图和著录项目入库）
+
+        //消费者1线程（摘要附图）
         Thread threadConsumer1 = new Thread(() -> {
             try {
-                pantentQueueService.pushPatentImageZhuluToDB();
+                pantentQueueService.pushPatentImageToDB();
             } catch (InterruptedException | IOException e) {
                 e.printStackTrace();
             }
         });
         threadConsumer1.start();
 
-        //一个线程执行消费者2（将专利信息从队列取出，说明书和权要入库）
+
+        //消费者2线程（著录项目）
         Thread threadConsumer2 = new Thread(() -> {
             try {
-                pantentQueueService.pushPatentRightInstructionTextToDB();
+                pantentQueueService.pushPatentZhuLuToDB();
             } catch (InterruptedException | IOException e) {
                 e.printStackTrace();
             }
         });
         threadConsumer2.start();
 
-        //一个线程执行消费者3（将专利信息从队列取出，与专利关联的数据入库）
+
+        //消费者3线程（权利要求）
         Thread threadConsumer3 = new Thread(() -> {
             try {
-                pantentQueueService.pushPatentAssoToDB();
+                pantentQueueService.pushPatentRightToDB();
             } catch (InterruptedException | IOException e) {
                 e.printStackTrace();
             }
@@ -77,6 +78,27 @@ public class CreateTaskThread implements InitializingBean {
         threadConsumer3.start();
 
 
+        //消费者4线程（说明书文本消费者）
+        Thread threadConsumer4 = new Thread(() -> {
+            try {
+                pantentQueueService.pushPatentInstructionTextToDB();
+            } catch (InterruptedException | IOException e) {
+                e.printStackTrace();
+            }
+        });
+        threadConsumer4.start();
+
+
+        //消费者5线程（与专利关联数据消费者）
+        Thread threadConsumer5 = new Thread(() -> {
+            try {
+                pantentQueueService.pushPatentAssoToDB();
+            } catch (InterruptedException | IOException e) {
+                e.printStackTrace();
+            }
+        });
+        threadConsumer5.start();
+
     }
 
 }

PAS/src/main/java/cn/cslg/pas/common/utils/Response.java

@@ -1,5 +1,8 @@
 package cn.cslg.pas.common.utils;
 
+import lombok.Data;
+import lombok.experimental.Accessors;
+
 public class Response {
 
     private Integer code;
@@ -25,16 +28,30 @@ public class Response {
         response.setData(data);
         return JsonUtils.objectToJson(response);
     }
+
     /**
      * 陈宇 ↓ 直接返回对象(前台默认显示为jsonResult格式对象)
      */
-    public static Response success2(Object data) {
+    public static Response ok(Object data) {
         Response response = new Response();
         response.setResultEnum(ResponseEnum.SUCCESS);
         response.setData(data);
         return response;
     }
 
+    public static Response fail() {
+        Response response = new Response();
+        response.setResultEnum(ResponseEnum.ERROR);
+        return response;
+    }
+
+    public static Response fail(Object data) {
+        Response response = new Response();
+        response.setResultEnum(ResponseEnum.ERROR);
+        response.setData(data);
+        return response;
+    }
+
     public static String websocket(Object data, ResponseEnum responseEnum) {
         Response response = new Response();
         response.setResultEnum(responseEnum);

PAS/src/main/java/cn/cslg/pas/controller/ProjectImportController.java

@@ -57,14 +57,10 @@ public class ProjectImportController {
         if (params == null) {
             return Response.error("参数错误");
         }
-//        TaskParams taskParams = projectService.getImportPatentTaskParams(file, params.getProjectId());
+        //TaskParams taskParams = projectService.getImportPatentTaskParams(file, params.getProjectId());
         //projectService.importPatent(taskParams, params);
-//        uploadPatentBatchService.uploadPatentBatch(taskParams, params);
-        try {
-            uploadTaskService.addTask(file, json);
-        } catch (XiaoShiException e) {
-            return Response.error(e.getMessage());
-        }
+        //uploadPatentBatchService.uploadPatentBatch(taskParams, params);
+        uploadTaskService.addTask(file, json);
         return Response.success(true);
     }
 

PAS/src/main/java/cn/cslg/pas/controller/StructureController.java

@@ -71,7 +71,7 @@ public class StructureController {
     public Response query(@RequestBody StructureQueryPageDTO structureQueryPageDTO) {
         log.info("开始处理【查询架构树】的请求，请求参数为：{}", structureQueryPageDTO);
         StructureVO queryResult = structureService.query(structureQueryPageDTO);
-        return Response.success2(queryResult);
+        return Response.ok(queryResult);
     }
 
     @Operation(summary = "查询拼接路径名")

PAS/src/main/java/cn/cslg/pas/controller/TaskController.java

@@ -1,7 +1,9 @@
 package cn.cslg.pas.controller;
 
 import cn.cslg.pas.common.core.base.Constants;
+import cn.cslg.pas.common.model.vo.ProjectImportPatentVO;
 import cn.cslg.pas.common.model.vo.TaskVO;
+import cn.cslg.pas.common.utils.JsonUtils;
 import cn.cslg.pas.common.utils.Response;
 import cn.cslg.pas.domain.Task;
 import cn.cslg.pas.service.TaskService;
@@ -9,8 +11,10 @@ import cn.cslg.pas.service.upLoadPatent.UploadTaskService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
 
 import java.io.IOException;
 
@@ -22,6 +26,7 @@ import java.io.IOException;
  * @author 王岩
  * @since 2022-02-17
  */
+@Slf4j
 @Tag(name = "系统任务")
 @RestController
 @RequestMapping(Constants.API_VERSION_V2 + "/task")
@@ -55,16 +60,35 @@ public class TaskController {
         return Response.success(true);
     }
 
-//    @PostMapping("add")
-//    @Operation(summary = "新增专利导入任务")
-//    public String add(MultipartFile file, String json) throws IOException {
-//        ProjectImportPatentVO params = JsonUtils.jsonToPojo(json, ProjectImportPatentVO.class);
-//        if (params == null) {
-//            return Response.error("参数错误");
-//        }
-//        uploadTaskService.addTask(file, json);
-//        return Response.success(true);
-//    }
+    @PostMapping("add")
+    @Operation(summary = "新增专利导入任务")
+    public String add(MultipartFile file, String json) throws IOException {
+        if (json == null || json.equals("")) {
+            return Response.error("参数错误");
+        }
+        ProjectImportPatentVO params = JsonUtils.jsonToPojo(json, ProjectImportPatentVO.class);
+        if (params == null) {
+            return Response.error("参数错误");
+        }
+        uploadTaskService.addTask(file, json);
+        return Response.success(true);
+    }
+
+    @PostMapping("/pause")
+    @Operation(summary = "暂停任务")
+    public Response pauseTask(Integer taskId) {
+        log.info("开始处理【暂停任务】的请求，请求参数为：taskId={}", taskId);
+        taskService.pauseTask(taskId);
+        return Response.ok("暂停任务成功");
+    }
+
+    @PostMapping("/continue")
+    @Operation(summary = "继续任务")
+    public Response continueTask(Integer taskId) {
+        log.info("开始处理【继续任务】的请求，请求参数为：taskId={}", taskId);
+        taskService.continueTask(taskId);
+        return Response.ok("继续任务成功");
+    }
 
 }
 

PAS/src/main/java/cn/cslg/pas/service/ITaskService.java

@@ -0,0 +1,24 @@
+package cn.cslg.pas.service;
+
+/**
+ * 任务的业务层接口
+ *
+ * @Author chenyu
+ * @Date 2023/6/8
+ */
+public interface ITaskService {
+    /**
+     * 暂停任务
+     *
+     * @param taskId 任务id
+     */
+    void pauseTask(Integer taskId);
+
+    /**
+     * 继续任务
+     *
+     * @param taskId 任务id
+     */
+    void continueTask(Integer taskId);
+
+}

PAS/src/main/java/cn/cslg/pas/service/TaskService.java

@@ -23,6 +23,7 @@ import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
@@ -42,9 +43,10 @@ import java.util.stream.Collectors;
  * @author 王岩
  * @since 2022-02-27
  */
+@Slf4j
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
-public class TaskService extends ServiceImpl<TaskMapper, Task> {
+public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskService {
     private final FileUtils fileUtils;
     private final LoginUtils loginUtils;
     private final RequestService requestService;
@@ -247,4 +249,80 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> {
         }
     }
 
+    /**
+     * 暂停任务
+     *
+     * @param taskId 任务id
+     */
+    @Override
+    public void pauseTask(Integer taskId) {
+        log.info("开始处理【暂停任务】的业务，参数为：taskId={}", taskId);
+
+        //1.检查尝试暂停的任务是否存在，若不存在则暂停失败，提示用户 "暂停失败，当前任务已不存在，请尝试刷新页面"
+        log.info("检查尝试暂停的任务是否存在");
+        Task task = this.getById(taskId);
+        if (task == null) {
+            ThrowException.throwXiaoShiException("暂停失败，当前任务已不存在，请尝试刷新页面");
+            return;
+        }
+        //2.检查尝试暂停的任务是否已处于暂停状态，若是则暂停失败，提示用户 "暂停失败，当前任务已处于暂停状态，请尝试刷新页面"
+        if (task.getStatus().equals(4)) {
+            ThrowException.throwXiaoShiException("暂停失败，当前任务已处于暂停状态，请尝试刷新页面");
+        }
+
+        //3.检查尝试暂停的任务是否处于进行中状态，若不是则暂停失败，提示用户 "暂停失败，当前任务已结束或未开始，请尝试刷新页面"
+        if (!task.getStatus().equals(1)) {
+            ThrowException.throwXiaoShiException("暂停失败，当前任务已结束或未开始，请尝试刷新页面");
+        }
+
+        //4.暂停任务
+        Task updateTask = new Task();
+        updateTask.setId(taskId);
+        updateTask.setStatus(4);
+        log.info("任务表修改数据，暂停任务，任务id={}", taskId);
+        boolean updateResult = this.updateById(updateTask);
+        if (!updateResult) {
+            ThrowException.throwXiaoShiException("暂停失败，服务器忙请稍后再试");
+        }
+
+        log.info("暂停任务成功");
+
+    }
+
+    /**
+     * 继续任务
+     *
+     * @param taskId 任务id
+     */
+    @Override
+    public void continueTask(Integer taskId) {
+        log.info("开始处理【继续任务】的业务，参数为：taskId={}", taskId);
+
+        //1.检查尝试继续的任务是否存在，若不存在则继续失败，提示用户 "继续失败，当前任务已不存在，请尝试刷新页面"
+        log.info("检查尝试继续的任务是否存在");
+        Task task = this.getById(taskId);
+        if (task == null) {
+            ThrowException.throwXiaoShiException("继续失败，当前任务已不存在，请尝试刷新页面");
+            return;
+        }
+
+        //2.检查尝试继续的任务是否处于暂停状态，若不是则继续失败，提示用户 "继续失败，当前任务未暂停，请尝试刷新页面"
+        if (!task.getStatus().equals(4)) {
+            ThrowException.throwXiaoShiException("继续失败，当前任务未暂停，请尝试刷新页面");
+        }
+
+        //3.继续任务（将任务状态改为0即等待中）
+        Task updateTask = new Task();
+        updateTask.setId(taskId);
+        updateTask.setStatus(0);
+        log.info("任务表修改数据，继续任务，任务id={}", taskId);
+        boolean updateResult = this.updateById(updateTask);
+        if (!updateResult) {
+            ThrowException.throwXiaoShiException("继续失败，服务器忙请稍后再试");
+        }
+
+        log.info("继续任务成功");
+
+    }
+
 }

PAS/src/main/java/cn/cslg/pas/service/upLoadPatent/PantentQueueService.java

@@ -3,6 +3,7 @@ package cn.cslg.pas.service.upLoadPatent;
 import cn.cslg.pas.common.model.vo.ProjectImportPatentVO;
 import cn.cslg.pas.common.model.vo.UploadParamsVO;
 import cn.cslg.pas.common.model.vo.UploadSettingVO;
+import cn.cslg.pas.common.utils.DateUtils;
 import cn.cslg.pas.common.utils.FileUtils;
 import cn.cslg.pas.common.utils.JsonUtils;
 import cn.cslg.pas.common.utils.ReadExcelUtils;
@@ -35,24 +36,32 @@ public class PantentQueueService {
     private final FileUtils fileUtils;
     private final MessageService messageService;
     private final TaskService taskService;
-    private Queue<QueueData> patentImageZhuluQueue = new LinkedList<>();
-    private Queue<QueueData> patentRightInstructionTextQueue = new LinkedList<>();
+    private Queue<QueueData> patentImageQueue = new LinkedList<>();
+    private Queue<QueueData> patentZhuluQueue = new LinkedList<>();
+    private Queue<QueueData> patentRightQueue = new LinkedList<>();
+    private Queue<QueueData> patentInstructionTextQueue = new LinkedList<>();
     private Queue<QueueData> patentAssoQueue = new LinkedList<>();
     private List<Integer> taskQueueList = new ArrayList<>();
     private Boolean flag = false;
     private Lock taskLock = new ReentrantLock();
-    private Lock patentImageZhuluLock = new ReentrantLock();
-    private Lock patentRightInstructionTextLock = new ReentrantLock();
+    private Lock patentImageLock = new ReentrantLock();
+    private Lock patentZhuluLock = new ReentrantLock();
+    private Lock patentRightLock = new ReentrantLock();
+    private Lock patentInstructionTextLock = new ReentrantLock();
     private Lock patentAssoLock = new ReentrantLock();
     Condition taskCondition = taskLock.newCondition();
-    private Condition patentImageZhuluCondition = patentImageZhuluLock.newCondition();
-    private Condition patentRightInstructionTextCondition = patentRightInstructionTextLock.newCondition();
+    private Condition patentImageCondition = patentImageLock.newCondition();
+    private Condition patentZhuluCondition = patentZhuluLock.newCondition();
+    private Condition patentRightCondition = patentRightLock.newCondition();
+    private Condition patentInstructionTextCondition = patentInstructionTextLock.newCondition();
     private Condition patentAssoCondition = patentAssoLock.newCondition();
     private HashMap<Integer, Integer> patentIdMap = new HashMap<>();
     private Task task = null;
     private Integer patentFinishNum = 0;
 
-    //将专利信息存入队列
+    /**
+     * 生产者：从任务队列取出任务解析成专利实体类，分配给三个消费者队列
+     */
     public void addPatnetToQueue() {
         try {
             while (true) {
@@ -61,10 +70,13 @@ public class PantentQueueService {
                     taskLock.lock();
                     taskCondition.await();
                 }
-                //1.从taskQueueList中取出第一个task，并将其从taskQueueList中删除
+                //1.从taskQueueList中取出第一个task，将其状态改为进行中，并将其从任务队列taskQueueList中删除
                 task = taskService.getById(taskQueueList.get(0));
+                task.setStatus(1);
+                taskService.updateById(task);
                 taskQueueList.remove(0);
-                //从任务数据中取出文件路径、总条数、成功条数、前台参数json
+
+                //从任务中取出文件路径、总条数、成功条数、前台参数json
                 String filePath = task.getUrl();  //相对路径
                 filePath = fileUtils.getPath(filePath);  //绝对路径
                 Integer total = task.getTotal();
@@ -84,118 +96,182 @@ public class PantentQueueService {
                     UploadParamsVO uploadParamsVO = excuteDataToVOService.fileToPatentVO(patentData, jsonData);
                     //保存专利基础数据（专利表"os_patent"）
                     uploadPatentBatchService.getOneOrInsertOne(uploadParamsVO);
-                    //专利分别加入三个消费者队列
+
+                    //专利分别加入5个消费者队列
                     QueueData queueData = new QueueData()
                             .setUploadParamsVO(uploadParamsVO)
                             .setProjectImportPatentVO(projectImportPatentVO);
-                    patentImageZhuluQueue.add(queueData);
-                    patentRightInstructionTextQueue.add(queueData);
+                    patentImageQueue.add(queueData);
+                    patentZhuluQueue.add(queueData);
+                    patentRightQueue.add(queueData);
+                    patentInstructionTextQueue.add(queueData);
                     patentAssoQueue.add(queueData);
-                    //通知消费者线程（三个消费者：保存摘要附图和著录、保存说明书和权要、保存专题库关联专利数据）
-                    //保存摘要附图和著录消费者
-                    //patentImageZhuluLatch.countDown();
-                    patentImageZhuluLock.lock();
-                    patentImageZhuluCondition.signalAll();
-                    patentImageZhuluLock.unlock();
-                    //保存说明书和权要消费者
-                    //patentRightInstructionTextLatch.countDown();
-                    patentRightInstructionTextLock.lock();
-                    patentRightInstructionTextCondition.signalAll();
-                    patentRightInstructionTextLock.unlock();
-                    //保存专题库关联专利数据消费者
-                    //patentAssoLatch.countDown();
+
+                    //通知消费者线程（5个消费者：摘要附图、著录项目、权利要求文本、说明书文本、与专利关联数据）
+                    //消费者1摘要附图
+                    patentImageLock.lock();
+                    patentImageCondition.signalAll();
+                    patentImageLock.unlock();
+                    //消费者2著录项目
+                    patentZhuluLock.lock();
+                    patentZhuluCondition.signalAll();
+                    patentZhuluLock.unlock();
+                    //消费者3权利要求文本
+                    patentRightLock.lock();
+                    patentRightCondition.signalAll();
+                    patentRightLock.unlock();
+                    //消费者4说明书文本
+                    patentInstructionTextLock.lock();
+                    patentInstructionTextCondition.signalAll();
+                    patentInstructionTextLock.unlock();
+                    //消费者5与专利关联数据
                     patentAssoLock.lock();
                     patentAssoCondition.signalAll();
                     patentAssoLock.unlock();
 
-
                 }
 
-                //任务表更新数据
-                task.setStatus(2);
-                taskService.updateById(task);
             }
 
         } catch (Exception e) {
             e.printStackTrace();
-            //修改任务状态为失败
+            //任务表更新状态为失败
             task.setStatus(3);
+            task.setEndTime(DateUtils.getDateTime());
             taskService.updateById(task);
-        } finally {
         }
         flag = true;
     }
 
     /**
-     * 将专利信息从队列取出，摘要附图和著录项目入库
+     * 消费者1：将专利从队列取出，摘要附图入库
      */
-    public void pushPatentImageZhuluToDB() throws InterruptedException, IOException {
-        try {
-            while (true) {
-                if (patentImageZhuluQueue.isEmpty()) {
+    public void pushPatentImageToDB() throws InterruptedException, IOException {
+        while (true) {
+            try {
+                if (patentImageQueue.isEmpty()) {
                     if (flag) {
-                        System.out.println("所有专利的摘要附图和著录项目全部完成，退出循环");
+                        System.out.println("摘要附图全部完成，退出循环");
                         return;
                     } else {
-                        patentImageZhuluLock.lock();
-                        patentImageZhuluCondition.await();
-                        patentImageZhuluLock.unlock();
+                        patentImageLock.lock();
+                        patentImageCondition.await();
+                        patentImageLock.unlock();
                     }
                 } else {
-                    QueueData queueData = patentImageZhuluQueue.remove();
+                    QueueData queueData = patentImageQueue.remove();
                     //摘要附图入库
                     uploadPatentToDBService.uploadPatentImage(queueData.getUploadParamsVO());
+                    //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
+                    sendMessage(queueData, patentIdMap.get(0), task);
+                }
+
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+
+        }
+    }
+
+    /**
+     * 消费者2：将专利从队列取出，著录项目入库
+     */
+    public void pushPatentZhuLuToDB() throws InterruptedException, IOException {
+        while (true) {
+            try {
+                if (patentZhuluQueue.isEmpty()) {
+                    if (flag) {
+                        System.out.println("著录项目全部完成，退出循环");
+                        return;
+                    } else {
+                        patentZhuluLock.lock();
+                        patentZhuluCondition.await();
+                        patentZhuluLock.unlock();
+                    }
+                } else {
+                    QueueData queueData = patentZhuluQueue.remove();
                     //著录项目入库
                     uploadPatentToDBService.uploadPatentZhulu(queueData.getUploadParamsVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
                     sendMessage(queueData, patentIdMap.get(0), task);
                 }
 
+            } catch (Exception e) {
+                e.printStackTrace();
             }
-        } finally {
 
         }
     }
 
     /**
-     * 将专利信息从队列取出，说明书和权要入库
+     * 消费者3：将专利从队列取出，权利要求文本入库
      */
-    public void pushPatentRightInstructionTextToDB() throws InterruptedException, IOException {
-        try {
-            while (true) {
-                if (patentRightInstructionTextQueue.isEmpty()) {
+    public void pushPatentRightToDB() throws InterruptedException, IOException {
+        while (true) {
+            try {
+                if (patentRightQueue.isEmpty()) {
                     if (flag) {
-                        System.out.println("所有专利的说明书和权要全部完成，退出循环");
+                        System.out.println("权利要求全部完成，退出循环");
                         return;
                     } else {
-                        patentRightInstructionTextLock.lock();
-                        patentRightInstructionTextCondition.await();
-                        patentRightInstructionTextLock.unlock();
+                        patentRightLock.lock();
+                        patentRightCondition.await();
+                        patentRightLock.unlock();
                     }
                 } else {
-                    QueueData queueData = patentRightInstructionTextQueue.remove();
-                    //说明书入库
-                    uploadPatentToDBService.uploadPatentInstructionText(queueData.getUploadParamsVO());
-                    //权要入库
+                    QueueData queueData = patentRightQueue.remove();
+                    //权要文本入库
                     uploadPatentToDBService.uploadPatentRight(queueData.getUploadParamsVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
                     sendMessage(queueData, patentIdMap.get(0), task);
                 }
+
+            } catch (Exception e) {
+                e.printStackTrace();
             }
-        } finally {
 
         }
     }
 
     /**
-     * 将专利信息从队列取出，与专利关联的数据入库
+     * 消费者4：将专利从队列取出，说明书文本入库
+     */
+    public void pushPatentInstructionTextToDB() throws InterruptedException, IOException {
+        while (true) {
+            try {
+                if (patentInstructionTextQueue.isEmpty()) {
+                    if (flag) {
+                        System.out.println("说明书文本全部完成，退出循环");
+                        return;
+                    } else {
+                        patentInstructionTextLock.lock();
+                        patentInstructionTextCondition.await();
+                        patentInstructionTextLock.unlock();
+                    }
+                } else {
+                    QueueData queueData = patentInstructionTextQueue.remove();
+                    //说明书文本入库
+                    uploadPatentToDBService.uploadPatentInstructionText(queueData.getUploadParamsVO());
+                    //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
+                    sendMessage(queueData, patentIdMap.get(0), task);
+                }
+
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+
+        }
+    }
+
+    /**
+     * 消费者5：将专利从队列取出，与专利关联数据入库
      */
     public void pushPatentAssoToDB() throws InterruptedException, IOException {
-        try {
-            while (true) {
+        while (true) {
+            try {
                 if (patentAssoQueue.isEmpty()) {
                     if (flag) {
-                        System.out.println("所有专利的与专利关联的数据全部完成，退出循环");
+                        System.out.println("与专利关联的数据全部完成，退出循环");
                         return;
                     } else {
                         patentAssoLock.lock();
@@ -213,35 +289,40 @@ public class PantentQueueService {
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
                     sendMessage(queueData, patentIdMap.get(0), task);
                 }
+
+            } catch (Exception e) {
+                e.printStackTrace();
             }
-        } finally {
 
         }
     }
 
     public void sendMessage(QueueData queueData, Integer total, Task task) {
         //每完成一个专利，通过计算，发送进度
-        synchronized ("啊啊啊") {
+        synchronized ("此为同步锁") {
             Integer currentPatentId = queueData.getUploadParamsVO().getPatent().getId();
             Integer num = patentIdMap.get(currentPatentId);
             if (num == null) {
                 patentIdMap.put(currentPatentId, 1);
-            } else if (num == 1) {
-                patentIdMap.put(currentPatentId, 2);
+            } else if (num < 4) {
+                patentIdMap.put(currentPatentId, ++num);
             } else {
                 //num达到3了就从patentIdMap中删除
                 patentIdMap.remove(currentPatentId);
+                patentFinishNum++;
                 long percentage = Math.round((patentFinishNum + 1D) / total * 100D);
+                //当全部完成时
                 if (patentFinishNum.equals(total)) {
                     percentage = 100L;
+                    //任务表更新状态为成功
+                    task.setStatus(2);
+                    task.setEndTime(DateUtils.getDateTime());
+                    taskService.updateById(task);
+                    System.out.println("结束时间：" + new Date());
                 }
-                patentFinishNum++;
                 messageService.sendWebsocketMessage(task, total, patentFinishNum, percentage);
-
-//任务表更新数据 ↓
-                //成功条数
+                //任务表更新数据
                 task.setSuccessNum(patentFinishNum);
-                //失败条数
                 task.setDefaultNum(total - task.getSuccessNum());
                 taskService.updateById(task);
             }

PAS/src/main/java/cn/cslg/pas/service/upLoadPatent/UploadPatentToDBService.java

@@ -28,7 +28,7 @@ import java.util.List;
 import java.util.Map;
 
 /**
- * 保存专利及所有专利关联入库
+ * 保存专利及所有与之关联数据入库
  *
  * @Author chenyu
  * @Date 2023/5/30
@@ -42,33 +42,9 @@ public class UploadPatentToDBService {
     private final PatentImageService patentImageService;
 
     /**
-     * 专利及所有关联入库
+     * 摘要附图
      *
-     * @param uploadParamsVO        专利实体类
-     * @param projectImportPatentVO 专题库专利关联数据实体类（专题库id、数据来源id、自定义字段、文件夹）
-     */
-    public void uploadPatentToDB(UploadParamsVO uploadParamsVO, ProjectImportPatentVO projectImportPatentVO) throws IOException {
-        //摘要附图入库
-        //uploadPatentImage(uploadParamsVO, uploadParamsVO.getPictureData());
-        //著录项目入库
-        //uploadPatentZhulu(uploadParamsVO);
-        //说明书文本入库
-        //uploadPatentInstructionText(uploadParamsVO);
-        //权要入库
-        //uploadPatentRight(uploadParamsVO);
-        //专题库与专利关联入库
-        //uploadAssoThemaPat(uploadParamsVO, projectImportPatentVO);
-        //自定义字段标引与专利关联入库
-        //uploadAssoFieldPat(uploadParamsVO, projectImportPatentVO);
-        //文件夹与专利关联入库
-        //uploadAssoPorPat(uploadParamsVO, projectImportPatentVO);
-
-    }
-
-    /**
-     * 摘要附图入库
-     *
-     * @param uploadParamsVO 专利内容实体类对象
+     * @param uploadParamsVO 专利内容
      */
     public void uploadPatentImage(UploadParamsVO uploadParamsVO) throws IOException {
         //摘要附图数据装配及入库（摘要附图表"os_patent_img"）
@@ -79,13 +55,31 @@ public class UploadPatentToDBService {
         }
     }
 
+//    /**
+//     * 法律状态
+//     *
+//     * @param uploadParamsVO 专利内容
+//     */
+//    public void uploadLegalStatus(UploadParamsVO uploadParamsVO) {
+//        //保存法律状态（专利表"os_patent"）
+//        if (uploadParamsVO.getPatent() != null) {
+//            List<SystemDict> systemDictList = systemDictService.getSystemDictListByType(Collections.singletonList(Constants.PATENT_SIMPLE_STATUS));
+//            Integer simpleStatus = Integer.parseInt(systemDictList.stream()
+//                    .filter(systemDict -> systemDict.getType().equals(Constants.PATENT_SIMPLE_STATUS) && systemDict.getLabel().equals(uploadParamsVO.getPatentSimpleStatus()))
+//                    .findFirst()
+//                    .orElse(new SystemDict()).getValue());
+//            uploadParamsVO.getPatent().setSimpleStatus(simpleStatus);
+//            uploadParamsVO.getPatent().updateById();
+//        }
+//    }
+
     /**
-     * 著录项目入库
+     * 著录项目
      *
-     * @param uploadParamsVO 专利内容实体类对象
+     * @param uploadParamsVO 专利内容
      */
     public void uploadPatentZhulu(UploadParamsVO uploadParamsVO) {
-        //保存法律状态（表"os_patent"）
+        //保存法律状态（专利表"os_patent"）
         if (uploadParamsVO.getPatent() != null) {
             List<SystemDict> systemDictList = systemDictService.getSystemDictListByType(Collections.singletonList(Constants.PATENT_SIMPLE_STATUS));
             Integer simpleStatus = Integer.parseInt(systemDictList.stream()
@@ -138,58 +132,61 @@ public class UploadPatentToDBService {
     }
 
     /**
-     * 权利要求入库
+     * 权利要求
      *
-     * @param uploadParamsVO 专利内容实体类对象
+     * @param uploadParamsVO 专利内容
      */
     public void uploadPatentRight(UploadParamsVO uploadParamsVO) {
-        //保存权利要求（表"os_patent_right"）
+        //保存权利要求（权要表"os_patent_right"）
         uploadPatentBatchService.patentRightBusiness(uploadParamsVO);
     }
 
     /**
-     * 说明书入库
+     * 说明书文本
      *
-     * @param uploadParamsVO 专利内容实体类对象
+     * @param uploadParamsVO 专利内容
      */
     public void uploadPatentInstructionText(UploadParamsVO uploadParamsVO) {
-        //保存说明书（表"os_patent_instruction_text"）
+        //保存说明书文本（说明书文本表"os_patent_instruction_text"）
         if (uploadParamsVO.getPatentInstructionText() != null) {
             uploadPatentBatchService.patentInstructionTextBusiness(uploadParamsVO);
         }
     }
 
     /**
-     * 保存专题库与专利关联（表"os_thematic_pid"）
+     * 专题库与专利关联
      *
-     * @param uploadParamsVO        专利内容实体类对象
-     * @param projectImportPatentVO 专题库关联专利信息（专题库id、自定义字段、文件夹等数据）
+     * @param uploadParamsVO        专利内容
+     * @param projectImportPatentVO 专题库关联专利内容（专题库id、专利id）
      */
     public void uploadAssoThemaPat(UploadParamsVO uploadParamsVO, ProjectImportPatentVO projectImportPatentVO) {
+        //保存专题库与专利关联（表"os_thematic_pid"）
         if (uploadParamsVO.getPatent() != null) {
             uploadPatentBatchService.patentThematicPidBusiness(uploadParamsVO, projectImportPatentVO);
         }
     }
 
     /**
-     * 保存标引内容关联专利信息（表"os_patent_field_patent_link"、"os_patent_field_text"）
+     * 标引内容与专利关联
      *
-     * @param uploadParamsVO        专利内容实体类对象
-     * @param projectImportPatentVO 专题库关联专利信息（专题库id、自定义字段、文件夹等数据）
+     * @param uploadParamsVO        专利内容
+     * @param projectImportPatentVO 专题库关联专利内容（专题库id、专利id、自定义字段）
      */
     public void uploadAssoFieldPat(UploadParamsVO uploadParamsVO, ProjectImportPatentVO projectImportPatentVO) {
+        //保存标引内容与专利关联（表"os_patent_field_patent_link"、"os_patent_field_text"）
         if (uploadParamsVO.getPatent() != null) {
             uploadPatentBatchService.patentProjectFieldPatentLinkBusiness(uploadParamsVO, projectImportPatentVO);
         }
     }
 
     /**
-     * 保存文件夹关联专利信息（表"os_portfolio_link"）
+     * 文件夹与专利关联
      *
-     * @param uploadParamsVO        专利内容实体类对象
-     * @param projectImportPatentVO 专题库关联专利信息（专题库id、自定义字段、文件夹等数据）
+     * @param uploadParamsVO        专利内容
+     * @param projectImportPatentVO 文件夹关联专利（专题库id、专利id、文件夹id）
      */
     public void uploadAssoPorPat(UploadParamsVO uploadParamsVO, ProjectImportPatentVO projectImportPatentVO) {
+        //保存文件夹与专利关联（表"os_portfolio_link"）
         if (uploadParamsVO.getPatent() != null) {
             uploadPatentBatchService.patentProjectFolderPatentLinkBusiness(uploadParamsVO, projectImportPatentVO);
         }