Activiti学习笔记三

最新推荐文章于 2025-06-03 21:50:27 发布
原创 最新推荐文章于 2025-06-03 21:50:27 发布 · 568 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Activiti

本文深入探讨了Activiti流程引擎的部署、启动、任务管理及流程变量设置与获取的全过程，详细介绍了流程定义、部署、启动流程实例、任务查询与完成、流程变量的设置与获取等关键操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

流程定义

管理流程定义

/**
     * 流程部署方式1
     */
    private ProcessEngine processEngine = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("/activiti.cfg.xml").buildProcessEngine();
    @Test
    public void deployProcess(){
        //得到RepositoryService
        RepositoryService service = processEngine.getRepositoryService();
        //部署
        InputStream isBpmn = this.getClass().getResourceAsStream("/LeaveBill.xml");
        InputStream isPng = this.getClass().getResourceAsStream("/LeaveBill.png");
        Deployment deployment = service.createDeployment().name("请假流程001")//部署的名称
                .addInputStream("LeaveBill.bpmn", isBpmn)//设置；流程图的xml文件
                .addInputStream("LeaveBill.png", isPng)//设置流程图的PNG文件
                .deploy();//确定
        /**
         * act_re_deployment：流程部署表
         * act_re_model：
         * act_re_procdef：流程定义表，它和部署表里面的数据是一一对应的
         * act_ge_bytearray：二进制文件存放表，和部署表和定义表是2-1关系
         * act_ge_property：系统内置表存放activiti的版本和自动增长的字段
         */

        System.out.println("流程部署成功：");
        System.out.println("部署ID：" + deployment.getId());
        System.out.println("部署名称：" + deployment.getName());
        System.out.println("部署时间：" + deployment.getDeploymentTime().toLocaleString());
    }

    /**
     * 流程部署方式2
     */
    @Test
    public void deployProcess2(){
        //得到RepositoryService
        RepositoryService service = processEngine.getRepositoryService();
        //部署
        Deployment deployment = service.createDeployment().name("请假流程002")//部署的名称act_re_deployment-name
                .addClasspathResource("LeaveBill.xml")//指src下面的文件
                .addClasspathResource("LeaveBill.png")//指src下面的文件
                .deploy();//确定部署
        System.out.println("流程部署成功：");
        System.out.println("部署ID：" + deployment.getId());
        System.out.println("部署名称：" + deployment.getName());
        System.out.println("部署时间：" + deployment.getDeploymentTime().toLocaleString());
    }
    /**
     * 流程部署方式3
     */
    @Test
    public void deployProcess3_zip(){
        //得到RepositoryService
        RepositoryService service = processEngine.getRepositoryService();
        //部署
        InputStream is = this.getClass().getResourceAsStream("/LeaveBill.zip");
        ZipInputStream zipInputStream = new ZipInputStream(is);
        Deployment deployment = service.createDeployment().name("请假流程003")//部署的名称
                .addZipInputStream(zipInputStream)
                .deploy();//确定部署
        System.out.println("流程部署成功：");
        System.out.println("部署ID：" + deployment.getId());
        System.out.println("部署名称：" + deployment.getName());
        System.out.println("部署时间：" + deployment.getDeploymentTime().toLocaleString());
    }

查看流程部署

    /**
     * 查看流程部署
     */
    @Test
    public void findProcessDeployment(){
        //得到流程管理的服务
        RepositoryService repositoryService = this.processEngine.getRepositoryService();
        List<Deployment> list = repositoryService.createDeploymentQuery()//创建查询分析器
                //where
                //.deploymentId()//通过部署ID查询流程部署act_re_deployment的id
                //.deploymentName()
                //.deploymentNameLike()
                //排序
                //.asc()
                //.desc()
                //结果集
                //.count();//查询流程部署的总根据条数
                //.singleResult()//查询单个结果集
                .list();//返回数据的结果
        if (list != null && list.size() > 0){
            for(Deployment deployment : list){
                System.out.println("流程部署成功：");
                System.out.println("部署ID：" + deployment.getId());
                System.out.println("部署名称：" + deployment.getName());
                System.out.println("部署时间：" + deployment.getDeploymentTime().toLocaleString());
            }
        }

    }

查看流程的定义

