6/20 Excel导入专利下载接口调通

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

@@ -15,6 +15,8 @@ import cn.cslg.pas.common.model.vo.TaskVO;
 import cn.cslg.pas.domain.asso.AssoOsTaskQrtzTask;
 import cn.cslg.pas.mapper.TaskMapper;
 import cn.cslg.pas.common.model.dto.UploadFileDTO;
+import cn.cslg.pas.service.upLoadPatent.ExcutePatentDataExcel;
+import cn.cslg.pas.service.upLoadPatent.PantentQueueService;
 import cn.dev33.satoken.stp.StpUtil;
 import cn.hutool.core.io.FileUtil;
 import com.alibaba.fastjson.JSON;
@@ -53,6 +55,8 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
     private final LoginUtils loginUtils;
     private final RequestService requestService;
     private final OutInterfaceService outInterfaceService;
+    private final PantentQueueService pantentQueueService;
+    private final ExcutePatentDataExcel excutePatentDataExcel;
 
     public String getFileUrl(Integer id) {
         Task task = this.getById(id);
@@ -296,24 +300,24 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
     public void pauseTask(Integer taskId) {
         log.info("开始处理【暂停任务】的业务，参数为：taskId={}", taskId);
 
-        //1.检查尝试暂停的任务是否存在，若不存在则暂停失败，提示用户 "暂停失败，当前任务已不存在，请尝试刷新页面"
+        //1.检查尝试暂停的任务是否存在，若不存在则提示用户 "暂停失败，当前任务已不存在，请尝试刷新页面"
         log.info("检查尝试暂停的任务是否存在");
         Task task = this.getById(taskId);
         if (task == null) {
             ThrowException.throwXiaoShiException("暂停失败，当前任务已不存在，请尝试刷新页面");
             return;
         }
-        //2.检查尝试暂停的任务是否已处于暂停状态，若是则暂停失败，提示用户 "暂停失败，当前任务已处于暂停状态，请尝试刷新页面"
+        //2.检查尝试暂停的任务是否已处于暂停状态，若是则提示用户 "暂停失败，当前任务已处于暂停状态，请尝试刷新页面"
         if (task.getStatus().equals(4)) {
             ThrowException.throwXiaoShiException("暂停失败，当前任务已处于暂停状态，请尝试刷新页面");
         }
 
-        //3.检查尝试暂停的任务是否处于进行中状态，若不是则暂停失败，提示用户 "暂停失败，当前任务已结束或未开始，请尝试刷新页面"
+        //3.检查尝试暂停的任务是否处于进行中状态，若不是则提示用户 "暂停失败，当前任务已结束或未开始，请尝试刷新页面"
         if (!task.getStatus().equals(1)) {
             ThrowException.throwXiaoShiException("暂停失败，当前任务已结束或未开始，请尝试刷新页面");
         }
 
-        //4.暂停任务
+        //4.任务表将任务状态修改为4暂停
         Task updateTask = new Task();
         updateTask.setId(taskId);
         updateTask.setStatus(4);
@@ -323,6 +327,16 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
             ThrowException.throwXiaoShiException("暂停失败，服务器忙请稍后再试");
         }
 
+        //5.将生产者生产专利类中的公共任务状态改为暂停
+        excutePatentDataExcel.setTaskStatus(4);
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            ThrowException.throwXiaoShiException("暂停失败，未知错误");
+        }
+        //6.将消费者的专利队列中所有该任务的专利剔除
+        pantentQueueService.consumerQueueDeleteTasks(taskId);
+
         log.info("暂停任务成功");
 
     }
