Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-opus-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-sonnet-4-20250514’s answer.
  1. User

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

  2. Claude Assistant

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

    技术方案概述

    FlowLong是一个轻量级的Java工作流引擎,支持BPMN 2.0标准,适合集成到各种Java应用中。以下是完整的集成方案。

    一、环境准备和依赖配置

    Maven依赖配置

    <dependencies>
        <!-- FlowLong核心依赖 -->
        <dependency>
            <groupId>com.flowlong</groupId>
            <artifactId>flowlong-core</artifactId>
            <version>1.0.0</version>
        </dependency>
        
        <!-- 数据库驱动(以MySQL为例) -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>
        
        <!-- 连接池 -->
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
            <version>5.0.1</version>
        </dependency>
        
        <!-- Spring Boot相关依赖(如果使用Spring Boot) -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.7.0</version>
        </dependency>
    </dependencies>
    

    二、数据库初始化

    创建FlowLong所需的数据库表

    -- 流程定义表
    CREATE TABLE `flw_process` (
        `id` varchar(32) NOT NULL COMMENT '主键ID',
        `name` varchar(100) NOT NULL COMMENT '流程名称',
        `display_name` varchar(200) COMMENT '流程显示名称',
        `type` varchar(50) COMMENT '流程类型',
        `instance_url` varchar(200) COMMENT '实例URL',
        `state` tinyint DEFAULT 1 COMMENT '状态',
        `content` longblob COMMENT '流程定义内容',
        `version` int DEFAULT 0 COMMENT '版本号',
        `create_time` datetime COMMENT '创建时间',
        `creator` varchar(50) COMMENT '创建人',
        PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    
    -- 流程实例表
    CREATE TABLE `flw_instance` (
        `id` varchar(32) NOT NULL COMMENT '主键ID',
        `process_id` varchar(32) NOT NULL COMMENT '流程定义ID',
        `parent_id` varchar(32) COMMENT '父流程实例ID',
        `priority` tinyint DEFAULT 0 COMMENT '优先级',
        `instance_no` varchar(50) COMMENT '流程实例编号',
        `business_key` varchar(100) COMMENT '业务关联键',
        `variable` text COMMENT '流程变量',
        `current_node` varchar(100) COMMENT '当前节点',
        `create_time` datetime COMMENT '创建时间',
        `creator` varchar(50) COMMENT '创建人',
        `last_update_time` datetime COMMENT '最后更新时间',
        `last_updator` varchar(50) COMMENT '最后更新人',
        `expire_time` datetime COMMENT '期望完成时间',
        `state` tinyint DEFAULT 1 COMMENT '状态',
        PRIMARY KEY (`id`),
        KEY `idx_process_id` (`process_id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    
    -- 任务表
    CREATE TABLE `flw_task` (
        `id` varchar(32) NOT NULL COMMENT '主键ID',
        `instance_id` varchar(32) NOT NULL COMMENT '流程实例ID',
        `task_name` varchar(100) NOT NULL COMMENT '任务名称',
        `display_name` varchar(200) COMMENT '任务显示名称',
        `task_type` tinyint DEFAULT 0 COMMENT '任务类型',
        `perform_type` tinyint DEFAULT 0 COMMENT '参与类型',
        `action_url` varchar(200) COMMENT '任务处理URL',
        `variable` text COMMENT '任务变量',
        `assignee` varchar(100) COMMENT '任务处理人',
        `create_time` datetime COMMENT '创建时间',
        `finish_time` datetime COMMENT '完成时间',
        `expire_time` datetime COMMENT '期望完成时间',
        `remind_time` datetime COMMENT '提醒时间',
        `state` tinyint DEFAULT 1 COMMENT '状态',
        PRIMARY KEY (`id`),
        KEY `idx_instance_id` (`instance_id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    
    -- 任务参与者表
    CREATE TABLE `flw_task_actor` (
        `id` varchar(32) NOT NULL COMMENT '主键ID',
        `task_id` varchar(32) NOT NULL COMMENT '任务ID',
        `actor_id` varchar(100) NOT NULL COMMENT '参与者ID',
        `actor_name` varchar(100) COMMENT '参与者名称',
        `actor_type` tinyint DEFAULT 0 COMMENT '参与者类型',
        PRIMARY KEY (`id`),
        KEY `idx_task_id` (`task_id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    
    -- 历史流程实例表
    CREATE TABLE `flw_his_instance` (
        `id` varchar(32) NOT NULL COMMENT '主键ID',
        `process_id` varchar(32) NOT NULL COMMENT '流程定义ID',
        `instance_no` varchar(50) COMMENT '流程实例编号',
        `business_key` varchar(100) COMMENT '业务关联键',
        `variable` text COMMENT '流程变量',
        `create_time` datetime COMMENT '创建时间',
        `creator` varchar(50) COMMENT '创建人',
        `end_time` datetime COMMENT '结束时间',
        `duration` bigint COMMENT '处理时长',
        `state` tinyint COMMENT '状态',
        PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    
    -- 历史任务表
    CREATE TABLE `flw_his_task` (
        `id` varchar(32) NOT NULL COMMENT '主键ID',
        `instance_id` varchar(32) NOT NULL COMMENT '流程实例ID',
        `task_name` varchar(100) NOT NULL COMMENT '任务名称',
        `display_name` varchar(200) COMMENT '任务显示名称',
        `task_type` tinyint DEFAULT 0 COMMENT '任务类型',
        `assignee` varchar(100) COMMENT '任务处理人',
        `create_time` datetime COMMENT '创建时间',
        `finish_time` datetime COMMENT '完成时间',
        `duration` bigint COMMENT '处理时长',
        `state` tinyint COMMENT '状态',
        `operator` varchar(100) COMMENT '操作人',
        `remark` varchar(500) COMMENT '备注',
        PRIMARY KEY (`id`),
        KEY `idx_instance_id` (`instance_id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    

    三、核心配置类

    1. FlowLong配置类

    package com.example.workflow.config;
    
    import com.flowlong.bpm.engine.ProcessEngine;
    import com.flowlong.bpm.engine.ProcessEngineBuilder;
    import com.flowlong.bpm.engine.cfg.Configuration;
    import com.zaxxer.hikari.HikariConfig;
    import com.zaxxer.hikari.HikariDataSource;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import javax.sql.DataSource;
    
    @Configuration
    public class FlowLongConfig {
        
        @Value("${spring.datasource.url}")
        private String jdbcUrl;
        
        @Value("${spring.datasource.username}")
        private String username;
        
        @Value("${spring.datasource.password}")
        private String password;
        
        @Bean
        public DataSource dataSource() {
            HikariConfig config = new HikariConfig();
            config.setJdbcUrl(jdbcUrl);
            config.setUsername(username);
            config.setPassword(password);
            config.setMaximumPoolSize(10);
            config.setMinimumIdle(5);
            config.setConnectionTimeout(30000);
            config.setIdleTimeout(600000);
            config.setMaxLifetime(1800000);
            return new HikariDataSource(config);
        }
        
        @Bean
        public ProcessEngine processEngine(DataSource dataSource) {
            Configuration configuration = new Configuration();
            configuration.setDataSource(dataSource);
            configuration.setDbType("mysql");
            configuration.setInstanceNoGenerator(new CustomInstanceNoGenerator());
            configuration.setTaskAccessStrategy(new CustomTaskAccessStrategy());
            
            return ProcessEngineBuilder.create()
                    .configuration(configuration)
                    .build();
        }
    }
    

    2. 自定义流程实例编号生成器

    package com.example.workflow.config;
    
    import com.flowlong.bpm.engine.core.instance.InstanceNoGenerator;
    import com.flowlong.bpm.engine.entity.Process;
    
    import java.time.LocalDateTime;
    import java.time.format.DateTimeFormatter;
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class CustomInstanceNoGenerator implements InstanceNoGenerator {
        
        private static final AtomicInteger SEQUENCE = new AtomicInteger(0);
        private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
        
        @Override
        public String generate(Process process) {
            String timestamp = LocalDateTime.now().format(FORMATTER);
            int seq = SEQUENCE.incrementAndGet() % 10000;
            return String.format("%s-%s-%04d", process.getName(), timestamp, seq);
        }
    }
    

    3. 自定义任务访问策略

    package com.example.workflow.config;
    
    import com.flowlong.bpm.engine.TaskAccessStrategy;
    import com.flowlong.bpm.engine.entity.Task;
    
    import java.util.List;
    
    public class CustomTaskAccessStrategy implements TaskAccessStrategy {
        
        @Override
        public boolean isAllowed(String userId, List<Task> tasks) {
            // 实现自定义的任务访问权限逻辑
            for (Task task : tasks) {
                // 检查用户是否是任务的处理人
                if (userId.equals(task.getAssignee())) {
                    return true;
                }
                
                // 检查用户是否在任务参与者列表中
                if (task.getActorIds() != null && task.getActorIds().contains(userId)) {
                    return true;
                }
            }
            return false;
        }
    }
    

    四、业务服务层实现

    1. 工作流服务接口

    package com.example.workflow.service;
    
    import com.example.workflow.dto.*;
    import java.util.List;
    import java.util.Map;
    
    public interface WorkflowService {
        
        // 流程定义相关
        ProcessDefinitionDTO deployProcess(String processContent, String processName);
        List<ProcessDefinitionDTO> getProcessDefinitions();
        void deleteProcess(String processId);
        
        // 流程实例相关
        ProcessInstanceDTO startProcess(String processId, String businessKey, Map<String, Object> variables);
        ProcessInstanceDTO getProcessInstance(String instanceId);
        List<ProcessInstanceDTO> getActiveProcessInstances();
        void terminateProcess(String instanceId, String reason);
        
        // 任务相关
        List<TaskDTO> getMyTasks(String userId);
        List<TaskDTO> getTasksByInstanceId(String instanceId);
        void completeTask(String taskId, String userId, Map<String, Object> variables);
        void claimTask(String taskId, String userId);
        void delegateTask(String taskId, String fromUserId, String toUserId);
        
        // 历史查询
        List<HistoricProcessInstanceDTO> getHistoricProcessInstances(String businessKey);
        List<HistoricTaskDTO> getHistoricTasks(String instanceId);
    }
    

    2. 工作流服务实现

    package com.example.workflow.service.impl;
    
    import com.example.workflow.dto.*;
    import com.example.workflow.service.WorkflowService;
    import com.flowlong.bpm.engine.*;
    import com.flowlong.bpm.engine.entity.*;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    import java.util.*;
    import java.util.stream.Collectors;
    
    @Service
    @Transactional
    public class WorkflowServiceImpl implements WorkflowService {
        
        @Autowired
        private ProcessEngine processEngine;
        
        @Override
        public ProcessDefinitionDTO deployProcess(String processContent, String processName) {
            ProcessService processService = processEngine.processService();
            
            Process process = processService.deploy(processContent, processName);
            
            return convertToProcessDefinitionDTO(process);
        }
        
        @Override
        public List<ProcessDefinitionDTO> getProcessDefinitions() {
            ProcessService processService = processEngine.processService();
            List<Process> processes = processService.getProcessList();
            
            return processes.stream()
                    .map(this::convertToProcessDefinitionDTO)
                    .collect(Collectors.toList());
        }
        
        @Override
        public void deleteProcess(String processId) {
            ProcessService processService = processEngine.processService();
            processService.undeploy(processId);
        }
        
        @Override
        public ProcessInstanceDTO startProcess(String processId, String businessKey, Map<String, Object> variables) {
            RuntimeService runtimeService = processEngine.runtimeService();
            
            Instance instance = runtimeService.startInstanceById(processId, businessKey, variables);
            
            return convertToProcessInstanceDTO(instance);
        }
        
        @Override
        public ProcessInstanceDTO getProcessInstance(String instanceId) {
            QueryService queryService = processEngine.queryService();
            Instance instance = queryService.getInstance(instanceId);
            
            return convertToProcessInstanceDTO(instance);
        }
        
        @Override
        public List<ProcessInstanceDTO> getActiveProcessInstances() {
            QueryService queryService = processEngine.queryService();
            List<Instance> instances = queryService.getActiveInstances();
            
            return instances.stream()
                    .map(this::convertToProcessInstanceDTO)
                    .collect(Collectors.toList());
        }
        
        @Override
        public void terminateProcess(String instanceId, String reason) {
            RuntimeService runtimeService = processEngine.runtimeService();
            runtimeService.terminate(instanceId, reason);
        }
        
        @Override
        public List<TaskDTO> getMyTasks(String userId) {
            TaskService taskService = processEngine.taskService();
            List<Task> tasks = taskService.getTasksByUserId(userId);
            
            return tasks.stream()
                    .map(this::convertToTaskDTO)
                    .collect(Collectors.toList());
        }
        
        @Override
        public List<TaskDTO> getTasksByInstanceId(String instanceId) {
            TaskService taskService = processEngine.taskService();
            List
    

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