/**
     * 查看流程定义
     */
    @Test
    public void findProcessDefinition(){
        //得到流程管理的服务
        RepositoryService repositoryService = this.processEngine.getRepositoryService();
        List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery()//创建查询分析器
                //where查询
                //.deploymentId("")//通过部署ID查询流程部署act_re_deployment的id
                //.deploymentIds()//根据部署ID的set集合查询
                //.processDefinitionId()//根据流程定义的ID查询act_re_procdef的ID
                //.processDefinitionKey()//根据流程定义的KEY查询act_re_procdef的KEY
                //.processDefinitionKeyLike("%" + key + "%")//根据流程定义的KEY模糊查询act_re_procdef的KEY
                //.processDefinitionName()//根据流程定义的NAME查询act_re_procdef的NAME
                //.processDefinitionNameLike("%" + NAME + "%")//根据流程定义的NAME模糊查询act_re_procdef的NAME
                //.processDefinitionResourceName()//根据流程定义的RESOURCE_NAME查询act_re_procdef的RESOURCE_NAME
                //.processDefinitionResourceNameLike("%" + resouce_name + "%")//根据流程定义的RESOURCE_NAME模糊查询act_re_procdef的RESOURCE_NAME
                //.processDefinitionVersion()//根据版本查询
                //排序
                //.orderByDeploymentId().asc()//根据流程部署的ID 升序查询
                //.orderByProcessDefinitionKey().asc()//根据流程定义的KEY 升序查询
                .orderByProcessDefinitionId().desc()//根据流程定义的ID 降序查询
                //.orderByProcessDefinitionName().asc()//根据流程定义的NAME 升序查询
                //.asc()
                //.desc()
                //结果集
                //.count();//根据部署的总根据条数
                //.singleResult()//查询单个结果集
                .list();//返回数据的结果
        if (list != null && list.size() > 0){
                for(ProcessDefinition processDefinition : list){
                    System.out.println("流程定义ID：" + processDefinition.getId());
                    System.out.println("流程定义名称：" + processDefinition.getName());
                    System.out.println("流程定义KEY：" + processDefinition.getKey());
                    System.out.println("流程定义BPMN的文件名：" + processDefinition.getResourceName());
                    System.out.println("流程定义版本号：" + processDefinition.getVersion());
                }
            }
    }

删除流程定义

    /**
     * 删除流程定义
     */
    @Test
    public void deleteProcessDefinition(){
        //得到流程管理的服务
        RepositoryService repositoryService = this.processEngine.getRepositoryService();
        String deploymentId = "";
        //repositoryService.deleteDeployment(deploymentId);//根据部署ID删除流程定义 如果当前流程正在执行，删除会报异常
        repositoryService.deleteDeployment(deploymentId,true);//根据部署ID删除流程定义 cascade=false 它和上面的删除方法一样
                                                                  //cascade=true 删除正在执行的流程，不会抛出异常
        System.out.println("删除成功");
    }

获取流程定义文档的资源(获得图片)

