activiti全部知识点

Posted huqi96

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了activiti全部知识点相关的知识，希望对你有一定的参考价值。

1.activiti中的25张表

  1. 部署流程相关表 
    SELECT * FROM act_re_deployment #部署对象表

select* from act_re_procdef  #流程定义表

select * from act_ge_bytearray #资源文件表

select * from act_ge_property #主键生成策略表
  2. 流程实例，执行对象，任务相关表 
    ######流程实例，执行对象，任务#######
select * from act_ru_execution #正在执行的执行对象表

select * from act_hi_procinst #流程实例的历史表

select * from act_ru_task #正在执行的任务表（只有节点是UserTask的时候，该表中存在数据）

select * from act_hi_taskinst #任务历史表

select * from act_hi_actinst  #所有活动节点的历史表

    3.分组任务表

    SELECT * FROM `act_ru_identitylink` #正在执行的组任务

select * from act_hi_identitylink  #所有历史组任务

    部署和启动流程实例

        /**
       * 排它网关与连线方式对比的优势是排它网关可以设置默认的条件
     * */
    
    /**
       * 并行网关在聚合处只有当分支任务都完成后才会进行下个任务
     * */
    private ProcessEngine pes=ProcessEngines.getDefaultProcessEngine();
    
    /**
     * 部署流程定义
     * 部署完流程后在数据库ACT_RE_DEPLOYMENT中会产生条数据id和name
     * 在ACT_RE_PROCDEF会生成一条流程图详细数据
     * 在ACT_GE_BYTEARRAY中存储bpmn和png流程文件
     * */
    @Test
    public void deploymentProessDefintion() {
    Deployment dep=    pes.getRepositoryService()//与流程定义和部署相关的service
            .createDeployment()//创建部署对象
            .name("qiqi")//添加部署名称
            .addClasspathResource("bpmn/factorDataEntry.bpmn")//从classpath资源中加载，一次只能加载一个文件
            .addClasspathResource("bpmn/factorDataEntry.png")//从classpath资源中加载，一次只能加载一个文件
            .deploy();//完成部署
    System.out.println("获取流程id"+dep.getId());
    System.out.println("获取部署名称："+dep.getName());
    }

    组任务分配方式

    1.在配置文件中进行设置
在Main config中candidata user进行设置:小王,小五,小红（中间用逗号隔开）
2.使用流程变量的方式进行设置
（1）.在配置文件中Main config中的canditidata user设置路程变量赋值：#{groupuser}或者${groupuser}

（2）.    使用流程变量进行传递参数
@Test
    public void startGorupTask() {
         Map<String, Object> map = new HashMap<String, Object>();
           map.put("users", "小王,小张,小五");//指定走那条线
           
        ProcessInstance    pi=pes.getRuntimeService()//获取正在执行的流程实例和执行对象相关的service
            .startProcessInstanceByKey("eidataresult",map);//使用指定的key启动流程实例
        System.out.println("流程实例ID"+pi.getId());//流程实例的id
        System.out.println("流程定义ID"+pi.getProcessDefinitionId());//流程定义id
    }
3.向组任务添加成员
/**
     * 向组任务中添加成员
     * */
    @Test
    public void addGroupUser() {
        pes.getTaskService()
        .addCandidateUser("50006","小红");
    }

    个人任务指定办理人

    1.在main config中Assignee设置流程变量：${msg==‘huqi‘}或者#{msg==‘qiqi‘}
2.在任务启动或者任务完成时指定办理人
    @Test
    public void completeMypersonalTask2() {
        String taskId="40007";
        
        TaskService  task= pes.getTaskService();//与正在执行的任务相关的service
        
        task.setAssignee(taskId, "任务办理人");
        task.complete(taskId);//让流程往指定路线走
        System.out.println("完成任务ID："+taskId);
    }

    连线中的条件设置

    在属性文件中Main config中condition设置，在任务完成后可以设置流程变量来指定行走路线

condition流程变量设计实例：${msg}或者#{!msg}

    排它网关设置默认线路

    bpmn文件中Genaeral中Default flow中可以选择默认走的线路，当所有条件都不符合时会走默认线路

    activiti所有常用知识汇总

    package org.huqi.text;

import java.io.File;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipInputStream;

