专利之星任务导入专利代码

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

@@ -25,26 +25,25 @@ import java.util.stream.Collectors;
 @Component
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class CreateTaskThread implements InitializingBean {
-
     private final TaskService taskService;
     private final PantentQueueService pantentQueueService;
 
     @Override
     public void afterPropertiesSet() throws Exception {
         //初始化任务队列
-        //查找任务状态为0（队列中）和1（进行中）的任务
+        //查询出任务状态为0（队列中）和1（进行中）的任务
         List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().in(Task::getStatus, new ArrayList<>(Arrays.asList(0, 1))));
         if (tasks.size() > 0) {
-            //过滤出任务ids
+            //过滤出任务状态为0（队列中）和1（进行中）的任务的ids
             List<Integer> taskIds = tasks.stream().map(Task::getId).collect(Collectors.toList());
-            //过滤出进行中的任务的id
-            List<Task> doingTasks = tasks.stream().filter(item -> item.getStatus() == 1).collect(Collectors.toList());
-            List<Integer> doingTaskIds = doingTasks.stream().map(Task::getId).collect(Collectors.toList());
+            //过滤出任务状态为1（进行中）的任务的ids
+            List<Integer> doingTaskIds = tasks.stream().filter(item -> item.getStatus() == 1).map(Task::getId).collect(Collectors.toList());
             if (doingTaskIds.size() > 0) {
-                //先将进行中的任务（项目重启后进行中的任务仅会有1个）的id先存入任务队列，再将其余存入
-                pantentQueueService.taskQueueAddTask(Arrays.asList(doingTaskIds.get(0)));
+                //先将任务状态为1（进行中）的任务的ids存入任务队列
+                pantentQueueService.taskQueueAddTask(doingTaskIds);
                 taskIds.removeAll(doingTaskIds);
             }
+            //再将其余（任务状态为0（队列中）的任务的ids）存入任务队列
             pantentQueueService.taskQueueAddTask(taskIds);
         }
 
@@ -68,58 +67,20 @@ public class CreateTaskThread implements InitializingBean {
         Thread threadSetPatentPicture = new Thread(pantentQueueService::setPatentImage);
         threadSetPatentPicture.start();
 
-
-        //消费者1线程（摘要附图）
-        Thread threadConsumer1 = new Thread(() -> {
-            try {
-                pantentQueueService.pushPatentImageToDB();
-            } catch (InterruptedException | IOException e) {
-                e.printStackTrace();
-            }
-        });
+        //消费摘要附图线程
+        Thread threadConsumer1 = new Thread(pantentQueueService::pushPatentImageToDB);
         threadConsumer1.start();
-
-
-        //消费者2线程（著录项目）
-        Thread threadConsumer2 = new Thread(() -> {
-            try {
-                pantentQueueService.pushPatentZhuLuToDB();
-            } catch (InterruptedException | IOException e) {
-                e.printStackTrace();
-            }
-        });
+        //消费著录项目线程
+        Thread threadConsumer2 = new Thread(pantentQueueService::pushPatentZhuLuToDB);
         threadConsumer2.start();
-
-
-        //消费者3线程（权利要求）
-        Thread threadConsumer3 = new Thread(() -> {
-            try {
-                pantentQueueService.pushPatentRightToDB();
-            } catch (InterruptedException | IOException e) {
-                e.printStackTrace();
-            }
-        });
+        //消费权要线程
+        Thread threadConsumer3 = new Thread(pantentQueueService::pushPatentRightToDB);
         threadConsumer3.start();
-
-
-        //消费者4线程（说明书文本消费者）
-        Thread threadConsumer4 = new Thread(() -> {
-            try {
-                pantentQueueService.pushPatentInstructionTextToDB();
-            } catch (InterruptedException | IOException e) {
-                e.printStackTrace();
-            }
-        });
+        //消费说明书文本线程
+        Thread threadConsumer4 = new Thread(pantentQueueService::pushPatentInstructionTextToDB);
         threadConsumer4.start();
-
-        //消费者5线程（说明书pdf消费者）
-        Thread threadConsumer5 = new Thread(() -> {
-            try {
-                pantentQueueService.pushPatentInstructionPDFToDB();
-            } catch (InterruptedException | IOException e) {
-                e.printStackTrace();
-            }
-        });
+        //消费说明书pdf线程
+        Thread threadConsumer5 = new Thread(pantentQueueService::pushPatentInstructionPDFToDB);
         threadConsumer5.start();
 
     }

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

@@ -79,7 +79,7 @@ public class TaskController {
             assoOsTaskQrtzTask = uploadTaskService.addPatentStarTask(qrtzTaskAddNewDTO);
         }
 
-        //若是定时任务
+        //若是定时任务，则新增添加定时任务的job
         if (assoOsTaskQrtzTask.getTaskType() == 1) {
             jobService.addJob(assoOsTaskQrtzTask);
         }

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

@@ -40,20 +40,18 @@ public class ExcutePatentDataExcel implements IExcutePatentData {
     @Override
     public void startExcute(Task task) throws IOException {
         //从任务中取出文件路径、总条数、成功条数、前台参数json
-        String filePath = task.getUrl();  //相对路径
-        filePath = fileUtils.getPath(filePath);  //绝对路径
+        String filePath = fileUtils.getPath(task.getUrl());
         Integer total = task.getTotal();
+        int lastIndex = task.getSuccessNum();
+        ProjectImportPatentVO projectImportPatentVO = JsonUtils.jsonToPojo(task.getPramJson(), ProjectImportPatentVO.class);
 
-        int lastIndex = task.getSuccessNum();  //成功条数（即上一次遍历到的专利位置）
-        String json = task.getPramJson();
-        ProjectImportPatentVO projectImportPatentVO = JsonUtils.jsonToPojo(json, ProjectImportPatentVO.class);
         //解析数据源类，通过数据来源id（如1：智慧芽）解析数据源配置文件，获得数据源配置文件对象jsonData
         List<UploadSettingVO.Column> jsonData = excuteUploadSettingService.ExcuteUploadSetting(projectImportPatentVO.getSourceId());
         //解析Excel文件获得工作簿
         Sheet sheet = ReadExcelUtils.readExcel(filePath);
         //遍历专利总数量，在循环中将专利一个一个存入消费者专利队列
         for (int i = lastIndex; i < total; i++) {
-            //判断若任务状态为暂停（4），则不再生产该任务的专利
+            //判断若任务状态为已暂停，则结束生产
             if (pTaskId.equals(task.getId()) && pTaskStatus == 4) {
                 return;
             }

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

@@ -22,8 +22,9 @@ import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 
 /**
- * 1.生产专利（生产者从任务队列取出任务并解析任务生成专利数据，分配给消费者，唤醒消费者）
- * 2.消费专利（消费者从专利队列中取出专利并保存专利入库）
+ * 1.生产者线程生产专利（根据任务类型调用对应工厂方法执行获取专利数据）
+ * 2.装载者线程装载专利（将专利数据装载到专利实体类）
+ * 3.消费者线程消费专利（将专利入库）
  */
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
@@ -78,7 +79,7 @@ public class PantentQueueService {
         while (true) {
             Task task = new Task();
             try {
-                //判断任务队列是否有任务，若没有则该生产者线程睡眠
+                //判断任务队列是否有任务，若没有则线程等待唤醒
                 if (taskQueueList.size() == 0) {
                     taskLock.lock();
                     taskCondition.await();
@@ -86,18 +87,17 @@ public class PantentQueueService {
 
                 //线程被唤醒后 ↓
                 if (taskQueueList.size() > 0) {
-                    //从任务队列中取出一个task任务同时将其从任务队列中剔除
+                    //从任务队列中取出第一个task任务，同时将其从任务队列中剔除
                     task = taskService.getById(taskQueueList.remove(0));
-                    //若任务已不存在或任务状态为已暂停，则跳过当前，进行下一个任务
+                    //判断任务状态，若已不存在或已暂停，则跳过继续取下一个任务
                     if (task == null || task.getStatus() == 4) {
                         continue;
                     }
 
-                    //TODO 调用工厂方法并将任务扔进去，工厂方法会根据任务的类型创建并返回对应的生产专利方法的对象
-                    //1.用工厂方法根据任务类型创建对应的获取专利数据的对象
+                    //TODO 调用工厂方法，工厂方法会根据任务类型创建并返回对应的生产专利方法的对象
                     IExcutePatentData excutePatentDataObject = createObject(task);
                     if (excutePatentDataObject != null) {
-                        //执行生产专利方法
+                        //执行方法
                         excutePatentDataObject.startExcute(task);
                     }
 
@@ -105,7 +105,7 @@ public class PantentQueueService {
 
             } catch (Exception e) {
                 e.printStackTrace();
-                //任务表更新状态为失败
+                //任务表更新状态失败
                 task.setStatus(2);
                 task.setEndTime(DateUtils.getDateTime());
                 taskService.updateById(task);
@@ -298,9 +298,9 @@ public class PantentQueueService {
     }
 
     /**
-     * 消费者1：将专利从队列取出，摘要附图入库
+     * 消费者1：摘要附图入库
      */
-    public void pushPatentImageToDB() throws InterruptedException, IOException {
+    public void pushPatentImageToDB() {
         while (true) {
             QueueData queueData = new QueueData();
             try {
@@ -333,7 +333,7 @@ public class PantentQueueService {
     /**
      * 消费者2：将专利从队列取出，著录项目入库
      */
-    public void pushPatentZhuLuToDB() throws InterruptedException, IOException {
+    public void pushPatentZhuLuToDB() {
         while (true) {
             QueueData queueData = new QueueData();
             try {
@@ -366,7 +366,7 @@ public class PantentQueueService {
     /**
      * 消费者3：将专利从队列取出，权利要求文本入库
      */
-    public void pushPatentRightToDB() throws InterruptedException, IOException {
+    public void pushPatentRightToDB() {
         while (true) {
             QueueData queueData = new QueueData();
             try {
@@ -393,7 +393,7 @@ public class PantentQueueService {
     /**
      * 消费者4：将专利从队列取出，说明书文本入库
      */
-    public void pushPatentInstructionTextToDB() throws InterruptedException, IOException {
+    public void pushPatentInstructionTextToDB() {
         while (true) {
             QueueData queueData = new QueueData();
             try {
@@ -420,7 +420,7 @@ public class PantentQueueService {
     /**
      * 消费者5：将专利从队列取出，说明书pdf地址入库
      */
-    public void pushPatentInstructionPDFToDB() throws InterruptedException, IOException {
+    public void pushPatentInstructionPDFToDB() {
         while (true) {
             QueueData queueData = new QueueData();
             try {
@@ -660,9 +660,9 @@ public class PantentQueueService {
     private IExcutePatentData createObject(Task task) {
         //根据任务的类型创建并返回对应的解析获取专利数据的对象
         switch (task.getType()) {
-            case 1:  //Excel导入专利任务
+            case 1:  //Excel导入专利
                 return excutePatentDataExcel;
-            case 3:  //Epo欧专局网站导入
+            case 3:  //欧专局网站导入
                 return excutePatentDataEpo;
             case 4:  //专利之星网站导入
                 return excutePatentDataStar;