/**
     * 获取流程定义文档的资源(查看流程图附件)
     */
    @Test
    public void viewProcessDefinitionImg(){
        //得到流程管理的服务
        RepositoryService repositoryService = this.processEngine.getRepositoryService();
        //String processDefinitionId = "";
        //InputStream inputStream = repositoryService.getProcessDiagram(processDefinitionId);
        //如果只知道流程部署ID如何查询
        String deploymentId = "";
        ProcessDefinition processDefinition = (ProcessDefinition) repositoryService.createProcessDefinitionQuery().deploymentId(deploymentId);
        String processDefinitionId = processDefinition.getId();
        InputStream inputStream = repositoryService.getProcessDiagram(processDefinitionId);
        try {
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("/opt"));
            byte [] b = new byte[1024];
            int len = 0;
            while((len = inputStream.read(b)) != -1){
                bos.write(b,0,len);
            }
            bos.flush();
            bos.close();
            inputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

查询最新版本的流程定义

    /**
     * 附加功能：查询最新版本的流程定义
     */
    @Test
    public void findMaxVersionProcessDefinition(){
        //得到流程管理的服务
        RepositoryService repositoryService = this.processEngine.getRepositoryService();
        List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery()
                .orderByProcessDefinitionKey().desc()
                .orderByProcessDefinitionVersion().asc()
                .list();
        Map<String,ProcessDefinition> map = new HashMap<>();
        if(list != null && list.size() > 0){
            for(ProcessDefinition processDefinition : list){
                map.put(processDefinition.getKey(),processDefinition); 
            }
        }
        Collection<ProcessDefinition> collection = map.values();
        for(ProcessDefinition processDefinition : collection){
            System.out.println("流程定义ID：" + processDefinition.getId());
            System.out.println("流程定义名称：" + processDefinition.getName());
            System.out.println("流程定义KEY：" + processDefinition.getKey());
            System.out.println("流程定义BPMN的文件名：" + processDefinition.getResourceName());
            System.out.println("流程定义版本号：" + processDefinition.getVersion());
        }
    }

删除key相同的不同版本的流程定义

    /**
     * 附加功能：删除流程定义(删除key相同的所有不同版本的流程定义)
     */
    //已知最高版本的流程实例ID 删除这个流程的所有不同版本
    @Test
    public void deleteAllSameKeyProcessDefinition(){
        String processDefintionId = "";
        //根据ID找到KEY
        //得到流程管理的服务
        RepositoryService repositoryService = this.processEngine.getRepositoryService();
        ProcessDefinition processDefinition = (ProcessDefinition) repositoryService.createProcessDefinitionQuery().processDefinitionId(processDefintionId);
        String processDefinitionKey = processDefinition.getKey();
        List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery().processDefinitionKey(processDefinitionKey).list();
        for(ProcessDefinition processDefinition1 : list){
            repositoryService.deleteDeployment(processDefinition.getDeploymentId(),true);
        }
    }

总结：

  • Deployment部署对象

    1、一次部署多个文件的信息。对于不需要的流程可以删除和修改

    2、对应的表

    ​ act_re_deployment：部署对象表

    ​ act_re_procdef：流程定义表

    ​ act_ge_bytearray：资源文件表

    ​ act_ge_property：主键生成策略表

  • ProcessDefinition流程定义

    1、解析bpmn后得到的流程定义规则的信息，工作流系统就是按照流程定义的规则执行的。

  • 关于修改

    修改其它就是重新部署

    重新部署之后老版本的还没执行完成的流程还是按老版本的支持

    新的流程启动就使用新的版本去启动

流程实例、任务的执行

启动流程

    /**
     * 启动流程
     */
    @Test
    public void startProcess(){
        RuntimeService runtimeService = this.processEngine.getRuntimeService();
        //根据流程定义的KEY去启用流程
        String processDefinitionKey = "";
        runtimeService.startProcessInstanceByKey(processDefinitionKey);
        //根据流程定义的KEY去启用流程，并设置流程变量 variables必须是Map<String,Object>的对象
        Map<String,Object> variables = new HashMap<>();
        variables.put("请假天数",5);
        variables.put("请假时间",new Date());
        variables.put("请假原因","回家");
        runtimeService.startProcessInstanceByKey(processDefinitionKey,variables);
        //根据流程定义的key去启用流程，并设置业务ID和流程变量 act_hi_procinst 里面的bussinessKey会有数据
        //请假单
        String businessKey = "LeaveBill:1001";
        runtimeService.startProcessInstanceByKey(processDefinitionKey,businessKey);
        //根据流程定义的KEY去启用流程，并设置业务ID和流程变量act_hi_procinst 里面的bussinessKey会有数据
        runtimeService.startProcessInstanceByKey(processDefinitionKey,businessKey,variables);
        System.out.println("启动成功");
    }

查询个人任务

/**
     * 查询个人任务
     */
    @Test
    public void findUserTask(){
        //任务办理人
        String assignee = "张三";
        //得到任务的Service
        TaskService taskService = this.processEngine.getTaskService();
        //创建一个查询
        //Task task = taskService.createTaskQuery().taskId("").singleResult();
        List<Task> list = taskService.createTaskQuery()
                //where
                .taskAssignee(assignee)//根据任务办理人查询
                //.deploymentId()//根据部署ID去查询
                //.deploymentIdIn()//根据部署ID的Set集合查询
                //.executionId()//根据流程实例ID查询
                //.processDefinitionId()//根据流程定义ID act_re_procdef id
                //.processDefinitionKey()//根据流程定义的Key去查询act_re_procdef key
                //.processDefinitionName()//根据流程定义的名称去查询 act_re_procdef name
                //.processInstanceBusinessKey()//根据流程实例的业务查询
                //.processInstanceId()//根据流程实例ID查询 act_ru_task PROC_INST_ID
                //.processVariableValueEqualsIgnoreCase("请假天数",5)//根据变量查询
                //排序
                //.orderByTaskCreateTime().asc()//根据任务创建时间升序
                //结果集
                //.count()//查询条数
                //.singleResult()//返回单个结果集
                //.listPage(firstResult,maxResults)//分页使用
                .list();//返回集合

        if(list != null && list.size() > 0){
            for(Task task : list){
                System.out.println("任务ID：" + task.getId());
                System.out.println("任务办理人：" + task.getAssignee());
                System.out.println("流程执行实例ID：" + task.getExecutionId());
                System.out.println("任务名称：" + task.getName());
                System.out.println("流程定义ID：" + task.getProcessDefinitionId());
                System.out.println("流程实例ID：" + task.getProcessInstanceId());
                System.out.println("任务创建时间：" + task.getCreateTime());
            }
        }
    }

办理任务

    /**
     * 办理任务
     */
    @Test
    public void completeTask(){
        TaskService taskService = this.processEngine.getTaskService();
        String taskId = "";
        taskService.complete(taskId);//完成任务
        Map<String,Object> variables = new HashMap<>();
        taskService.complete(taskId,variables);//完成任务并设置流程变量
        System.out.println("任务完成");
    }

判断流程是否完成

    /**
     * 如何判断流程是否完成
     */
    @Test
    public void isProcessComplete(){
        //已经结束的流程实例ID
        String processInstanceId = "";
        RuntimeService runtimeService = this.processEngine.getRuntimeService();
        ProcessInstance processInstance = (ProcessInstance) runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId);
        if(processInstance == null){
            System.out.println("流程已结束");
        }else{
            System.out.println("流程未结束");
        }
    }