import org.activiti.engine.HistoryService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.TaskService;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.history.HistoricIdentityLink;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.history.HistoricVariableInstance;
import org.activiti.engine.history.HistoricVariableInstanceQuery;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.runtime.Execution;
import org.activiti.engine.runtime.ExecutionQuery;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.runtime.ProcessInstanceQuery;
import org.activiti.engine.task.IdentityLink;
import org.activiti.engine.task.Task;

import org.junit.jupiter.api.Test;
import org.springframework.stereotype.Service;
@Service
public class Demo {
    /**
       * 排它网关与连线方式对比的优势是排它网关可以设置默认的条件
     * */
    
    /**
       * 并行网关在聚合处只有当分支任务都完成后才会进行下个任务
     * */
    private ProcessEngine pes=ProcessEngines.getDefaultProcessEngine();
    
    /**
     * 部署流程定义
     * 部署完流程后在数据库ACT_RE_DEPLOYMENT中会产生条数据id和name
     * 在ACT_RE_PROCDEF会生成一条流程图详细数据
     * 在ACT_GE_BYTEARRAY中存储bpmn和png流程文件
     * */
    @Test
    public void deploymentProessDefintion() {
    Deployment dep=    pes.getRepositoryService()//与流程定义和部署相关的service
            .createDeployment()//创建部署对象
            .name("qiqi")//添加部署名称
            .addClasspathResource("bpmn/factorDataEntry.bpmn")//从classpath资源中加载，一次只能加载一个文件
            .addClasspathResource("bpmn/factorDataEntry.png")//从classpath资源中加载，一次只能加载一个文件
            .deploy();//完成部署
    System.out.println("获取流程id"+dep.getId());
    System.out.println("获取部署名称："+dep.getName());
    }
    /**
     * 启动流程实例
     * 启动流程实例后在ACT_RU_EXECUTION会产生指定key的流程记录
     * */
    @Test
    public void startProcessInstance() {
    ProcessInstance    pi=pes.getRuntimeService()//获取正在执行的流程实例和执行对象相关的service
        .startProcessInstanceByKey("eidataresult");//使用指定的key启动流程实例
        System.out.println("流程实例ID"+pi.getId());//流程实例的id
        System.out.println("流程定义ID"+pi.getProcessDefinitionId());//流程定义id
    }

    /**
     * 查询当前人的个人任务
     * */
    @Test
    public void findMyPersonalTask() {
        List<Task> list=pes.getTaskService()//获取与执行任务相关的service
        .createTaskQuery()//创建任务查询对象
        .taskAssignee("小王")//指定个人任务查询，指定办理人:第一个节点的办理人
        .list();
        for(Task ts:list) {
            System.out.println("任务ID"+ts.getId());
            System.out.println("任务任务名称"+ts.getName());
            System.out.println("任务的创建时间"+ts.getCreateTime());
            System.out.println("任务的办理人"+ts.getAssignee());
            System.out.println("流程实例ID"+ts.getProcessInstanceId());
            System.out.println("执行对对象ID"+ts.getExecutionId());
            System.out.println("流程定义ID"+ts.getProcessDefinitionId());
        }
    }
    /**
     * 完成指定任务ID的任务，完成后进入下一个待办节点
     * */
    @Test
    public void completeMypersonalTask() {
        String taskId="7503";
        Map<String,Object> variables =new HashMap<String,Object>();
        variables.put("msg", "失败");
        TaskService  task= pes.getTaskService();//与正在执行的任务相关的service
        //task.setVariables(taskId, variables);
        task.complete(taskId,variables);//提交流程时设置流程变量，让流程往指定路线走，流程变量设置示例：${msg==‘重要‘}
        System.out.println("完成任务ID："+taskId);
    }
    