@@ -336,7 +350,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
     public void continueTask(Integer taskId) {
         log.info("开始处理【继续任务】的业务，参数为：taskId={}", taskId);
 
-        //1.检查尝试继续的任务是否存在，若不存在则继续失败，提示用户 "继续失败，当前任务已不存在，请尝试刷新页面"
+        //1.检查尝试继续的任务是否存在，若不存在则提示用户 "继续失败，当前任务已不存在，请尝试刷新页面"
         log.info("检查尝试继续的任务是否存在");
         Task task = this.getById(taskId);
         if (task == null) {
@@ -344,7 +358,7 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
             return;
         }
 
-        //2.检查尝试继续的任务是否处于暂停状态，若不是则继续失败，提示用户 "继续失败，当前任务未暂停，请尝试刷新页面"
+        //2.检查尝试继续的任务是否处于暂停状态，若不是则提示用户 "继续失败，当前任务未暂停，请尝试刷新页面"
         if (!task.getStatus().equals(4)) {
             ThrowException.throwXiaoShiException("继续失败，当前任务未暂停，请尝试刷新页面");
         }
@@ -359,6 +373,10 @@ public class TaskService extends ServiceImpl<TaskMapper, Task> implements ITaskS
             ThrowException.throwXiaoShiException("继续失败，服务器忙请稍后再试");
         }
 
+        //4.将当前任务添加进生产者任务队列进行排队，并唤醒生产者线程
+        pantentQueueService.taskQueueAddTask(new ArrayList<>(Arrays.asList(taskId)));
+        pantentQueueService.awakeTasktch();
+
         log.info("继续任务成功");
 
     }

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

@@ -8,6 +8,7 @@ import cn.cslg.pas.common.utils.JsonUtils;
 import cn.cslg.pas.common.utils.ReadExcelUtils;
 import cn.cslg.pas.domain.PatentData;
 import cn.cslg.pas.domain.Task;
+import cn.cslg.pas.service.TaskService;
 import lombok.RequiredArgsConstructor;
 import org.apache.poi.ss.usermodel.Sheet;
 import org.springframework.stereotype.Service;
