Skip to content
The Chat Archive
llama-4-maverick-17b-128e-instruct· Meta LMArena Human Preference 140K

#实现一个功能 1.用户提交一个文件id,创建一个任务 任务状态 RUNNING FAILED CANCELLED COMPLETED 任务进度 1 - 100 任务取消信号量…

  1. User

    #实现一个功能

    1.用户提交一个文件id,创建一个任务

    任务状态 RUNNING FAILED CANCELLED COMPLETED

    任务进度 1 - 100

    任务取消信号量

    取消任务可以不立即生效 1min中之内,新的子任务不再执行,未完成的子任务要中断

    子任务成功数量、失败数量、取消数量、实际总执行数量

    2.这个主任务要开启大量异步线程执行具体任务

    根据fileId 查询数据库公共附件表 类型是 doc docx,latest =1 ,非当前fileId 且文件名不重复的指定条数的记录

    根据响应的文件列表执行子任务

    获取ftp路径,连接ftp服务器 批量查询对应的流,失败使用Retry重试,获取对应的文本信息与传入的fileId对应的文本分别作为 待匹配内容与匹配内容参数调用第三方API

    将接口返回的信息通过 stomp 发送给前端

    子任务全部完成(与生成的子任务数相等,比如100个子任务 90个成功 3个失败 1个超时 6个取消)发送任务全部处理完毕通知

    限制

    1.CPU密集与IO密集的场景区分使用自己的线程池子,线程取消策略要着重处理 2.使用Java8 SpringBoot2.1.3 reactor-core 3.3.0 netty-all 4.1.9final 3.使用合适的设计模式 4.遵循solid原则 5.从配置到代码给出详细步骤及其说明 6.不使用redis 单机版本 7.最好使用内存管理任务及其子任务 8.任务一定要能够取消,支持中断,有重试机制 9.区分用户 10.采用DDD+TDD

  2. Assistant

    为了实现您描述的功能,我们将采用领域驱动设计(DDD)和测试驱动开发(TDD)的方法,使用Java 8和Spring Boot 2.1.3。以下是一个简化的实现方案,重点关注任务管理和异步处理。

    步骤1:项目配置

    首先,创建一个新的Spring Boot项目,并添加必要的依赖到pom.xml(如果您使用Maven)或build.gradle(如果您使用Gradle):

    <!-- Maven -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>io.projectreactor</groupId>
            <artifactId>reactor-core</artifactId>
            <version>3.3.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.9.Final</version>
        </dependency>
        <!-- 添加STOMP依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-messaging</artifactId>
        </dependency>
        <!-- 数据库驱动,以MySQL为例 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
    </dependencies>
    

    步骤2:领域模型设计

    定义任务和子任务的领域模型:

    // Task.java
    @Entity
    public class Task {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
        private String fileId;
        private TaskStatus status;
        private int progress;
        // Getters and setters
    }
    
    // SubTask.java
    @Entity
    public class SubTask {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
        private String filePath;
        private SubTaskStatus status;
        @ManyToOne
        private Task task;
        // Getters and setters
    }
    
    public enum TaskStatus {
        RUNNING, FAILED, CANCELLED, COMPLETED
    }
    
    public enum SubTaskStatus {
        RUNNING, FAILED, CANCELLED, COMPLETED
    }
    

    步骤3:任务服务实现

    创建任务服务,负责任务的创建、取消和状态更新:

    // TaskService.java
    @Service
    public class TaskService {
        @Autowired
        private TaskRepository taskRepository;
        @Autowired
        private SubTaskService subTaskService;
        
        public Task createTask(String fileId) {
            Task task = new Task();
            task.setFileId(fileId);
            task.setStatus(TaskStatus.RUNNING);
            task = taskRepository.save(task);
            subTaskService.createSubTasks(task);
            return task;
        }
        
        public void cancelTask(Long taskId) {
            Task task = taskRepository.findById(taskId).orElseThrow();
            task.setStatus(TaskStatus.CANCELLED);
            taskRepository.save(task);
            subTaskService.cancelSubTasks(task);
        }
    }
    

    步骤4:子任务服务实现

    实现子任务服务,负责子任务的创建、执行和状态更新:

    // SubTaskService.java
    @Service
    public class SubTaskService {
        @Autowired
        private SubTaskRepository subTaskRepository;
        @Autowired
        private FTPService ftpService;
        @Autowired
        private ThirdPartyApi thirdPartyApi;
        @Autowired
        private SimpMessagingTemplate simpMessagingTemplate;
        
        public void createSubTasks(Task task) {
            // 根据fileId查询数据库,获取文件列表
            List<String> filePaths = queryFilePaths(task.getFileId());
            for (String filePath : filePaths) {
                SubTask subTask = new SubTask();
                subTask.setFilePath(filePath);
                subTask.setTask(task);
                subTask.setStatus(SubTaskStatus.RUNNING);
                subTaskRepository.save(subTask);
                executeSubTask(subTask);
            }
        }
        
        private void executeSubTask(SubTask subTask) {
            // 使用线程池执行子任务
            ExecutorService executor = Executors.newFixedThreadPool(10); // 根据需要调整线程池大小
            executor.submit(() -> {
                try {
                    // 连接FTP,获取文件流
                    InputStream inputStream = ftpService.getFile(subTask.getFilePath());
                    // 调用第三方API
                    String result = thirdPartyApi.process(inputStream, subTask.getTask().getFileId());
                    // 发送结果给前端
                    simpMessagingTemplate.convertAndSend("/topic/task/" + subTask.getTask().getId(), result);
                    subTask.setStatus(SubTaskStatus.COMPLETED);
                } catch (Exception e) {
                    subTask.setStatus(SubTaskStatus.FAILED);
                } finally {
                    subTaskRepository.save(subTask);
                }
            });
        }
        
        public void cancelSubTasks(Task task) {
            // 取消子任务
            List<SubTask> subTasks = subTaskRepository.findByTask(task);
            for (SubTask subTask : subTasks) {
                if (subTask.getStatus() == SubTaskStatus.RUNNING) {
                    subTask.setStatus(SubTaskStatus.CANCELLED);
                    subTaskRepository.save(subTask);
                    // 中断线程或取消任务
                }
            }
        }
    }
    

    步骤5:配置STOMP

    配置STOMP以实现实时消息推送:

    // WebSocketConfig.java
    @Configuration
    @EnableWebSocketMessageBroker
    public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
        @Override
        public void configureMessageBroker(MessageBrokerRegistry config) {
            config.enableSimpleBroker("/topic");
            config.setApplicationDestinationPrefixes("/app");
        }
        
        @Override
        public void registerStompEndpoints(StompEndpointRegistry registry) {
            registry.addEndpoint("/ws").setAllowedOrigins("*").withSockJS();
        }
    }
    

    步骤6:TDD

    编写单元测试和集成测试,确保代码的正确性和稳定性。

    // TaskServiceTest.java
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class TaskServiceTest {
        @Autowired
        private TaskService taskService;
        
        @Test
        public void testCreateTask() {
            // 测试创建任务
        }
        
        @Test
        public void testCancelTask() {
            // 测试取消任务
        }
    }
    

    结论

    上述步骤提供了一个基本的框架,用于实现您描述的功能。您需要根据具体的业务需求和技术栈调整和完善代码。同时,确保遵循SOLID原则和DDD的指导原则,以保持代码的可维护性和可扩展性。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.