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", "小红 ");
       }
   }