@@ -28,6 +29,7 @@ public class ExcutePatentDataExcel implements IExcutePatentData {
     private final ExcuteUploadSettingService excuteUploadSettingService;
     private final ExcuteDataToVOService excuteDataToVOService;
     private final PantentQueueService pantentQueueService;
+    private Integer taskStatus;
 
     /**
      * 解析获取专利数据
@@ -50,7 +52,12 @@ public class ExcutePatentDataExcel implements IExcutePatentData {
         //解析Excel文件获得工作簿
         Sheet sheet = ReadExcelUtils.readExcel(filePath);
         //遍历专利总数量，在循环中将专利一个一个存入消费者专利队列
+        taskStatus = 0;
         for (int i = lastIndex; i < total; i++) {
+            //判断若任务状态为暂停（4），则不再生产该任务的专利
+            if (taskStatus == 4) {
+                return;
+            }
             PatentData patentData = ReadExcelUtils.readExcelOneRow(filePath, sheet, i + 1);
             //调用装载数据类（根据数据源配置文件对象和专利源数据生成专利数据）
             UploadParamsVO uploadParamsVO = excuteDataToVOService.fileToPatentVO(patentData, jsonData);
@@ -60,4 +67,8 @@ public class ExcutePatentDataExcel implements IExcutePatentData {
         }
     }
 
+    public void setTaskStatus(Integer taskStatus) {
+        this.taskStatus = taskStatus;
+    }
+
 }

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

@@ -8,6 +8,7 @@ import cn.cslg.pas.domain.Task;
 import cn.cslg.pas.service.TaskService;
 import cn.cslg.pas.service.UploadPatentBatchService;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import lombok.Data;
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
@@ -33,23 +34,20 @@ public class PantentQueueService {
     private final ExcutePatentDataEpo excutePatentDataEpo;
     private final List<Integer> taskQueueList = new ArrayList<>();
     private Boolean flag = false;
-    private final Queue<QueueData> patentImageQueue = new LinkedList<>();
-    private final Queue<QueueData> patentZhuluQueue = new LinkedList<>();
-    private final Queue<QueueData> patentRightQueue = new LinkedList<>();
-    private final Queue<QueueData> patentInstructionTextQueue = new LinkedList<>();
-    private final Queue<QueueData> patentAssoQueue = new LinkedList<>();
+    private final List<QueueData> patentImageQueueList = new ArrayList<>();
+    private final List<QueueData> patentZhuluQueueList = new ArrayList<>();
+    private final List<QueueData> patentRightQueueList = new ArrayList<>();
+    private final List<QueueData> patentInstructionTextQueueList = new ArrayList<>();
     private final Lock taskLock = new ReentrantLock();
     private final Lock patentImageLock = new ReentrantLock();
     private final Lock patentZhuluLock = new ReentrantLock();
     private final Lock patentRightLock = new ReentrantLock();
     private final Lock patentInstructionTextLock = new ReentrantLock();
-    private final Lock patentAssoLock = new ReentrantLock();
     private final Condition taskCondition = taskLock.newCondition();
     private final Condition patentImageCondition = patentImageLock.newCondition();
     private final Condition patentZhuluCondition = patentZhuluLock.newCondition();
     private final Condition patentRightCondition = patentRightLock.newCondition();
     private final Condition patentInstructionTextCondition = patentInstructionTextLock.newCondition();
-    private final Condition patentAssoCondition = patentAssoLock.newCondition();
     private final HashMap<String, Integer> patentIdMap = new HashMap<>();
 
     /**
@@ -68,14 +66,18 @@ public class PantentQueueService {
                 //线程被唤醒后 ↓
                 if (taskQueueList.size() > 0) {
                     //1.从任务队列中取出一个task任务
+                    //2.同时将其从任务队列中剔除
+                    //3.查询任务，判断任务不存在或状态为已暂停，则直接跳过进行下一个任务
                     task = taskService.getById(taskQueueList.get(0));
-                    //同时将其从任务队列中剔除
                     taskQueueList.remove(0);
+                    if (task == null || task.getStatus() == 4) {
+                        continue;
+                    }
 
-                    //TODO 调用工厂方法，将任务扔进去，工厂方法根据任务类型返回对应的生产专利方法对象
+                    //TODO 调用工厂方法并将任务扔进去，工厂方法会根据任务的类型创建并返回对应的生产专利方法的对象
                     //1.用工厂方法根据任务类型创建对应的获取专利数据的对象
                     IExcutePatentData excutePatentDataObject = createObject(task);
-                    //2.开始执行生产专利方法（解析任务生产专利并丢入消费者专利队列，唤醒消费者线程）
+                    //2.对象调用执行生产专利方法（解析任务生产专利并丢入消费者专利队列，唤醒消费者线程）
                     if (excutePatentDataObject != null) {
                         excutePatentDataObject.startExcute(task);
                     }
@@ -100,7 +102,7 @@ public class PantentQueueService {
     public void pushPatentImageToDB() throws InterruptedException, IOException {
         while (true) {
             try {
-                if (patentImageQueue.isEmpty()) {
+                if (patentImageQueueList.isEmpty()) {
                     if (flag) {
                         System.out.println("摘要附图全部完成，退出循环");
                         return;
@@ -110,11 +112,11 @@ public class PantentQueueService {
                         patentImageLock.unlock();
                     }
                 } else {
-                    QueueData queueData = patentImageQueue.remove();
+                    QueueData queueData = patentImageQueueList.remove(0);
                     //摘要附图入库
                     uploadPatentToDBService.uploadPatentImage(queueData.getUploadParamsVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
-                    sendMessage(queueData, queueData.getTask().getTotal(), queueData.getTask());
+                    sendMessage(queueData);
                 }
 
             } catch (Exception e) {
@@ -131,7 +133,7 @@ public class PantentQueueService {
     public void pushPatentZhuLuToDB() throws InterruptedException, IOException {
         while (true) {
             try {
-                if (patentZhuluQueue.isEmpty()) {
+                if (patentZhuluQueueList.isEmpty()) {
                     if (flag) {
                         System.out.println("著录项目全部完成，退出循环");
                         return;
@@ -141,11 +143,17 @@ public class PantentQueueService {
                         patentZhuluLock.unlock();
                     }
                 } else {
-                    QueueData queueData = patentZhuluQueue.remove();
+                    QueueData queueData = patentZhuluQueueList.remove(0);
                     //著录项目入库
                     uploadPatentToDBService.uploadPatentZhulu(queueData.getUploadParamsVO());
+                    //专题库与专利关联入库
+                    uploadPatentToDBService.uploadAssoThemaPat(queueData.getUploadParamsVO(), queueData.getProjectImportPatentVO());
+                    //自定义字段标引与专利关联入库
+                    uploadPatentToDBService.uploadAssoFieldPat(queueData.getUploadParamsVO(), queueData.getProjectImportPatentVO());
+                    //文件夹与专利关联入库
+                    uploadPatentToDBService.uploadAssoPorPat(queueData.getUploadParamsVO(), queueData.getProjectImportPatentVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
-                    sendMessage(queueData, queueData.getTask().getTotal(), queueData.getTask());
+                    sendMessage(queueData);
                 }
 
             } catch (Exception e) {
@@ -161,7 +169,7 @@ public class PantentQueueService {
     public void pushPatentRightToDB() throws InterruptedException, IOException {
         while (true) {
             try {
-                if (patentRightQueue.isEmpty()) {
+                if (patentRightQueueList.isEmpty()) {
                     if (flag) {
                         System.out.println("权利要求全部完成，退出循环");
                         return;
@@ -171,11 +179,11 @@ public class PantentQueueService {
                         patentRightLock.unlock();
                     }
                 } else {
-                    QueueData queueData = patentRightQueue.remove();
+                    QueueData queueData = patentRightQueueList.remove(0);
                     //权要文本入库
                     uploadPatentToDBService.uploadPatentRight(queueData.getUploadParamsVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
-                    sendMessage(queueData, queueData.getTask().getTotal(), queueData.getTask());
+                    sendMessage(queueData);
                 }
 
             } catch (Exception e) {
@@ -191,7 +199,7 @@ public class PantentQueueService {
     public void pushPatentInstructionTextToDB() throws InterruptedException, IOException {
         while (true) {
             try {
-                if (patentInstructionTextQueue.isEmpty()) {
+                if (patentInstructionTextQueueList.isEmpty()) {
                     if (flag) {
                         System.out.println("说明书文本全部完成，退出循环");
                         return;
@@ -201,45 +209,11 @@ public class PantentQueueService {
                         patentInstructionTextLock.unlock();
                     }
                 } else {
-                    QueueData queueData = patentInstructionTextQueue.remove();
+                    QueueData queueData = patentInstructionTextQueueList.remove(0);
                     //说明书文本入库
                     uploadPatentToDBService.uploadPatentInstructionText(queueData.getUploadParamsVO());
                     //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
-                    sendMessage(queueData, queueData.getTask().getTotal(), queueData.getTask());
-                }
-
-            } catch (Exception e) {
-                e.printStackTrace();
-            }
-
-        }
-    }
-
-    /**
-     * 消费者5：将专利从队列取出，与专利关联数据入库
-     */
-    public void pushPatentAssoToDB() throws InterruptedException, IOException {
-        while (true) {
-            try {
-                if (patentAssoQueue.isEmpty()) {
-                    if (flag) {
-                        System.out.println("与专利关联的数据全部完成，退出循环");
-                        return;
-                    } else {
-                        patentAssoLock.lock();
-                        patentAssoCondition.await();
-                        patentAssoLock.unlock();
-                    }
-                } else {
-                    QueueData queueData = patentAssoQueue.remove();
-                    //专题库与专利关联入库
-                    uploadPatentToDBService.uploadAssoThemaPat(queueData.getUploadParamsVO(), queueData.getProjectImportPatentVO());
-                    //自定义字段标引与专利关联入库
-                    uploadPatentToDBService.uploadAssoFieldPat(queueData.getUploadParamsVO(), queueData.getProjectImportPatentVO());
-                    //文件夹与专利关联入库
-                    uploadPatentToDBService.uploadAssoPorPat(queueData.getUploadParamsVO(), queueData.getProjectImportPatentVO());
-                    //Websocket发送message：通过WebSocket 在每一次循环结束后 向前端发送完成进度
-                    sendMessage(queueData, queueData.getTask().getTotal(), queueData.getTask());
+                    sendMessage(queueData);
                 }
 
             } catch (Exception e) {
@@ -249,54 +223,55 @@ public class PantentQueueService {
         }
     }
 
-    public void sendMessage(QueueData queueData, Integer total, Task task) {
+    public void sendMessage(QueueData queueData) {
         //每完成一个专利，通过计算，发送进度
         synchronized ("此为同步锁") {
-            //上一个任务的一个消费者结束，开始消费下一个任务的专利，即下一个任务的第一个消费者进来，将当前任务的状态改为4待进行
-//            if (task.getStatus() == 0) {
-//                task.setStatus(4);
-//                taskService.updateById(task);
-//            }
-            Integer currentPatentId = queueData.getUploadParamsVO().getPatent().getId();
-            Integer taskId = task.getId();
-            String currentPatent = taskId + "|" + currentPatentId;
+            //当前进行的任务
+            Task task = queueData.getTask();
+            //当前进行的任务的专利总数量
+            Integer total = task.getTotal();
+
+            //将任务id + "|" + 专利id，拼接成专利的标识（作为当前某一个消费者消费完的这个专利的数量标识）
+            String currentPatent = task.getId() + "|" + queueData.getUploadParamsVO().getPatent().getId();
             Integer num = patentIdMap.get(currentPatent);
             if (num == null) {
                 patentIdMap.put(currentPatent, 1);
-            } else if (num < 4) {
+            } else if (num < 3) {
                 patentIdMap.put(currentPatent, ++num);
             } else {
-                //下一个任务的第5个消费者进来（即表示上一个任务的5个消费者都结束了），就将这个任务的状态正式改为1进行中
+                /*
+                1）若是看当前任务，表示当前这个任务这个专利的4个消费者全都消费结束，即当前这个任务的这个专利已完成
+                2）若是看下一个任务，表示下一个任务的著录项目消费者终于第一次进来了（即表示上一个任务最慢的著录项目消费者也结束了即上一个任务完成了），就将这下一个任务的状态改为 1进行中
+                 */
                 if (task.getStatus() == 0) {
                     task.setStatus(1);
                     task.setStartTime(DateUtils.getDateTime());
                     taskService.updateById(task);
                 }
-                //num达到4了就从patentIdMap中删除
+                //num达到4了就在patentIdMap中将其删除
                 patentIdMap.remove(currentPatent);
                 long percentage = Math.round((task.getSuccessNum() + 1D) / total * 100D);
-                //当全部完成时
-                if (task.getSuccessNum().equals(total)) {
-                    percentage = 100L;
-                }
-                messageService.sendWebsocketMessage(task, total, task.getSuccessNum(), percentage);
-                //任务表更新数据
+                //任务表更新数据（这里只更新成功条数和失败条数，注意不能更新状态等其他信息）
                 task.setSuccessNum(task.getSuccessNum() + 1);
                 task.setDefaultNum(total - task.getSuccessNum());
-                taskService.updateById(task);
+                Task updateTask = new Task();
+                updateTask.setId(task.getId());
+                updateTask.setSuccessNum(task.getSuccessNum());
+                updateTask.setDefaultNum(total - task.getSuccessNum());
+                taskService.updateById(updateTask);
+
                 //当全部完成时
                 if (task.getSuccessNum().equals(total)) {
+                    percentage = 100L;
                     //设置任务状态为成功
                     task.setStatus(2);
                     //设置任务结束时间为当前时间
                     task.setEndTime(DateUtils.getDateTime());
                     taskService.updateById(task);
-//                    //判断若没有进行中的任务则唤醒生产者线程
-//                    List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getStatus, 1));
-//                    if (tasks == null || tasks.size() == 0) {
-//                        awakeTasktch();
-//                    }
                 }
+
+                messageService.sendWebsocketMessage(task, total, task.getSuccessNum(), percentage);
+
             }
         }
     }
@@ -305,44 +280,62 @@ public class PantentQueueService {
         //保存专利基础数据（专利表"os_patent"）
         uploadPatentBatchService.getOneOrInsertOne(uploadParamsVO);
 
-        //专利分别加入5个消费者队列
+
         QueueData queueData = new QueueData()
                 .setTask(task)
                 .setUploadParamsVO(uploadParamsVO)
                 .setProjectImportPatentVO(projectImportPatentVO);
-        patentImageQueue.add(queueData);
-        patentZhuluQueue.add(queueData);
-        patentRightQueue.add(queueData);
-        patentInstructionTextQueue.add(queueData);
-        patentAssoQueue.add(queueData);
+
+        //专利分别加入5个消费者队列
+        patentImageQueueList.add(queueData);
+        patentZhuluQueueList.add(queueData);
+        patentRightQueueList.add(queueData);
+        patentInstructionTextQueueList.add(queueData);
 
         //通知消费者线程（5个消费者：摘要附图、著录项目、权利要求文本、说明书文本、与专利关联数据）
-        //消费者1摘要附图
+        //1.摘要附图
         patentImageLock.lock();
         patentImageCondition.signalAll();
         patentImageLock.unlock();
-        //消费者2著录项目
+        //2.著录项目
         patentZhuluLock.lock();
         patentZhuluCondition.signalAll();
         patentZhuluLock.unlock();
-        //消费者3权利要求文本
+        //3.权利要求文本
         patentRightLock.lock();
         patentRightCondition.signalAll();
         patentRightLock.unlock();
-        //消费者4说明书文本
+        //4.说明书文本
         patentInstructionTextLock.lock();
         patentInstructionTextCondition.signalAll();
         patentInstructionTextLock.unlock();
-        //消费者5与专利关联数据
-        patentAssoLock.lock();
-        patentAssoCondition.signalAll();
-        patentAssoLock.unlock();
     }
 
-    public void queueAddTask(List<Integer> taskQueueList) {
+    /**
+     * 生产者任务队列新增任务ids
+     *
+     * @param taskQueueList 生产者任务队列
+     */
+    public void taskQueueAddTask(List<Integer> taskQueueList) {
         this.taskQueueList.addAll(taskQueueList);
     }
 
+    /**
+     * 消费者专利队列剔除指定任务的所有专利
+     *
+     * @param taskId 任务id
+     */
+    public void consumerQueueDeleteTasks(Integer taskId) {
+        this.patentImageQueueList.removeIf(queueData -> queueData.getTask().getId().equals(taskId));
+        this.patentZhuluQueueList.removeIf(queueData -> queueData.getTask().getId().equals(taskId));
+        this.patentRightQueueList.removeIf(queueData -> queueData.getTask().getId().equals(taskId));
+        this.patentInstructionTextQueueList.removeIf(queueData -> queueData.getTask().getId().equals(taskId));
+        this.patentIdMap.clear();
+    }
+
+    /**
+     * 唤醒生产者线程执
+     */
     public void awakeTasktch() {
         taskLock.lock();
         taskCondition.signalAll();
@@ -369,4 +362,5 @@ public class PantentQueueService {
 
     }
 
+
 }