说明：

  • 因为是任务查询，所以从processEngine中应该得到TaskService
  • 使用TaskService获取到任务查询对象TaskQuery
  • 为查询对象添加查询过滤条件，使用taskAssignee指定任务的办理者(即查询指定用户的代办任务)，同时可以添加分页排序等过滤条件
  • 调用list方法执行查询，返回办理者为指定用户的任务列表
  • 任务ID，名称，办理人，创建时间可以从act_ru_task表中查到
  • Execution与ProcessInstance在前面的情况中，ProcessInstance相当Execution
  • 如果assignee属性为部门经理，结果为空，因为现在流程只到了填写请假申请阶段，后面的任务还没有执行，即在数据库中没有部门经理可以办理的任务，所以查询不到
  • 一个Task节点和Execution节点是1对1的情况，在task对象中使用Execution来表示他们之间的关系
  • 任务ID在数据库表act_ru_task中对应ID列

在流程执行的过程中，创建的流程实例ID在整个过程中都不会变，当流程结束后，流程实例将会在正在执行的执行对象表中(act_ru_execution)被删除

说明：

  • 因为是查询流程实例，所以先获取RuntimeService
  • 创建流程实例查询对象，设置实例ID过滤参数
  • 由于一个流程实例ID只对应一个实例，使用singleResult执行查询返回一个唯一的结果，如果结果数量大有1，则抛出异常
  • 判断指定ID的实例是否存在，如果结果为空，则代表流程结束，实例在正在执行的执行对象表中已被删除，转换为历史数据。

查询历史任务

    /**
     * 附加功能，查询历史任务
     */
    @Test
    public void finfHistoryTask(){
        HistoryService historyService = this.processEngine.getHistoryService();
        String taskId = "";
        HistoricTaskInstance task = historyService.createHistoricTaskInstanceQuery()
                //.taskAssignee()
                .taskId(taskId).singleResult();
        System.out.println("任务ID：" + task.getId());
        System.out.println("任务办理人：" + task.getAssignee());
        System.out.println("流程执行实例ID：" + task.getExecutionId());
        System.out.println("任务名称：" + task.getName());
        System.out.println("流程定义ID：" + task.getProcessDefinitionId());
        System.out.println("流程实例ID：" + task.getProcessInstanceId());
        System.out.println("任务创建时间：" + task.getCreateTime());
    }