    /**
     * 部署流程定义（从zip）
     * 
     * */
    @Test
    public void deploymentProcessDfinition_zip() {
        InputStream zipInputStream =this.getClass().getClassLoader().getResourceAsStream("bpmn/factorDataEntry.zip");
        ZipInputStream in=new ZipInputStream(zipInputStream);
        Deployment de=pes.getRepositoryService()//获取流程定义和部署对象相关的service
        .createDeployment()//创建一个部署对象
        .name("qiiqiqi")//添加部署名称
        .addZipInputStream(in)//指定zip资源文件输入流
        .deploy();//完成部署
        System.out.println("部署ID："+de.getId());
        System.out.println("部署名称："+de.getName());
    }
    /**查询流程定义*/
    @Test
    public void findProcessDefinition() {
        List<ProcessDefinition> list=pes.getRepositoryService()//获取与流程 定义和部署对象相同的service
        .createProcessDefinitionQuery()//创建一个流程定义的查询
        /**指定查询条件，where条件*/
        //.deploymentId(deploymentId);//流程部署对象id
        //.processDefinitionId(processDefinitionId)//使用流程定义id进行查询
        //.processDefinitionKey(processDefinitionKey)//使用流程定义的key进行查询
        //.processDefinitionNameLike(processDefinitionNameLike);//使用流程定义的名称进行模糊查询
        /**排序*/
        .orderByProcessDefinitionVersion().asc()//按照版本的升序排序
        .orderByProcessDefinitionName().desc()//按照流程定义的名称降序排序
        /**返回的结果集*/
        .list();
        for(ProcessDefinition pd:list) {
            System.out.println("流程定义ID:"+pd.getId());
            System.out.println("流程定义的名称:"+pd.getName());
            System.out.println("获取流程定义的key"+pd.getKey());
            System.out.println("获取流程定义的版本"+pd.getVersion());
            System.out.println("获取流程bpmn资源文件："+pd.getResourceName());
            System.out.println("资源文件png:"+pd.getDiagramResourceName());
            System.out.println("部署对象ID："+pd.getDeploymentId());
        }
    }
    /**删除流程*/
    @Test
    public void deleteProcessDefinition(){
        String deploymentId="2501";//流程定义id
        pes.getRepositoryService()
        /**不带级联的删除
          *只能删除没有启动的流程 ，已经启动的流程不能删除就会抛出异常 
         * */
        //.deleteDeployment(deploymentId);
        /**级联删除
           * 不管流程是否启动都能删除
         * */
        .deleteDeployment(deploymentId, true);
    }
    /**
       * 查看流程图片
     * */
    @Test
    public void viewPic() {
        String deploymentId="801";//流程定义id
        //获取图片资源名称
        List<String> list=pes.getRepositoryService()
        .getDeploymentResourceNames(deploymentId);
        //定义图片资源的名称
        String resourceName="";
        if(list!=null&&list.size()>0) {
            for(String name:list) {
                if(name.indexOf(".png")>=0) {
                    resourceName=name;
                }
            }
        }
        //获取图片的输入流
        InputStream in=pes.getRepositoryService()
                .getResourceAsStream(deploymentId, resourceName);
        //将图片生成到D盘 的目录下
        File file=new File("d/"+resourceName);
        
        
    }
    /**
     * 查询最新版本的流程定义
     * */
    @Test
    public void findLastVersionProcessDefinition() {
    List<ProcessDefinition> list=pes.getRepositoryService()
        .createProcessDefinitionQuery()//
        .orderByProcessDefinitionVersion().asc()//使用流程定义版本升序排序
        .list();
        Map<String,ProcessDefinition> map=new LinkedHashMap<String, ProcessDefinition>();
        if(list!=null&&list.size()>0) {
            for(ProcessDefinition pd:list) {
                map.put(pd.getKey(), pd);
            }
        }
        List<ProcessDefinition>    pdList=new ArrayList<ProcessDefinition>(map.values());//获取map中的值装入List集合中
        if(pdList!=null&&pdList.size()>0) {
            for(ProcessDefinition pd:pdList) {
                System.out.println("流程定义：ID"+pd.getId());
                System.out.println("流程定义的名称:"+pd.getName());//对应bpmn文件中的name属性
                System.out.println("流程定义的key:"+pd.getKey());//对应bpmn文件中的id属性
                System.out.println("流程定义的版本:"+pd.getVersion());//对应key相同的情况下版本相同的情况下版本升级
                System.out.println("资源文件名称bpmn文件:"+pd.getResourceName());
                System.out.println("资源文件名称png文件:"+pd.getDiagramResourceName());
                System.out.println("部署对象ID:"+pd.getDeploymentId());
                
                }
        }
    }
    /**
     * 删除key不同版本的流程定义
     * */
    @Test
    public void deleteProcessDefinitionByKey() {
        String processDefinitionKey="eidataresult";
        List<ProcessDefinition> list=pes.getRepositoryService()
        .createProcessDefinitionQuery()
        .processDefinitionKey(processDefinitionKey)//使用流程定义的key查询
        .list();
        
        for(ProcessDefinition ls:list) {
            pes.getRepositoryService()
            //获取部署流程id进行删除
            .deleteDeployment(ls.getDeploymentId(), true);
        }
    }
    /**
     * 查看流程状态（判断流程正在执行还是结束）
     * */
    @Test
    public void isProcessEnd() {
        String processInstanceId ="10001";
        ProcessInstance pi=pes.getRuntimeService()
        .createProcessInstanceQuery()//创建流程实例查询
        .processInstanceId(processInstanceId)//使用流程实例ID查询
        .singleResult();
        if(pi==null) {
            System.out.println("流程已结束");
        }else {
            System.out.println("流程没有结束");
        }
    }
    /**
     * 查询历史任务
     * */
    @Test
    public void findHistoryTask() {
        String assignee="huqi";
        List<HistoricTaskInstance> list=pes.getHistoryService()//与历史相关的service
        .createHistoricTaskInstanceQuery()//创建历史任务实例查询
        .taskAssignee(assignee)
        .list();
        if(list!=null&&list.size()>0) {
            for(HistoricTaskInstance hi:list) {
                System.out.println(hi.getName());
                System.out.println(hi.getId());
                System.out.println(hi.getProcessInstanceId());
                System.out.println(hi.getStartTime());
                System.out.println(hi.getEndTime());
            }
        }
    }
    /**
     * 查询历史任务
     * */
    @Test
    public void findHistoryProcessInstance() {
        String processInstanceId="17501";
        HistoricProcessInstance hi=pes.getHistoryService()//与历史数据相关的service
        .createHistoricProcessInstanceQuery()//创建历史流程实例查询
        .processInstanceId(processInstanceId)//使用流程实例ID查询
        .singleResult();
        System.out.println(hi.getProcessDefinitionId());
        System.out.println(hi.getId());
        
        System.out.println(hi.getStartTime());
        System.out.println(hi.getEndTime());
    }
    @Test
    public void setVariable() {
        Map<String,Object> map=new HashMap<String,Object>();
        map.put("name", "qiqi");
        map.put("age", 23);
        pes.getRuntimeService()
        .startProcessInstanceByKey("eidataresult", map);
        
    }
    @Test
    public void getVariable() {
    
        List<HistoricVariableInstance> hi=pes.getHistoryService().createHistoricVariableInstanceQuery().list();
        System.out.println(hi.size());
        for(HistoricVariableInstance h:hi) {
            System.out.println(h.getVariableName());
            System.out.println(h.getValue());
        }
    }
    @Test
    public void getRunTimeProcess() {
        ProcessInstance  p=pes.getRuntimeService()
        .createProcessInstanceQuery()
        .processInstanceId("12501").singleResult();
        System.out.println(p.getProcessDefinitionId());
    }
    /**
     * 服务方式任务，启动流程实例+设置流程变量+获取流程变量+向后执行一步
     * */
    @Test
    public void startProcessReceiveTask() {
        ProcessInstance    pi=pes.getRuntimeService()//获取正在执行的流程实例和执行对象相关的service
                .startProcessInstanceByKey("eidataresult");//使用指定的key启动流程实例
                System.out.println("流程实例ID"+pi.getId());//流程实例的id
                System.out.println("流程定义ID"+pi.getProcessDefinitionId());//流程定义id
                Execution  es=pes.getRuntimeService()
                .createExecutionQuery()
                .activityId("receivetask1")
                .processInstanceId(pi.getId())
                .singleResult();
                
                /**使用流程变量用来传递流程参数*/
        pes.getRuntimeService().setVariable(es.getId(), "当日销售额", 4000);
        
        /**让当前服务向后执行一步，activiti6之前使用的方法*/
        //pes.getRuntimeService().signal(pi.getId());
        /**让当前服务向后执行一步，activiti6之后使用的方法*/
        
        pes.getRuntimeService().trigger(es.getId());//当前任务id

        Execution ex=pes.getRuntimeService()
        .createExecutionQuery()
        .processInstanceId(pi.getId())//使用流程实例id
        .activityId("receivetask2")//当前活动的id，对应bpmn文件中的id属性
        .singleResult();
        /**从流程变量中获取汇总当日销售额*/
        
        Object value=pes.getRuntimeService()
        .getVariable(ex.getId(), "当日销售额");
        System.out.println("获取传递任务的流程变量："+value);
    }
    /**
     * 启动流程实例
     * 指定任务办理人（用流程变量指定方式）${name}
     * */
    @Test
    public void startProcessInstance2() {
         Map<String, Object> map = new HashMap<String, Object>();
           map.put("name", "one");//指定走那条线
           map.put("ass", "huqiqi");//指定办理人
           //map.put("age", "21");

    ProcessInstance    pi=pes.getRuntimeService()//获取正在执行的流程实例和执行对象相关的service
        .startProcessInstanceByKey("eidataresult",map);//使用指定的key启动流程实例
        System.out.println("流程实例ID"+pi.getId());//流程实例的id
        
        System.out.println("流程定义ID"+pi.getProcessDefinitionId());//流程定义id
    }
    
