任务不存在时，更新关键词状态,更新创建订单id逻辑

guyue

9 天以前 a9e958ce3675c4950ceddd3fd6f939cdf0d2bc5a

任务不存在时，更新关键词状态,更新创建订单id逻辑

 src/main/java/com/linghu/config/ShutdownHookConfig.java

New file
@@ -0,0 +1,36 @@
package com.linghu.config;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.linghu.model.entity.KeywordTask;
import com.linghu.service.KeywordTaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;

@Configuration
public class ShutdownHookConfig {
    @Autowired
    private KeywordTaskService keywordTaskService;

    @PostConstruct
    public void registerShutdownHook() {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("JVM关闭钩子：执行最后的操作...");

            performFinalOperations();
        }));
    }

    private void performFinalOperations() {
        // 关键操作逻辑
        //将关键词任务关系中任务id为null的状态改为false
        LambdaUpdateWrapper<KeywordTask> updateWrapper =  new LambdaUpdateWrapper<>();
        updateWrapper.isNull(KeywordTask::getTask_id).set(KeywordTask::getStatus, "false");
        keywordTaskService.update(updateWrapper);


    }
}

 src/main/java/com/linghu/controller/CollectController.java

@@ -220,7 +220,7 @@
                        return Mono.just(ResponseResult.success("任务已被取消"));
                    }
                    // 如果任务状态是"submitted"或"running"，继续轮询
                    if (!"completed".equalsIgnoreCase(statusResponse.getStatus()) && !"failed".equalsIgnoreCase(statusResponse.getStatus()) && !"cancelled".equalsIgnoreCase(statusResponse.getStatus()) ) {
                    if (!"completed".equalsIgnoreCase(statusResponse.getStatus()) && !"failed".equalsIgnoreCase(statusResponse.getStatus()) && !"cancelled".equalsIgnoreCase(statusResponse.getStatus()) && !("ERROR".equalsIgnoreCase(statusResponse.getStatus()) && statusResponse.getMessage().contains("Task not found")) ) {
                        return Mono.delay(Duration.ofSeconds(5))  // 延迟 5 秒后再次查询
                                .flatMap(aLong -> waitForTaskCompletion(taskId, batchQueue, searchTaskRequest, keywordId));  // 递归调用继续等待
                    } else {
@@ -651,14 +651,14 @@
                    System.out.println("未找到关联的关键词，task_id: " + result.getTask_id());
                    //报错
                    throw new Exception("未找到关联的关键词，task_id: " + result.getTask_id());
//                    return;

                }
                LambdaQueryWrapper<KeywordTask> keywordTaskWrapper2 = new LambdaQueryWrapper<>();
                keywordTaskWrapper2.eq(KeywordTask::getKeyword_id, keyword.getKeyword_id());
                List<KeywordTask> keywordTasks = keywordTaskService.list(keywordTaskWrapper2);

                //如果全部为completed  关键词也为completed  ，如果关联关系没有任务id，或者状态为running  ，关键词为submitted，
                if (keywordTasks.stream().allMatch(task -> "completed".equals(task.getStatus()) || "false".equals(task.getStatus()) || "cancelled".equals(task.getStatus()) ||"canceled".equals(task.getStatus())) ) {
                //如果全部为completed 或者错误、取消、任务不存在 关键词也为completed  ，如果关联关系没有任务id，或者状态为running  ，关键词为submitted，
                if (keywordTasks.stream().allMatch(task -> "completed".equals(task.getStatus()) || "false".equals(task.getStatus()) || "cancelled".equals(task.getStatus()) ||"canceled".equals(task.getStatus()) || "nonentity".equals(task.getStatus())) ) {
                    keyword.setStatus("completed");
                    keywordService.updateById(keyword);


 src/main/java/com/linghu/controller/OrderController.java

@@ -16,6 +16,7 @@
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
@@ -42,6 +43,7 @@
     * 新增订单
     */
    @PostMapping
    @Transactional // 开启事务
    @ApiOperation(value = "新增订单")
    public ResponseResult<Orders> add(@RequestBody OrderDto orderDto) {
        // 将dto转entity
@@ -55,14 +57,26 @@
        // 生成订单ID：日期+当天的订单数量（如：202507060001）
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
        String dateStr = dateFormat.format(new Date());

        // 查询当天订单数量
        // 1. 查询当天最大的订单号（包含已删除的，适应硬删除场景）
        LambdaQueryWrapper<Orders> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.likeRight(Orders::getOrder_id, dateStr);
        long count = orderService.count(queryWrapper);
        queryWrapper.likeRight(Orders::getOrder_id, dateStr)
                .select(Orders::getOrder_id)
                .orderByDesc(Orders::getOrder_id)
                .last("LIMIT 1"); // 只取最大的一条
        Orders maxOrder = orderService.getOne(queryWrapper);
        int sequence = 1; // 默认序号

        // 生成订单ID
        String orderId = String.format("%s%04d", dateStr, count + 1);
        if (maxOrder != null && maxOrder.getOrder_id() != null) {
            // 2. 从最大订单号中提取序号（如"202507250005"提取"0005"）
            String maxId = maxOrder.getOrder_id();
            if (maxId.length() == dateStr.length() + 4) { // 校验格式
                String seqStr = maxId.substring(dateStr.length());
                sequence = Integer.parseInt(seqStr) + 1; // 序号+1
            }
        }

        // 3. 生成新订单号（补全4位，如1→0001）
        String  orderId = String.format("%s%04d", dateStr, sequence);
        order.setOrder_id(orderId);

        // 设置初始状态

 src/main/java/com/linghu/timeTask/ScheduledTasks.java

@@ -6,8 +6,10 @@
import com.linghu.controller.CollectController;
import com.linghu.model.dto.TaskResultResponse;
import com.linghu.model.dto.TaskStatusResponse;
import com.linghu.model.entity.Keyword;
import com.linghu.model.entity.KeywordTask;
import com.linghu.model.entity.Question;
import com.linghu.service.KeywordService;
import com.linghu.service.KeywordTaskService;
import com.linghu.service.QuestionService;
import lombok.extern.slf4j.Slf4j;
@@ -40,6 +42,8 @@
    private WebClient webClient; // 假设已配置WebClient
    @Autowired
    private QuestionService questionService;
    @Autowired
    private KeywordService keywordService;

    private volatile boolean isHealthy = true; // 健康状态标识
    private volatile boolean initialCheckComplete = false; // 初始检查完成标志
@@ -216,13 +220,17 @@
                            && !"running".equalsIgnoreCase(statusResponse.getStatus())
                            && !"Error".equalsIgnoreCase(statusResponse.getStatus())) {
                        task.setStatus("false");
                        return Mono.just(task);
                        // 新增：处理status为false时的关键词状态更新
                        return updateKeywordStatusWhenTaskFinished(task)
                                .then(Mono.just(task));
                    }else if ( "running".equalsIgnoreCase(statusResponse.getStatus())) {
                        //更新每个提问词的状态
                        return updateQuestionStatus(task, statusResponse); // 抽取为独立方法
                    }else if("ERROR".equalsIgnoreCase(statusResponse.getStatus())&&"任务不存在".equalsIgnoreCase(statusResponse.getMessage())){
                    }else if("ERROR".equalsIgnoreCase(statusResponse.getStatus())&&statusResponse.getMessage().contains("Task not found")){
                        task.setStatus("nonentity");
                        return Mono.just(task);
                        // 更新关键词状态
                        return updateKeywordStatusWhenTaskFinished(task)
                                .then(Mono.just(task));
                    }
                    else {
                        // 任务仍在进行中，不更新状态
@@ -273,4 +281,33 @@
                })
                .then(Mono.just(task));
    }
    /**
     * 当任务状态为false/nonentity时，更新关键词状态
     */
    private Mono<Void> updateKeywordStatusWhenTaskFinished(KeywordTask task) {
        return Mono.fromSupplier(() -> {
            Keyword keyword = keywordService.getById(task.getKeyword_id());
            LambdaQueryWrapper<KeywordTask> keywordTaskWrapper = new LambdaQueryWrapper<>();
            keywordTaskWrapper.eq(KeywordTask::getKeyword_id, keyword.getKeyword_id());
            return keywordTaskService.list(keywordTaskWrapper);
        }).flatMap(keywordTasks -> {
            // 检查所有关联任务是否都已完成（包括各种结束状态）
            boolean allCompleted = keywordTasks.stream().allMatch(t ->
                    "completed".equals(t.getStatus()) ||
                            "false".equals(t.getStatus()) ||
                            "cancelled".equals(t.getStatus()) ||
                            "canceled".equals(t.getStatus()) ||
                            "nonentity".equals(t.getStatus())
            );

            if (allCompleted) {
                Keyword keyword = keywordService.getById(task.getKeyword_id());
                keyword.setStatus("completed");
                //
                return Mono.fromSupplier(() -> keywordService.updateById(keyword))
                        .then(); // 转换为Mono<Void>
            }
            return Mono.empty();
        });
    }
}