Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-sonnet-4-20250514· AnthropicHugging Face LMArena Human Preference 140K

请提供FlowLong集成到java工作流应用程序中的完整技术方案和代码

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-opus-4-20250514’s answer.
  1. User

    请提供FlowLong集成到java工作流应用程序中的完整技术方案和代码

  2. Claude Assistant

    我将为您提供FlowLong集成到Java工作流应用程序中的完整技术方案。

    技术架构方案

    FlowLong是一个轻量级的Java工作流引擎,基于有向无环图(DAG)设计,支持流程定义、流程实例管理、任务分配等核心功能。

    核心组件架构

    • 流程引擎(ProcessEngine): 核心引擎,负责流程的执行和管理
    • 流程定义(ProcessModel): 定义工作流的结构和规则
    • 流程实例(ProcessInstance): 具体的流程执行实例
    • 任务管理(TaskService): 处理用户任务的分配和执行
    • 历史服务(HistoryService): 记录流程执行历史

    项目集成配置

    Maven依赖配置

    <dependencies>
        <!-- FlowLong核心依赖 -->
        <dependency>
            <groupId>com.flowlong</groupId>
            <artifactId>flowlong-core</artifactId>
            <version>1.0.0</version>
        </dependency>
        
        <!-- Spring Boot集成 -->
        <dependency>
            <groupId>com.flowlong</groupId>
            <artifactId>flowlong-spring-boot-starter</artifactId>
            <version>1.0.0</version>
        </dependency>
        
        <!-- 数据库支持 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>
        
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3</version>
        </dependency>
    </dependencies>
    

    数据库配置

    -- 创建FlowLong所需的数据表
    CREATE TABLE flw_process (
        id BIGINT PRIMARY KEY AUTO_INCREMENT,
        name VARCHAR(100) NOT NULL,
        display_name VARCHAR(200),
        type VARCHAR(100),
        instance_url VARCHAR(200),
        state TINYINT DEFAULT 1,
        content LONGTEXT,
        version INT DEFAULT 0,
        create_time DATETIME,
        create_by VARCHAR(50)
    );
    
    CREATE TABLE flw_instance (
        id BIGINT PRIMARY KEY AUTO_INCREMENT,
        process_id BIGINT NOT NULL,
        parent_id BIGINT,
        priority TINYINT,
        instance_no VARCHAR(50),
        business_key VARCHAR(100),
        variable TEXT,
        current_node_name VARCHAR(100),
        current_node_key VARCHAR(100),
        expire_time DATETIME,
        last_update_by VARCHAR(50),
        last_update_time DATETIME,
        create_time DATETIME,
        create_by VARCHAR(50)
    );
    
    CREATE TABLE flw_task (
        id BIGINT PRIMARY KEY AUTO_INCREMENT,
        instance_id BIGINT NOT NULL,
        parent_task_id BIGINT,
        task_name VARCHAR(100) NOT NULL,
        task_key VARCHAR(100),
        task_type TINYINT DEFAULT 0,
        perform_type TINYINT,
        action_url VARCHAR(200),
        variable TEXT,
        assignor VARCHAR(100),
        assignee VARCHAR(100),
        claim_time DATETIME,
        finish_time DATETIME,
        expire_time DATETIME,
        remind_time DATETIME,
        remind_repeat TINYINT,
        viewed TINYINT,
        create_time DATETIME,
        create_by VARCHAR(50)
    );
    

    核心代码实现

    1. 配置类

    @Configuration
    @EnableFlowLong
    public class FlowLongConfig {
        
        @Bean
        public ProcessEngine processEngine(DataSource dataSource) {
            Configuration configuration = new Configuration();
            configuration.setDataSource(dataSource);
            configuration.setApplicationContext(applicationContext);
            
            return configuration.buildProcessEngine();
        }
        
        @Bean
        public ProcessService processService(ProcessEngine processEngine) {
            return processEngine.getProcessService();
        }
        
        @Bean
        public RuntimeService runtimeService(ProcessEngine processEngine) {
            return processEngine.getRuntimeService();
        }
        
        @Bean
        public TaskService taskService(ProcessEngine processEngine) {
            return processEngine.getTaskService();
        }
        
        @Bean
        public HistoryService historyService(ProcessEngine processEngine) {
            return processEngine.getHistoryService();
        }
    }
    

    2. 流程定义服务

    @Service
    @Transactional
    public class WorkflowProcessService {
        
        @Autowired
        private ProcessService processService;
        
        @Autowired
        private RuntimeService runtimeService;
        
        /**
         * 部署流程定义
         */
        public Long deployProcess(String processName, String processContent) {
            try {
                ProcessModel processModel = ModelParser.parse(processContent);
                processModel.setName(processName);
                
                Long processId = processService.deploy(processModel);
                log.info("流程部署成功,流程ID: {}", processId);
                return processId;
            } catch (Exception e) {
                log.error("流程部署失败: {}", e.getMessage(), e);
                throw new WorkflowException("流程部署失败", e);
            }
        }
        
        /**
         * 启动流程实例
         */
        public ProcessInstance startProcess(Long processId, String businessKey, 
                                          Map<String, Object> variables, String creator) {
            try {
                ProcessInstance instance = runtimeService.startInstanceById(
                    processId, creator, variables);
                instance.setBusinessKey(businessKey);
                
                log.info("流程实例启动成功,实例ID: {}", instance.getId());
                return instance;
            } catch (Exception e) {
                log.error("启动流程实例失败: {}", e.getMessage(), e);
                throw new WorkflowException("启动流程实例失败", e);
            }
        }
        
        /**
         * 获取流程定义列表
         */
        public List<Process> getProcessList() {
            return processService.getProcesses();
        }
        
        /**
         * 根据ID获取流程定义
         */
        public Process getProcessById(Long processId) {
            return processService.getProcessById(processId);
        }
    }
    

    3. 任务管理服务

    @Service
    @Transactional
    public class WorkflowTaskService {
        
        @Autowired
        private TaskService taskService;
        
        @Autowired
        private RuntimeService runtimeService;
        
        /**
         * 获取用户待办任务
         */
        public List<Task> getPendingTasks(String assignee) {
            QueryFilter filter = new QueryFilter()
                .setAssignee(assignee)
                .setState(TaskState.ACTIVE);
            return taskService.getActiveTasks(filter);
        }
        
        /**
         * 完成任务
         */
        public void completeTask(Long taskId, String operator, 
                               Map<String, Object> variables) {
            try {
                Task task = taskService.getTask(taskId);
                if (task == null) {
                    throw new WorkflowException("任务不存在");
                }
                
                // 验证任务执行权限
                if (!canExecuteTask(task, operator)) {
                    throw new WorkflowException("无权限执行此任务");
                }
                
                // 完成任务
                taskService.complete(taskId, operator, variables);
                log.info("任务完成成功,任务ID: {}, 操作人: {}", taskId, operator);
                
            } catch (Exception e) {
                log.error("完成任务失败: {}", e.getMessage(), e);
                throw new WorkflowException("完成任务失败", e);
            }
        }
        
        /**
         * 委派任务
         */
        public void delegateTask(Long taskId, String fromUser, String toUser) {
            try {
                taskService.delegate(taskId, fromUser, toUser);
                log.info("任务委派成功,从 {} 委派给 {}", fromUser, toUser);
            } catch (Exception e) {
                log.error("任务委派失败: {}", e.getMessage(), e);
                throw new WorkflowException("任务委派失败", e);
            }
        }
        
        /**
         * 认领任务
         */
        public void claimTask(Long taskId, String assignee) {
            try {
                taskService.claim(taskId, assignee);
                log.info("任务认领成功,任务ID: {}, 认领人: {}", taskId, assignee);
            } catch (Exception e) {
                log.error("任务认领失败: {}", e.getMessage(), e);
                throw new WorkflowException("任务认领失败", e);
            }
        }
        
        private boolean canExecuteTask(Task task, String operator) {
            return Objects.equals(task.getAssignee(), operator) || 
                   hasAdminRole(operator);
        }
        
        private boolean hasAdminRole(String operator) {
            // 实现管理员权限检查逻辑
            return false;
        }
    }
    

    4. 流程实例管理服务

    @Service
    @Transactional
    public class WorkflowInstanceService {
        
        @Autowired
        private RuntimeService runtimeService;
        
        @Autowired
        private HistoryService historyService;
        
        /**
         * 获取流程实例列表
         */
        public Page<ProcessInstance> getInstanceList(QueryFilter filter, 
                                                   int pageNum, int pageSize) {
            return runtimeService.getInstances(filter, pageNum, pageSize);
        }
        
        /**
         * 根据业务键获取流程实例
         */
        public ProcessInstance getInstanceByBusinessKey(String businessKey) {
            QueryFilter filter = new QueryFilter().setBusinessKey(businessKey);
            List<ProcessInstance> instances = runtimeService.getInstances(filter);
            return instances.isEmpty() ? null : instances.get(0);
        }
        
        /**
         * 终止流程实例
         */
        public void terminateInstance(Long instanceId, String operator) {
            try {
                runtimeService.terminate(instanceId, operator);
                log.info("流程实例终止成功,实例ID: {}, 操作人: {}", instanceId, operator);
            } catch (Exception e) {
                log.error("终止流程实例失败: {}", e.getMessage(), e);
                throw new WorkflowException("终止流程实例失败", e);
            }
        }
        
        /**
         * 挂起流程实例
         */
        public void suspendInstance(Long instanceId, String operator) {
            try {
                runtimeService.suspend(instanceId, operator);
                log.info("流程实例挂起成功,实例ID: {}", instanceId);
            } catch (Exception e) {
                log.error("挂起流程实例失败: {}", e.getMessage(), e);
                throw new WorkflowException("挂起流程实例失败", e);
            }
        }
        
        /**
         * 恢复流程实例
         */
        public void resumeInstance(Long instanceId, String operator) {
            try {
                runtimeService.resume(instanceId, operator);
                log.info("流程实例恢复成功,实例ID: {}", instanceId);
            } catch (Exception e) {
                log.error("恢复流程实例失败: {}", e.getMessage(), e);
                throw new WorkflowException("恢复流程实例失败", e);
            }
        }
        
        /**
         * 获取流程实例历史
         */
        public List<HistoryInstance> getInstanceHistory(Long instanceId) {
            return historyService.getHistoryInstances(
                new QueryFilter().setInstanceId(instanceId));
        }
    }
    

    5. REST API控制器

    @RestController
    @RequestMapping("/api/workflow")
    @Slf4j
    public class WorkflowController {
        
        @Autowired
        private WorkflowProcessService processService;
        
        @Autowired
        private WorkflowTaskService taskService;
        
        @Autowired
        private WorkflowInstanceService instanceService;
        
        /**
         * 部署流程定义
         */
        @PostMapping("/process/deploy")
        public ApiResponse<Long> deployProcess(@RequestBody ProcessDeployRequest request) {
            Long processId = processService.deployProcess(
                request.getProcessName(), request.getProcessContent());
            return ApiResponse.success(processId);
        }
        
        /**
         * 启动流程实例
         */
        @PostMapping("/instance/start")
        public ApiResponse<ProcessInstance> startInstance(
                @RequestBody StartInstanceRequest request) {
            ProcessInstance instance = processService.startProcess(
                request.getProcessId(), 
                request.getBusinessKey(),
                request.getVariables(),
                getCurrentUser());
            return ApiResponse.success(instance);
        }
        
        /**
         * 获取待办任务
         */
        @GetMapping("/task/pending")
        public ApiResponse<List<Task>> getPendingTasks() {
            List<Task> tasks = taskService.getPendingTasks(getCurrentUser());
            return ApiResponse.success(tasks);
        }
        
        /**
         * 完成任务
         */
        @PostMapping("/task/{taskId}/complete")
        public ApiResponse<Void> completeTask(@PathVariable Long taskId,
                                            @RequestBody CompleteTaskRequest request) {
            taskService.completeTask(taskId, getCurrentUser(), request.getVariables());
            return ApiResponse.success();
        }
        
        /**
         * 获取流程实例列表
         */
        @GetMapping("/instance/list")
        public ApiResponse<Page<ProcessInstance>> getInstanceList(
                @RequestParam(defaultValue = "1") int pageNum,
                @RequestParam(defaultValue = "10") int pageSize,
                @RequestParam(required = false) String businessKey) {
            
            QueryFilter filter = new QueryFilter();
            if (StringUtils.hasText(businessKey)) {
                filter.setBusinessKey(businessKey);
            }
            
            Page<ProcessInstance> instances = instanceService.getInstanceList(
                filter, pageNum, pageSize);
            return ApiResponse.success(instances);
        }
        
        private String getCurrentUser() {
            // 从安全上下文获取当前用户
            return SecurityContextHolder.getContext()
                .getAuthentication().getName();
        }
    }
    

    6. 异常处理和响应封装

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class ApiResponse<T> {
        private int code;
        private String message;
        private T data;
        
        public static <T> ApiResponse<T> success(T data) {
            return new ApiResponse<>(200, "success", data);
        }
        
        public static <T> ApiResponse<T> success() {
            return new ApiResponse<>(200, "success", null);
        }
        
        public static <T> ApiResponse<T> error(String message) {
            return new ApiResponse<>(500, message, null);
        }
    }
    
    @ControllerAdvice
    public class GlobalException
    

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