查询历史流程实例

    /**
     * 附加功能，查询历史流程实例
     */
    @Test
    public void findHistoryProcessInstance(){
        HistoryService historyService = this.processEngine.getHistoryService();
        String processInstanceId = "";
        HistoricProcessInstanceQuery historicProcessInstanceQuery = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId);
        System.out.println(historicProcessInstanceQuery);
    }

总结：

Execution执行对象

按流程定义的规则执行一次的过程

对应的表：

​ act_ru_execution：正在执行的信息

​ act_hi_procinst：已经执行完的历史流程实例信息

​ act_hi_actionst：存放历史所有完成的活动

ProcessInstance流程实例

特指流程从开始到结束的那个最大的执行分支，一个执行的流程中，流程实例只有1个

注意：

​ 1、如果是单例流程，执行对象ID就是流程实例ID

​ 2、如果一个流程有分支和聚合，那么执行对象ID和流程实例ID就不相同

​ 3、一个流程中，流程实例只有1个，执行对象可以存在多个

Task任务

执行到某任务环节时生成的任务信息

对应的表：

​ act_ru_task：正在执行的任务信息

​ act_hi_taskinst：已经执行完成的历史任务信息

设置和获取流程变量

部署流程

@Test
    public void deployProcess(){
        //得到RepositoryService
        RepositoryService service = processEngine.getRepositoryService();
        //部署
        InputStream isBpmn = this.getClass().getResourceAsStream("/LeaveBill.xml");
        InputStream isPng = this.getClass().getResourceAsStream("/LeaveBill.png");
        Deployment deployment = service.createDeployment().name("请假流程001")//部署的名称
                .addInputStream("LeaveBill.bpmn", isBpmn)//设置；流程图的xml文件
                .addInputStream("LeaveBill.png", isPng)//设置流程图的PNG文件
                .deploy();//确定
        /**
         * act_re_deployment：流程部署表
         * act_re_model：
         * act_re_procdef：流程定义表，它和部署表里面的数据是一一对应的
         * act_ge_bytearray：二进制文件存放表，和部署表和定义表是2-1关系
         * act_ge_property：系统内置表存放activiti的版本和自动增长的字段
         */

        System.out.println("流程部署成功：");
        System.out.println("部署ID：" + deployment.getId());
        System.out.println("部署名称：" + deployment.getName());
        System.out.println("部署时间：" + deployment.getDeploymentTime().toLocaleString());
    }

启动流程

@Test
    public void startProcess(){
        RuntimeService runtimeService = this.processEngine.getRuntimeService();
        //根据流程定义的KEY去启用流程
        String processDefinitionKey = "";
        runtimeService.startProcessInstanceByKey(processDefinitionKey);
        //根据流程定义的KEY去启用流程，并设置流程变量 variables必须是Map<String,Object>的对象
        Map<String,Object> variables = new HashMap<>();
        variables.put("请假天数",5);
        variables.put("请假时间",new Date());
        variables.put("请假原因","回家");
        runtimeService.startProcessInstanceByKey(processDefinitionKey,variables);
        //根据流程定义的key去启用流程，并设置业务ID和流程变量 act_hi_procinst 里面的bussinessKey会有数据
        //请假单
        String businessKey = "LeaveBill:1001";
        runtimeService.startProcessInstanceByKey(processDefinitionKey,businessKey);
        //根据流程定义的KEY去启用流程，并设置业务ID和流程变量act_hi_procinst 里面的bussinessKey会有数据
        runtimeService.startProcessInstanceByKey(processDefinitionKey,businessKey,variables);
        System.out.println("启动成功");
    }

设置流程变量