    /**
     * 完成指定任务ID的任务，设置下一个任务的任务办理人，完成后进入下一个待办节点
     * */
    @Test
    public void completeMypersonalTask2() {
        String taskId="40007";
        
        TaskService  task= pes.getTaskService();//与正在执行的任务相关的service
        
        task.setAssignee(taskId, "任务办理人");
        task.complete(taskId);//让流程往指定路线走
        System.out.println("完成任务ID："+taskId);
    }
    /**
     * 启动任务，并分配组任务人
     * */
    @Test
    public void startGorupTask() {
         Map<String, Object> map = new HashMap<String, Object>();
           map.put("users", "小王,小张,小五");//指定走那条线
           
        ProcessInstance    pi=pes.getRuntimeService()//获取正在执行的流程实例和执行对象相关的service
            .startProcessInstanceByKey("eidataresult",map);//使用指定的key启动流程实例
        System.out.println("流程实例ID"+pi.getId());//流程实例的id
        System.out.println("流程定义ID"+pi.getProcessDefinitionId());//流程定义id
    }
    /**
     * 根据任务分组人查询任务
     * */
    @Test
    public void findGorupTask() {
        List<Task> list=pes.getTaskService()
        .createTaskQuery()
        .taskCandidateUser("小红").list();//属于小王的组任务
        for(Task ls:list) {
            System.out.println("获取任务id："+ls.getId());
            System.out.println("获取流程定义id"+ls.getProcessDefinitionId());
        }
    }
    /**
     * 将组任务分配到个人，任务分配到个人后分组人就查不到任务，只有个人才能查询出这个任务
     * */
    @Test
    public void claimTask() {
        pes.getTaskService()
        .claim("50006", "小王");
    }
    /**
     * 查询正在执行的任务办理人,就算是任务分配完成后也可以查询出这个任务的所有参与者
     * */
    @Test
    public void findRunPersonTask() {
        List<IdentityLink> list=pes.getTaskService()
        .getIdentityLinksForTask("50006");
        for(IdentityLink id:list) {
            System.out.println("当前任务id："+id.getTaskId());
            System.out.println("办理人类型："+id.getType());
        }
    }
    /**
     * 查询历史任务办理人
     * */
    @Test
    public void findHistoryPersonTask() {
        List<HistoricIdentityLink> list=pes.getHistoryService()
        .getHistoricIdentityLinksForProcessInstance("50001");
        for(HistoricIdentityLink ls:list) {
            System.out.println("当前任务类型"+ls.getType());
            System.out.println("当前任务id"+ls.getTaskId());
        }
    }
    /**
     * 将个人任务回退到组任务
     * */
    @Test
    public void setAssigee() {
        pes.getTaskService()
        .setAssignee("50006", null);//任务id，办理人设置为空
    }
    /**
     * 向组任务中添加成员
     * */
    @Test
    public void addGroupUser() {
        pes.getTaskService()
        .addCandidateUser("50006","小红");
    }
    /**
     * 删除任务成员
     * */
    @Test
    public void deleteGroupUser() {
        pes.getTaskService()
        .deleteCandidateUser("50006", "小红 ");
    }
}

     

以上是关于activiti全部知识点的主要内容，如果未能解决你的问题，请参考以下文章

如何在 Activity（非 AppCompatActivity）中打开片段？

片段 MyFragment 未附加到 Activity

将字符串数据从Activity发送到片段[关闭]

如何在 ViewPager 中从 Activity 移动到 Fragment？未找到片段 ID 的视图

如何将片段中的 ListView 对象的数据传递给 Activity？

片段 - 您是不是必须在包含整个 Activity 的片段周围使用 Activity Wrapper？