@Test
    public void setVariables(){
        //1、启动流程时设置
        RuntimeService runtimeService = this.processEngine.getRuntimeService();
        String processDefinitionKey = "";
        Map<String,Object> variables = new HashMap<>();
        variables.put("请假天数",5);
        variables.put("请假时间",new Date());
        variables.put("请假原因","回家");
        runtimeService.startProcessInstanceByKey(processDefinitionKey,variables);


        //2、使用执行实例id去设置
        String executionid = "";
        runtimeService.setVariable(executionid,"测试1","测试1");
        Map<String,Object> variable = new HashMap<>();
        variable.put("请假天数",5);
        variable.put("请假时间",new Date());
        variable.put("请假原因","回家");
        runtimeService.setVariables(executionid,variable);
        runtimeService.setVariable(executionid,"测试2","测试2");
        runtimeService.setVariable(executionid,"测试3",10.001);
        runtimeService.setVariable(executionid,"person",new Person(1,"小明"));



        //3、完成任务的时候去设置
        TaskService taskService = this.processEngine.getTaskService();
        String taskId = "";
        Map<String,Object> map = new HashMap<>();
        map.put("测试2","测试3");;
        taskService.complete(taskId,map);

    }

perosn类

实现序列化和序列化id的统一

public class Person implements Serializable {

    private static final long serialVersionUID = 1L;

    private int id;
    private String name;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

获取流程变量

 /**
     * 获取流程变量
     */
    @Test
    public void getVariables(){
        //1、使用执行实例ID和流程变量的NAME去获取
        RuntimeService runtimeService = this.processEngine.getRuntimeService();
        String executionid = "";
        Object day = runtimeService.getVariable(executionid, "请假天数");
        Object time = runtimeService.getVariable(executionid, "请假时间");
        Object content = runtimeService.getVariable(executionid, "请假原因");
        System.out.println(day);
        System.out.println(time);
        System.out.println(content);

        //2、使用任务ID去得到流程变量
        TaskService taskService = this.processEngine.getTaskService();
        String taskId = "";
        Object days = taskService.getVariable(taskId, "请假天数");
        Person person = (Person) taskService.getVariable(taskId, "person");
        System.out.println(days);
        System.out.println(person);
    }

查询历史流程变量

 /**
     * 查询历史流程变量
     */
    @Test
    public void findHistoryVariables(){
        HistoryService historyService = this.processEngine.getHistoryService();
        String executionId = "";
        List<HistoricVariableInstance> list = historyService.createHistoricVariableInstanceQuery().executionId(executionId).list();
        for (HistoricVariableInstance hvi : list){
            System.out.println("历史变量类型名称：" + hvi.getVariableTypeName());
            /**
             * 历史任务id为空，因为变量可以在流程的任意时刻都可以获取
             * 所以历史任务id无意义
             */
            System.out.println("历史任务ID：" + hvi.getTaskId());
            System.out.println("历史实例ID：" + hvi.getProcessInstanceId());
            System.out.println("历史变量名称：" + hvi.getVariableName());
            System.out.println("历史变量创建时间：" + hvi.getCreateTime());
            System.out.println("历史变量的值：" + hvi.getValue());
        }
    }
流程执行历史记录

查询历史流程实例

    /**
     * 查询历史流程实例
     */
    @Test
    public void findHistoryProcessInstance(){
        List<HistoricProcessInstance> list = historyService.createHistoricProcessInstanceQuery().list();
        for (HistoricProcessInstance hpi : list){
            System.out.println("部署ID：" + hpi.getDeploymentId());
            System.out.println("名称：" + hpi.getName());
            System.out.println("流程定义KEY：" + hpi.getProcessDefinitionKey());
            System.out.println("流程定义名称：" + hpi.getProcessDefinitionName());
            System.out.println("开始时间" + hpi.getStartTime());
            System.out.println("结束时间：" + hpi.getEndTime());
        }
    }

查询历史活动

/**
     * 查询历史活动
     */
    @Test
    public void findHistoryActivit(){
        List<HistoricActivityInstance> list = historyService.createHistoricActivityInstanceQuery().list();
        for(HistoricActivityInstance hai : list){
            System.out.println("活动ID：" + hai.getActivityId());
            System.out.println("活动名称：" + hai.getActivityName());
            System.out.println("活动类型：" + hai.getActivityType());
            System.out.println("办理人：" + hai.getAssignee());
            System.out.println("执行实例ID：" + hai.getExecutionId());
            System.out.println("定义ID：" + hai.getProcessDefinitionId());
            System.out.println("流程实例ID：" + hai.getProcessInstanceId());
            System.out.println("任务ID：" + hai.getTaskId());
            System.out.println("持续时间：" + hai.getDurationInMillis());
            System.out.println("开始时间：" + hai.getStartTime());
            System.out.println("结束时间：" + hai.getEndTime());
        }
    }

查询历史任务

/**
     * 查询历史任务
     */
    @Test
    public void findHistoryTask(){
        List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery().list();
        for(HistoricTaskInstance hti : list){
            System.out.println("办理人：" + hti.getAssignee());
            System.out.println("执行实例iD：" + hti.getExecutionId());
            System.out.println("任务名称：" + hti.getName());
            System.out.println("定义ID：" + hti.getProcessDefinitionId());
            System.out.println("流程实例ID：" + hti.getProcessInstanceId());
            System.out.println("活动KEY：" + hti.getTaskDefinitionKey());//就是活动节点
        }
    }

总结：

流程变量

在流程执行或者任务执行的过程中，用于设置和获取变量，使用；流程变量在流程传递的过程中传递业务参数

对应的表：

​ act_ru_variable：正在执行的流程变量表

​ act_hi_varinst：流程变量历史表

扩展知识：setVariable和setVariableLocal的区别

setVariable：设置流程变量的时候，流程变量名称相同的时候，后一次的值替换前一次的值，而且可以看到
TASK_ID的字段不会存放任务ID的值

serVariableLocal：

​ 1、设置流程变量的时候，针对当前活动的节点设置流程变量，如果一个流程中存在2个活动节点，对每个活动节点都设置流程变量，即使流程变量的名称相同，后一次的版本的值也不会替换前一次版本的值，她会使用不同的任务ID作为标识，存放2个流程变量值，而且可以看到TASK_ID的字段会存放ID的值，例如act_hi_varinst表的数据：不同的任务节点，即使流程变量名称相同，存放的值也是不同的。

​ 2、还有，使用setVariableLocal说明流程变量绑定了当前的任务，当流程继续执行时，下个任务获取不到这个流程变量(因为正在执行的流程变量中没有这个数据)，所有查询正在执行的任务时不能查询到我们需要的数据，此时需要查询历史的流程变量。

2021-10-19 Flowable笔记
鲸鱼姐的专栏
10-19 1093
一. Flowable API 我们开发Flowable涉及到了一些Flowable的API，在开发的时候经常需要与这些API打交道。 入口点为：ProcessEngine，我们有多种方式来创建它。 通过ProcessEngine，我们可以获取工作流的不同服务类型，ProcessEngine和服务都是线程安全的，因此我们可以用作单例对象来使用这些服务。 // 第一次会初始化和创建一个ProcessEngine，后续调用都会从缓存中直接返回，全局创建一次 // ProcessEngines.in
activiti工作流07-processDefinition的CRUD
haiminhuang的博客
09-13 8533
package com.hhm.activitiDemo.test02; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.util.List; import java.util.zip.ZipInputStream; import org.activ
【六】流程执行历史记录
weixin_41449756的博客
06-08 760
一、查询历史流程实例 二、查询历史活动 三、查询历史任务 act_hi_taskinst 一、查询历史流程实例 /* 1，查询历史流程实例 */ @Test public void historyProcessInstince() { List<HistoricProcessInstance> list = historyService.createHistoricProcessInstanceQuery() //条件 // .processDefinitionId(
flowable中的流程变量
埃泽漫笔
06-03 533
流程实例按步骤执行时，需要使用一些数据。在Flowable中，这些数据称作变量(variable)，并会存储在数据库中。变量可以用在表达式中（例如在排他网关中用于选择正确的出口路径），也可以在Java服务任务(service task)中用于调用外部服务（例如为服务调用提供输入或结果存储），等等。流程实例可以持有变量（称作流程变量 process variables用户任务以及执行(executions)——流程当前活动节点的指针——也可以持有变量。
工作流程flowable(一）各节点和网关线条。网关不生效
nalanxiaoxiao2011的博客
08-31 1679
工作流程 flowable
flowable 五个引擎和组成引擎的服务
王洪伟的专栏
07-31 1万+
一、flowable的五个引擎flowable包含五个引擎，分别是： 1、内容引擎 ContentEngine 2、身份识别引擎 IdmEngine 3、表单引擎 FormEngine 4、决策引擎 DmnEngine 5、流程引擎 ProcessEngine 二、引擎包含的服务每个引擎由相对应的 EngineConfiguration进行创建，在创建过程中对每个引擎使用的服务进行初始化。1、内容引
Activiti学习笔记三：管理流程定义
09-03
在“Activiti学习笔记三：管理流程定义”中，我们将深入探讨如何使用Activiti来管理和操作流程定义。 首先，流程定义是Activiti中的核心概念，它是流程模型的静态表示，描述了工作流的结构和规则。流程定义通常以...
Activiti学习笔记
04-25
Activiti学习笔记，介绍Activiti的组成结构，工作流BPMN2.0规范等
《Activiti学习笔记：深入解析排他网关ExclusiveGateWay》
最新发布
07-17
通过这些示例，你可以学习如何在实际项目中应用排他网关。 排他网关的应用场景非常广泛。例如，在订单处理流程中，可以根据订单的状态（如库存情况、付款状态等）决定是进行发货还是退款。通过排他网关，可以清晰地...
Activiti 学习笔记六：流程执行历史记录
09-06
本学习笔记将聚焦于流程执行的历史记录，这是理解流程运行情况、追踪问题以及优化流程的关键。 一、Activiti 的历史记录功能 历史记录是 Activiti 中的一个重要特性，它允许开发者和管理员查看已经执行过的流程实例...
Activiti 学习笔记14：工作流定义的角色组
09-14
在本篇Activiti学习笔记中，我们将深入探讨工作流定义中的关键概念——角色组，以及它们在Activiti流程引擎中的应用。Activiti是一款强大的、开源的企业级工作流和业务自动化引擎，广泛应用于业务流程管理（BPM）...
activiti 流程定义 ProcessDefinition
mchgogo的博客
01-19 9120
由于这两天没项目、学习 activiti 工作流 、根据demo 写、记录一下....................../** * 部署流程定义（从classpath） */ @Test public void processDefinition_classpath(){ Deployment deployment=processEngine.getRepositoryService()
再读flowable
远行的博客
08-12 602
命令模式+责任链模式
flowable入门教程
热门推荐
u010957271的博客
01-31 1万+
1.1. 先决条件 Prerequisites 这个教程假设你已经运行了Flowable演示配置，并使用独立的H2服务器。编辑db.properties并设置jdbc.url=jdbc:h2:tcp://localhost/flowable，然后按照H2文档的介绍运行独立服务器。 1.2. 目标 Goal 这个教程的目标是学习Flowable以及BPMN 2.0的一些基础
2、Activiti 流程定义操作 ProcessDefinition
zhaoshe的专栏
04-25 7814
public class ProcessDefinitionTest { ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine(); /** * 部署流程定义 * */ @Test public void deployProcessDefintion_classPath() { Dep
Activiti5 学习笔记（七）—— 与业务关联
q42368773的博客
01-27 1941
activiti流程引擎单独跑应用是没有任何意义的。最终我们要操作的业务数据。现在我们来演示一个请假流程，如何与业务数据进行绑定开发。 1、创建业务数据，请假单，数据表：leave_bill 2、创建流程图 3、部署流程定义，省略代码 4、启动流程实例 //do 我要请假 @RequestMapping("leave") public String leave(){ ...
activiti6超详细教程
萌新比克o的博客
12-16 8241
1.activiti6表说明 ACT_RE_ *：RE代表repository。具有此前缀的表包含静态信息，例如流程定义和流程资源（图像，规则等）。 ​ ACT_RU_ *：RU代表runtime。这些是运行时表，其中包含流程实例，用户任务，变量，作业等的运行时数据。Activiti仅在流程实例执行期间存储运行时数据，并在流程实例结束时删除记录。这样可以使运行时表较小而又快速。 ​ ACT_I...
flowable工作流进阶（二）
吕小小布的博客
11-01 1万+
Flowable spring boot 进阶（二） 数据库表介绍 Flowable的数据库名称都以ACT_开头。第二部分是表的用例的双字符标识。此用例也将大致匹配服务API。 ACT_RE_ *：RE代表repository。具有此前缀的表包含静态信息，例如流程定义和流程资源（图像，规则等）。 ACT_RU_ *：RU代表runtime。这些是包含流程实例，用户任务，变量，作业等的运行时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值