activiti笔记（常见api及使用）

工作流：在多个参与者之间按照某种预定义的规则传递文档 信息 任务的过程自动进行。
演示请假流程管理系统平台：
工作流引擎 processEngine
---定义工作流
---执行和管理工作流

工作流activiti的表是使用来存放流程数据的
而业务的数据都需要用户自己创建和维护的

一定需要业务去关联流程，才能开发工作流系统




使用activiti的api

---

流程定义是不能修改的，
控制修改


#部署对象和流程定义相关的表
select * from act_re_deployment #部署对象表
select * from act_re_procdef #流程定义表
select * from act_ge_bytearray #流程文件表
select * from act_ge_property #主键生成策略表


#流程实例，执行对象，任务
select * from act_ru_execution #正在执行的执行对象表

#id_ === proc_inst_id_
流程实例Id和执行对象ID

select * from act_hi_procinst  #流程实例历史表
select * from act_ru_task;#正在执行的任务表，只有节点中存usertask的时候，该表中有数据
select * from act_hi_taskinst #正在执行的历史任务表
#结论：
1.如果是单例流程（没有分支和聚合），那么流程实例Id和执行对象ID是相同的
2.一个流程中流程实例只有一个，执行对象可以多个（如果存在分支和聚合）


流程变量
1.用来传递业务参数
2.指定连线完成任务（同意和拒绝）
3.动态指定任务的办理人

****************************************************************************
流程变量
在流程执行或者任务执行过程中，用于设置流程变量
select * from act_ru_variable ##正在执行的流程变量表
select * from act_hi_varinst ##历史流程变量表

流程变量支持类型：
基本数据类型，引用数据类型需要序列化并有版本号控制

----------------------------------------------------------------------------
---------------------------------------------------------------------------
---------------------------------------------------------------------------

线条：
线设置：condition --》#{}(或者#{} ){boolean值} ，流程变量进行判断走哪条线

排他网关（exclusiveGaeWay）：

组件--》排他网关的组件--》设置任务完成时的condition-->连线时做判断————》完成排他网关的执行

并行网关（parallelGateWay）:
排他网关没有condition,都是成对出现的

判断活动是否结束

接收活动（receiveTask,即等待活动）：
没有办理人

个人任务：
办理人：assigner-->
1. 直接指定办理人
2. 使用流程变量 ${} #{}--》在bpmn文件中的userTask属性assigner指定办理人${userId}
3. 使用类指定流程的办理人 -->TaskListener-->在bpmn文件中指定任务监听的类的全路径当启动流程实例会自动监听到配置好的方法中

组任务：
由一组人来办理
1. 直接指定办理人-->candidate users(小A,小B,小C,小D)多个人用逗号隔开
2. 使用流程变量 ${} #{}--》在bpmn文件中的userTask属性assigner指定办理人${userId}
3. 使用类指定流程的办理人 -->TaskListener-->在bpmn文件中指定任务监听的类的全路径当启动流程实例会自动监听到配置好的方法中

select *from act_ru_identitylink #任务表 包括个人任务也包括组任务
select *from act_hi_identitylink #历史任务办理人表 个任务和组任务

工作流定义的用户组（了解）

demo

package com.demo.activiti;

import com.demo.activiti.entity.Person;
import org.activiti.engine.*;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.history.HistoricVariableInstance;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.apache.commons.io.FileUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;

@SpringBootTest//(classes = ActivitiApplicationTests.class, webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
@RunWith(SpringJUnit4ClassRunner.class)
public class ActivitiApplicationTests {
    private Logger logger = LoggerFactory.getLogger(ActivitiApplicationTests.class);

    /**
     * 默认方式获取  流程引擎对象
     */
    @Autowired
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

    /**
     * 使用代码创建工作流程需要的23张表
     * 

     * public static final String DB_SCHEMA_UPDATE_FALSE = "false"; 不能自动创建表 需要表存在
     * public static final String DB_SCHEMA_UPDATE_CREATE_DROP = "create-drop"; 先删除 再创建
     * public static final String DB_SCHEMA_UPDATE_TRUE = "true"; 如果表不存在 自动创建表
     */
    @Test
    public void createTable() {
        ProcessEngineConfiguration config = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
        config.setJdbcDriver("com.mysql.cj.jdbc.Driver");
        config.setJdbcUrl("jdbc:mysql://localhost:3306/activiti?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8");
        config.setJdbcUsername("root");
        config.setJdbcPassword("root");
        config.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_FALSE);
        //工作流的核心对象 processEngine对象
        ProcessEngine processEngine = config.buildProcessEngine();
        logger.info("processEngine:" + processEngine);
    }

    /**
     * 通过配置文件activiti.cfg.xml 获取流程引擎对象
     */
    @Test
    public void createtable_2() {
        ProcessEngine processEngine = ProcessEngineConfiguration
                .createProcessEngineConfigurationFromResource("activiti.cfg.xml")
                .buildProcessEngine();
        logger.info("processEngin:" + processEngine);
    }

    @Test
    public void contextLoads() {
        //通过获取载入默认获取
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        logger.info(processEngine.toString());
        processEngine.close();

    }

    /**
     * 部署流程定义
     */
    @Test
    public void deployment() {
        //与流程定义和流程部署相关的service
        Deployment deploy = processEngine.getRepositoryService()
                .createDeployment() //创建一个部署对象
                .name("审批流") //添加部署的名称
                .addClasspathResource("workflow/testActiviti.bpmn")//从classpath加载资源文件 一次只能加载一个文件
                .addClasspathResource("workflow/testActiviti.png")
                .deploy();//完成部署
        logger.info("id:" + deploy.getId());//1
        logger.info("id:" + deploy.getName());//对应的表act_re_procdef（） act_re_deployment（部署表） act_ge_bytearray （二进制表） act_ge_property（版本号控制的）
    }

    /**
     * 启动流程实例
     */
    @Test
    public void startProcessInstance() {
        //流程顶定义的key
        String processDefinitionKey = "myProcess";
        //返回流程实例对象
        ProcessInstance processInstance = processEngine.getRuntimeService() //正在执行的流程实例和执行对象相关的对象--执行管理 ，包括启动 推进 删除流程实例等操作
                .startProcessInstanceByKey(processDefinitionKey);//使用流程定义的key 启动实例，key 为bpmn 文件id 的属性值myProcess  或者 流程定义表：act_re_procdef 表中的key
        //默认使用的最新版本的流程定义启动
        logger.info("流程实例id:"+processInstance.getId());//流程实例id:2501
        logger.info("流程定义id:"+processInstance.getProcessDefinitionId());//流程定义id:myProcess:1:4
        //act_ru_execution  act_ru_task  act_ru_identitylink  act_ru_execution  act_hi_taskinst  act_hi_procinst  act_hi_identitylink act_hi_actinst
    }

    /**
     * 查询当前人的个人任务
     */
    @Test
    public void findMyPersonProcessTask(){
        String assignee = "李四";//张三 李四
        //任务管理
        List list = processEngine.getTaskService() //与任务相关的service
                .createTaskQuery()
                .taskAssignee(assignee) //指定个人任务查询 指定办理人  act_ru_task
                .list();
        if(list!= null && list.size()>0){
            for(Task task:list){
                logger.info("任务id:"+task.getId());//任务id:2505  任务id:5002
                logger.info("任务名称:"+task.getName());//任务名称:提交申请  任务名称:部门审批
                logger.info("任务的创建时间:"+task.getCreateTime());//任务的创建时间:Tue Apr 14 18:08:52 CST 2020  任务的创建时间:Tue Apr 14 18:42:29 CST 20
                logger.info("任务的办理人:"+task.getAssignee());//任务的办理人:张三 任务的办理人:李四
                logger.info("流程实例Id:"+task.getProcessInstanceId());//流程实例Id:2501  流程实例Id:2501
                logger.info("执行对象Id:"+task.getExecutionId());//执行对象Id:2502 执行对象Id:2502
                logger.info("流程定义Id:"+task.getProcessDefinitionId());//流程定义Id:myProcess:1:4 流程定义Id:myProcess:1:4
                logger.info("***********************************************");
            }
        }
    }

    /**
     * 完成我的任务
     */
    @Test
    public void completeMyPersonTask(){
        //任务id
        String taskId = "40002"; //2505 5002  15005  20002    32505  40002
        processEngine.getTaskService() //与任务相关的service
        .complete(taskId); //完成任务
        logger.info("完成任务，任务id:"+taskId); //完成任务，任务id:5002

    }

    /**
     * 查询流程定义
     */
    @Test
    public void findProcessDefinition(){
        List list = processEngine.getRepositoryService()//与流程定义和部署相关的service
                .createProcessDefinitionQuery()//创建一个流程定义的查询
                /** 指定查询条件， where 条件**/
//        .deploymentId(deploymentId)//使用部署对象ID查询
//        .processDefinitionId(processDefinitionId)//使用流程定义Id查询
//        .processDefinitionKey(processDefinitionKey) //使用流程定义key查询
//        .processDefinitionName(processDefinionName) //使用流程定义Name查询

                /** 排序**/
                .orderByProcessDefinitionVersion().asc()//按照版本的升序排列
//        .orderByProcessDefinitionName().desc()//按照流程定义的名称降序排列
                /** 返回的结果**/
                .list();//返回一个集合列表，封装流程定义
//        .singleResult();//返回唯一结果集
//        .count();//返回结果集数量
//       .listPage(firstResult,maxResults);//分页查询
        if(list!=null && list.size()>0){
            for(ProcessDefinition pd:list){
                System.out.println("流程定义ID:"+pd.getId());//流程定义的key+版本+随机生成数
                System.out.println("流程定义名称："+pd.getName());//bpmn文件中的names属性值
                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());
                System.out.println("#######################################################");
            }
        }
    }

    /**
     * 删除流程定义
     */
    @Test
    public void deleteaProcessDefinition(){
        String deploymentId = "65001";
        //使用部署ID 完成删除
//        processEngine.getRepositoryService()//
//        .deleteDeployment(deploymentId); //不能级联删除，只能删除没有启动的流程，如果流程启动就会抛异常

        //不管流程是否启动，都能删除
        processEngine.getRepositoryService()//

        .deleteDeployment(deploymentId,true);//默认是false  实现级联删除。
    }

    /**
     * 查看流程图
     */
    @Test
    public void viewflow() throws IOException {
        //将生成的图片放到文件夹下
        String deploymentId = "1";
        String resourceName = "";
        //获取图片资源名称
        List list = processEngine.getRepositoryService()
                .getDeploymentResourceNames(deploymentId);
        if(list!=null && list.size()>0){
            for(String name:list){
                if(name.indexOf(".png")>=0){
                    resourceName = name;
                }
            }
        }
        InputStream in = processEngine.getRepositoryService()//
                .getResourceAsStream(deploymentId, resourceName);
        //将图片生成到d盘的目录下
        File file = new File("D:/"+resourceName);
        //将输入流图片写入到d盘
        FileUtils.copyInputStreamToFile(in,file);
    }

    /**
     * 附加功能 查询最新版本的流程
     */
    @Test
    public void findLastVersionProcessDefinition(){
        List list = processEngine.getRepositoryService()//
                .createProcessDefinitionQuery()
                .orderByProcessDefinitionVersion().asc()//是用流程定义的版本升序排序
                .list();
        Map map = new LinkedHashMap();
        if(list!=null && list.size()>0){
            for(ProcessDefinition pd:list){
                map.put(pd.getKey(),pd);
            }
        }
        List pdlist = new ArrayList(map.values());
        if(pdlist!=null && pdlist.size()>0){
            for(ProcessDefinition pd:pdlist){
                System.out.println( "流程定义ID:"+pd.getId());//流程定义的key+版本+随机生成数
                System.out.println( "流程定义名称："+pd.getName());//bpmn文件中的names属性值
                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());
                System.out.println( "#######################################################");
            }
        }
    }

    /**
     * 附加功能，删除流程定义（删除key相同的所有不同版本的流程定义）
     */
    public void deleteProcessDefintionByKey(){
        //流程定义的key
        String key ="myProcess";
        List list = processEngine.getRepositoryService()//先使用流程定义的key查询流程定义，查询出所有的版本
                .createProcessDefinitionQuery()
                .list();
        //遍历 获取每个流程定义的部署Id
        if(list!=null && list.size()>0){
            for(ProcessDefinition pd:list){
                String deploymentId = pd.getDeploymentId();
                processEngine.getRepositoryService()
                        .deleteDeployment(deploymentId,true);
            }
        }
    }

    /**
     * 查询流程状态，判断流程是否正在执行还是结束
     */
    @Test
    public void isProcessEnd(){
        String processInstanceId = "2501";
        ProcessInstance pi = processEngine.getRuntimeService()//表示正在执行的流程实例和执行对象
                .createProcessInstanceQuery()//创建流程实例查询
                .processInstanceId(processInstanceId)//使用流程实例ID
                .singleResult();//流程实例对象
        if(pi == null){
            System.out.println("流程结束");
        }else{
            System.out.println("流程没有结束");
        }
    }

    /**
     * 查询历史任务（后面讲）
     */
    @Test
    public void findHistoryTask(){
        String taskAssignee ="";
        List list = processEngine.getHistoryService()//与历史数据（历史表）相关的service
                .createHistoricTaskInstanceQuery()//创建历史任务实例查询
                .taskAssignee(taskAssignee)//指定历史任务的办理人
                .list();
        if(list!= null && list.size()>0){
            for(HistoricTaskInstance hti:list){
                System.out.println(hti.getId()+"  "+hti.getName()+" "+hti.getProcessDefinitionId()+" "+hti.getStartTime()+" "+hti.getEndTime());
            }
        }
    }

    /**
     * 查询历史流程实例（后面讲）
     */
    @Test
    public void findHistoryProcessInstance(){
        String processInstanceId = "";
        HistoricProcessInstance hpi = processEngine.getHistoryService()
                .createHistoricProcessInstanceQuery()//创建历史流程实例查询
                .processInstanceId(processInstanceId)//使用流程实例ID查询
                .singleResult();
        System.out.println(hpi.getId()+" "+hpi.getProcessDefinitionId()+" "+hpi.getStartTime()+" "+hpi.getEndTime());
    }

    /**
     * 设置流程变量
     */
    @Test
    public void setVariables(){
        //任务Id
        String taskId ="32505";//15005 20002        32505
        /** 与任务（正在执行）**/
        TaskService taskService = processEngine.getTaskService();
        /** 1. 设置流程变量 使用基本数据类型**/
//        taskService.setVariableLocal(taskId,"请假天数",5);//与任务Id绑定
//        taskService.setVariable(taskId,"请假日期",new Date());
//        taskService.setVariable(taskId,"请假原因","回家探亲--起吃饭");//select * from act_ru_variable

        /** 2. 设置流程变量使用javabean**/
        Person p = new Person(1,"张三");
        taskService.setVariable(taskId,"人员信息",p);
    }

    /**
     * 获取流程变量
     */
    @Test
    public void getVariables(){
        //任务Id
        String taskId ="32505";//15005 20002        32505
        /** 与任务（正在执行）**/
        TaskService taskService = processEngine.getTaskService();
        /** 1. 获取流程变量 使用基本数据类型**/
//        Integer days = (Integer) taskService.getVariable(taskId, "请假天数");
//        Date date = (Date) taskService.getVariable(taskId, "请假日期");
//        String reason = (String) taskService.getVariable(taskId, "请假原因");
//
//        System.out.println("请假天数:"+days);
//        System.out.println("请假日期:"+date);
//        System.out.println("请假原因:"+reason);

        /** 2. 获取流程变量，使用JavaBean类型 **/
        /**
         * 当一个javabean（实现序列）放置到流程变量中，要求javabean的属性不能再发生变化，
         * 如果发生变化，在获取的时候会抛出异常
         * 解决办法加上版本号序列号
         */

        Person p = (Person) taskService.getVariable(taskId, "人员信息");
        System.out.println(p.toString());

    }

    /** 模拟设置和获取流程变量的场景**/
    public void setAndGetVariables(){
        /** 与流程实例，执行对象（正在执行）**/
        RuntimeService runtimeService = processEngine.getRuntimeService();
        /** 与任务（正在执行）**/
        TaskService taskService = processEngine.getTaskService();

        /** 设置流程变量**/
//        runtimeService.setVariable(executionId,variableName,value);//表示执行对象id 和流程变量的名称，设置流程变量的值（一次只能设置一个值）
//        runtimeService.setVariables(executionId,variables);//表示使用执行对象ID,和map集合设置流程变量。map集合的key就是流程变量名称，map集合的value 就是流程变量的值（一次可以设置多个）

//        taskService.setVariable(taskId,variableName,value);//表示任务id 和流程变量的名称，设置流程变量的值（一次只能设置一个值）
//        taskService.setVariables(taskId,variables);//表示使用任务ID,和map集合设置流程变量。map集合的key就是流程变量名称，map集合的value 就是流程变量的值（一次可以设置多个）

//        runtimeService.startProcessInstanceByKey(processDefinitionKey,variables);//启动流程实例的时候设置流程变量，使用map 集合
//        taskService.setVariables(taskId,variables);//完成任务的时候设置流程变量，使用map

        /** 获取流程变量**/
//        runtimeService.getVariable(executionId,vaiableName);//根据执行对象id,和流程变量名称 获取流程变量值
//        runtimeService.getVariables(executionId);//使用执行对象ID,获取所有的流程变量，将流程变量放置到map集合中
//        runtimeService.getVariables(executionId，vaiableNames);//使用执行对象Id,获取流程变量的值，通过设置流程变量的名称存放到集合中，获取指定流程变量名称的流程变量的值，值存放到map集合中


//        taskService.getVariable(taskId,vaiableName);//根据任务id,和流程变量名称 获取流程变量值
//        taskService.getVariables(taskId);//使用任务ID,获取所有的流程变量，将流程变量放置到map集合中
//        taskService.getVariables(taskId，vaiableNames);//使用任务Id,获取流程变量的值，通过设置流程变量的名称存放到集合中，获取指定流程变量名称的流程变量的值，值存放到map集合中


    }

    /**
     * 查询流程变量的历史表
     */
    @Test
    public void findHistoryProcessVariables(){
        List list = processEngine.getHistoryService()//
                .createHistoricVariableInstanceQuery()//创建一个历史的流程变量查询对象
                .variableName("请假天数")
                .list();
        if(list!=null && list.size()>0){
            for(HistoricVariableInstance hvi :list){
                System.out.println(hvi.getId()+" "+hvi.getProcessInstanceId()+" "+hvi.getVariableTypeName()+" "+hvi.getVariableName()+" "+hvi.getValue());
                System.out.println("######################################################");
            }
        }
    }

    /**
     * 历史流程实例
     */
    @Test
    public void findHistoryProcessInstance_(){
        String processInstanceId ="15001";
        HistoricProcessInstance hpi = processEngine.getHistoryService()//
                .createHistoricProcessInstanceQuery()//创建一个历史的流程实例查询对象
                .processInstanceId(processInstanceId)//使用流程实例ID查询
                .singleResult();
        if(hpi!=null){
                System.out.println(hpi.getId()+" "+hpi.getProcessDefinitionId()+" "+hpi.getStartTime()+" "+hpi.getEndTime());

        }
    }

    /**
     * 查询历史活动
     */
    @Test
    public void findHistoryActiviti(){
        String processInstanceId ="15001";
        List list = processEngine.getHistoryService()
                .createHistoricActivityInstanceQuery()//创建历史活动实例查询对象
                .processInstanceId(processInstanceId)
                .orderByHistoricActivityInstanceStartTime().asc()
                .list();
        if(list!=null && list.size()>0){
            for(HistoricActivityInstance hai:list){
                System.out.println(hai.getId()+" "+hai.getProcessInstanceId()+ " "+hai.getStartTime()+" "+hai.getEndTime()+" "+hai.getDurationInMillis());
                System.out.println("####################################################");
            }
        }
    }

    /**
     * 查询历任务
     */
    @Test
    public void findHistoryTask_(){
//        String taskAssignee ="";
        String processInstanceId = "15001";
        List list = processEngine.getHistoryService()//与历史数据（历史表）相关的service
                .createHistoricTaskInstanceQuery()//创建历史任务实例查询
//                .taskAssignee(taskAssignee)//指定历史任务的办理人
                .processInstanceId(processInstanceId)
                .orderByHistoricTaskInstanceStartTime().asc()
                .list();
        if(list!= null && list.size()>0){
            for(HistoricTaskInstance hti:list){
                System.out.println(hti.getId()+"  "+hti.getName()+" "+hti.getProcessDefinitionId()+" "+hti.getStartTime()+" "+hti.getEndTime());
            }
        }
    }
}

package com.demo.activiti;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 线条
 */
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class SequenceFlowTest {
    private Logger logger = LoggerFactory.getLogger(SequenceFlowTest.class);

    /**
     * 默认方式获取  流程引擎对象
     */
    @Autowired
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

    /**
     * 部署流程定义
     */
    @Test
    public void deployment() {
        //与流程定义和流程部署相关的service
        Deployment deploy = processEngine.getRepositoryService()
                .createDeployment() //创建一个部署对象
                .name("连线") //添加部署的名称
                .addClasspathResource("workflow/sequenceFlow.bpmn")//从classpath加载资源文件 一次只能加载一个文件
                .addClasspathResource("workflow/sequenceFlow.png")
                .deploy();//完成部署
        logger.info("id:" + deploy.getId());//1
        logger.info("id:" + deploy.getName());//对应的表act_re_procdef（） act_re_deployment（部署表） act_ge_bytearray （二进制表） act_ge_property（版本号控制的）
    }

    /**
     * 启动流程实例
     */
    @Test
    public void startProcessInstance() {
        //流程顶定义的key
        String processDefinitionKey = "sequenceFlow";
        //返回流程实例对象
        ProcessInstance processInstance = processEngine.getRuntimeService() //正在执行的流程实例和执行对象相关的对象--执行管理 ，包括启动 推进 删除流程实例等操作
                .startProcessInstanceByKey(processDefinitionKey);//使用流程定义的key 启动实例，key 为bpmn 文件id 的属性值myProcess  或者 流程定义表：act_re_procdef 表中的key
        //默认使用的最新版本的流程定义启动
        logger.info("流程实例id:"+processInstance.getId());//流程实例id:2501
        logger.info("流程定义id:"+processInstance.getProcessDefinitionId());//流程定义id:myProcess:1:4
        //act_ru_execution  act_ru_task  act_ru_identitylink  act_ru_execution  act_hi_taskinst  act_hi_procinst  act_hi_identitylink act_hi_actinst
    }

    /**
     * 查询当前人的个人任务
     */
    @Test
    public void findMyPersonProcessTask(){
        String assignee = "赵六";//张三 李四 赵六
        //任务管理
        List list = processEngine.getTaskService() //与任务相关的service
                .createTaskQuery()
                .taskAssignee(assignee) //指定个人任务查询 指定办理人  act_ru_task
                .list();
        if(list!= null && list.size()>0){
            for(Task task:list){
                logger.info("任务id:"+task.getId());//任务id:2505  任务id:5002
                logger.info("任务名称:"+task.getName());//任务名称:提交申请  任务名称:部门审批
                logger.info("任务的创建时间:"+task.getCreateTime());//任务的创建时间:Tue Apr 14 18:08:52 CST 2020  任务的创建时间:Tue Apr 14 18:42:29 CST 20
                logger.info("任务的办理人:"+task.getAssignee());//任务的办理人:张三 任务的办理人:李四
                logger.info("流程实例Id:"+task.getProcessInstanceId());//流程实例Id:2501  流程实例Id:2501
                logger.info("执行对象Id:"+task.getExecutionId());//执行对象Id:2502 执行对象Id:2502
                logger.info("流程定义Id:"+task.getProcessDefinitionId());//流程定义Id:myProcess:1:4 流程定义Id:myProcess:1:4
                logger.info("***********************************************");
            }
        }
    }

    /**
     * 完成我的任务
     */
    @Test
    public void completeMyPersonTask(){
        //任务id
        String taskId = "60004"; //50005  57505  60004
        //完成任务的同时 设置流程变量  使用流程变量用来指定完成任务后 下一个连线，对应sequenceFlow.bpmn 文件中的 #{message=='不重要'}
        Map variables = new HashMap();
        variables.put("message","重要");
        processEngine.getTaskService() //与任务相关的service
                .complete(taskId,variables); //完成任务
        logger.info("完成任务，任务id:"+taskId); //完成任务，任务id:5002

    }
}

package com.demo.activiti;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 排他网关
 */
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class ExclusiveGaeWayTest {
    private Logger logger = LoggerFactory.getLogger(ExclusiveGaeWayTest.class);

    /**
     * 默认方式获取  流程引擎对象
     */
    @Autowired
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

    /**
     * 部署流程定义
     */
    @Test
    public void deployment() {
        //与流程定义和流程部署相关的service
        Deployment deploy = processEngine.getRepositoryService()
                .createDeployment() //创建一个部署对象
                .name("排他网关") //添加部署的名称
                .addClasspathResource("workflow/exclusiveGaeWay.bpmn")//从classpath加载资源文件 一次只能加载一个文件
                .addClasspathResource("workflow/exclusiveGaeWay.png")
                .deploy();//完成部署
        logger.info("id:" + deploy.getId());//1
        logger.info("id:" + deploy.getName());//对应的表act_re_procdef（） act_re_deployment（部署表） act_ge_bytearray （二进制表） act_ge_property（版本号控制的）
    }

    /**
     * 启动流程实例
     */
    @Test
    public void startProcessInstance() {
        //流程顶定义的key
        String processDefinitionKey = "exclusiveGaeWay";
        //返回流程实例对象
        ProcessInstance processInstance = processEngine.getRuntimeService() //正在执行的流程实例和执行对象相关的对象--执行管理 ，包括启动 推进 删除流程实例等操作
                .startProcessInstanceByKey(processDefinitionKey);//使用流程定义的key 启动实例，key 为bpmn 文件id 的属性值myProcess  或者 流程定义表：act_re_procdef 表中的key
        //默认使用的最新版本的流程定义启动
        logger.info("流程实例id:"+processInstance.getId());//流程实例id:2501
        logger.info("流程定义id:"+processInstance.getProcessDefinitionId());//流程定义id:myProcess:1:4
        //act_ru_execution  act_ru_task  act_ru_identitylink  act_ru_execution  act_hi_taskinst  act_hi_procinst  act_hi_identitylink act_hi_actinst
    }

    /**
     * 查询当前人的个人任务
     */
    @Test
    public void findMyPersonProcessTask(){
        String assignee = "赵小六";//王小五 胡小八  赵小六
        //任务管理
        List list = processEngine.getTaskService() //与任务相关的service
                .createTaskQuery()
                .taskAssignee(assignee) //指定个人任务查询 指定办理人  act_ru_task
                .list();
        if(list!= null && list.size()>0){
            for(Task task:list){
                logger.info("任务id:"+task.getId());//任务id:2505  任务id:5002
                logger.info("任务名称:"+task.getName());//任务名称:提交申请  任务名称:部门审批
                logger.info("任务的创建时间:"+task.getCreateTime());//任务的创建时间:Tue Apr 14 18:08:52 CST 2020  任务的创建时间:Tue Apr 14 18:42:29 CST 20
                logger.info("任务的办理人:"+task.getAssignee());//任务的办理人:张三 任务的办理人:李四
                logger.info("流程实例Id:"+task.getProcessInstanceId());//流程实例Id:2501  流程实例Id:2501
                logger.info("执行对象Id:"+task.getExecutionId());//执行对象Id:2502 执行对象Id:2502
                logger.info("流程定义Id:"+task.getProcessDefinitionId());//流程定义Id:myProcess:1:4 流程定义Id:myProcess:1:4
                logger.info("***********************************************");
            }
        }
    }

    /**
     * 完成我的任务
     */
    @Test
    public void completeMyPersonTask(){
        //任务id
        String taskId = "85005"; //72505  75005   82505  85005
        //完成任务的同时 设置流程变量  使用流程变量用来指定完成任务后 下一个连线，对应sequenceFlow.bpmn 文件中的 #{message=='不重要'}
        Map variables = new HashMap();
        variables.put("money",800);
        processEngine.getTaskService() //与任务相关的service
                .complete(taskId,variables); //完成任务
        logger.info("完成任务，任务id:"+taskId); //完成任务，任务id:5002

    }

}

package com.demo.activiti;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 并行网关
 */
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class PalallelGateWayTest {
    private Logger logger = LoggerFactory.getLogger(PalallelGateWayTest.class);

    /**
     * 默认方式获取  流程引擎对象
     */
    @Autowired
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

    /**
     * 部署流程定义
     */
    @Test
    public void deployment() {
        //与流程定义和流程部署相关的service
        Deployment deploy = processEngine.getRepositoryService()
                .createDeployment() //创建一个部署对象
                .name("并行网关") //添加部署的名称
                .addClasspathResource("workflow/parallelGateWay.bpmn")//从classpath加载资源文件 一次只能加载一个文件
//                .addClasspathResource("workflow/parallelGateWay.png")
                .deploy();//完成部署
        logger.info("id:" + deploy.getId());//1
        logger.info("id:" + deploy.getName());//对应的表act_re_procdef（） act_re_deployment（部署表） act_ge_bytearray （二进制表） act_ge_property（版本号控制的）
    }

    /**
     * 启动流程实例
     */
    @Test
    public void startProcessInstance() {
        //流程顶定义的key
        String processDefinitionKey = "parallelGateWay";
        //返回流程实例对象
        ProcessInstance processInstance = processEngine.getRuntimeService() //正在执行的流程实例和执行对象相关的对象--执行管理 ，包括启动 推进 删除流程实例等操作
                .startProcessInstanceByKey(processDefinitionKey);//使用流程定义的key 启动实例，key 为bpmn 文件id 的属性值myProcess  或者 流程定义表：act_re_procdef 表中的key
        //默认使用的最新版本的流程定义启动
        logger.info("流程实例id:"+processInstance.getId());//流程实例id:2501
        logger.info("流程定义id:"+processInstance.getProcessDefinitionId());//流程定义id:myProcess:1:4
        //act_ru_execution  act_ru_task  act_ru_identitylink  act_ru_execution  act_hi_taskinst  act_hi_procinst  act_hi_identitylink act_hi_actinst
    }

    /**
     * 查询当前人的个人任务
     */
    @Test
    public void findMyPersonProcessTask(){
        String assignee = "赵小六";//王小五 胡小八  赵小六
        //任务管理
        List list = processEngine.getTaskService() //与任务相关的service
                .createTaskQuery()
                .taskAssignee(assignee) //指定个人任务查询 指定办理人  act_ru_task
                .list();
        if(list!= null && list.size()>0){
            for(Task task:list){
                logger.info("任务id:"+task.getId());//任务id:2505  任务id:5002
                logger.info("任务名称:"+task.getName());//任务名称:提交申请  任务名称:部门审批
                logger.info("任务的创建时间:"+task.getCreateTime());//任务的创建时间:Tue Apr 14 18:08:52 CST 2020  任务的创建时间:Tue Apr 14 18:42:29 CST 20
                logger.info("任务的办理人:"+task.getAssignee());//任务的办理人:张三 任务的办理人:李四
                logger.info("流程实例Id:"+task.getProcessInstanceId());//流程实例Id:2501  流程实例Id:2501
                logger.info("执行对象Id:"+task.getExecutionId());//执行对象Id:2502 执行对象Id:2502
                logger.info("流程定义Id:"+task.getProcessDefinitionId());//流程定义Id:myProcess:1:4 流程定义Id:myProcess:1:4
                logger.info("***********************************************");
            }
        }
    }

    /**
     * 完成我的任务
     */
    @Test
    public void completeMyPersonTask(){
        //任务id
        String taskId = "95004"; //92507   92509  95004  97503
        //完成任务的同时 设置流程变量  使用流程变量用来指定完成任务后 下一个连线，对应sequenceFlow.bpmn 文件中的 #{message=='不重要'}
        Map variables = new HashMap();
        variables.put("money",800);
        processEngine.getTaskService() //与任务相关的service
                .complete(taskId,variables); //完成任务
        logger.info("完成任务，任务id:"+taskId); //完成任务，任务id:5002

    }

}

package com.demo.activiti;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 个人任务
 */
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class Person1TaskTest {
    private Logger logger = LoggerFactory.getLogger(Person1TaskTest.class);

    /**
     * 默认方式获取  流程引擎对象
     */
    @Autowired
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

    /**
     * 部署流程定义
     */
    @Test
    public void deployment() {
        //与流程定义和流程部署相关的service
        Deployment deploy = processEngine.getRepositoryService()
                .createDeployment() //创建一个部署对象
                .name("个人任务") //添加部署的名称
                .addClasspathResource("workflow/person1Task.bpmn")//从classpath加载资源文件 一次只能加载一个文件
//                .addClasspathResource("workflow/exclusiveGaeWay.png")
                .deploy();//完成部署
        logger.info("id:" + deploy.getId());//1
        logger.info("id:" + deploy.getName());//对应的表act_re_procdef（） act_re_deployment（部署表） act_ge_bytearray （二进制表） act_ge_property（版本号控制的）
    }

    /**
     * 启动流程实例
     */
    @Test
    public void startProcessInstance() {
        //流程顶定义的key
        String processDefinitionKey = "person1Task";
        /** 启动流程实例的同时，设置流程变量**/
        Map variables = new HashMap();//userId-->流程变量
        variables.put("userId","周芷若");
        //返回流程实例对象
        ProcessInstance processInstance = processEngine.getRuntimeService() //正在执行的流程实例和执行对象相关的对象--执行管理 ，包括启动 推进 删除流程实例等操作
                .startProcessInstanceByKey(processDefinitionKey,variables);//使用流程定义的key 启动实例，key 为bpmn 文件id 的属性值myProcess  或者 流程定义表：act_re_procdef 表中的key
        //默认使用的最新版本的流程定义启动
        logger.info("流程实例id:"+processInstance.getId());//流程实例id:2501
        logger.info("流程定义id:"+processInstance.getProcessDefinitionId());//流程定义id:myProcess:1:4
        //act_ru_execution  act_ru_task  act_ru_identitylink  act_ru_execution  act_hi_taskinst  act_hi_procinst  act_hi_identitylink act_hi_actinst
    }

    /**
     * 查询当前人的个人任务
     */
    @Test
    public void findMyPersonProcessTask(){
        String assignee = "周芷若";//张三丰  周芷若
        //任务管理
        List list = processEngine.getTaskService() //与任务相关的service
                .createTaskQuery()
                .taskAssignee(assignee) //指定个人任务查询 指定办理人  act_ru_task
                .list();
        if(list!= null && list.size()>0){
            for(Task task:list){
                logger.info("任务id:"+task.getId());//任务id:2505  任务id:5002
                logger.info("任务名称:"+task.getName());//任务名称:提交申请  任务名称:部门审批
                logger.info("任务的创建时间:"+task.getCreateTime());//任务的创建时间:Tue Apr 14 18:08:52 CST 2020  任务的创建时间:Tue Apr 14 18:42:29 CST 20
                logger.info("任务的办理人:"+task.getAssignee());//任务的办理人:张三 任务的办理人:李四
                logger.info("流程实例Id:"+task.getProcessInstanceId());//流程实例Id:2501  流程实例Id:2501
                logger.info("执行对象Id:"+task.getExecutionId());//执行对象Id:2502 执行对象Id:2502
                logger.info("流程定义Id:"+task.getProcessDefinitionId());//流程定义Id:myProcess:1:4 流程定义Id:myProcess:1:4
                logger.info("***********************************************");
            }
        }
    }

    /**
     * 完成我的任务
     */
    @Test
    public void completeMyPersonTask(){
        //任务id
        String taskId = "127507"; //72505  75005   82505  85005 127507
        //完成任务的同时 设置流程变量  使用流程变量用来指定完成任务后 下一个连线，对应sequenceFlow.bpmn 文件中的 #{message=='不重要'}
        Map variables = new HashMap();
        variables.put("hahaha","哈哈哈");
        processEngine.getTaskService() //与任务相关的service
                .complete(taskId,variables); //完成任务
        logger.info("完成任务，任务id:"+taskId); //完成任务，任务id:5002

    }
    /**
     * 删除流程定义
     */
    @Test
    public void deleteaProcessDefinition(){
        String deploymentId = "110001";
        //使用部署ID 完成删除
//        processEngine.getRepositoryService()//
//        .deleteDeployment(deploymentId); //不能级联删除，只能删除没有启动的流程，如果流程启动就会抛异常

        //不管流程是否启动，都能删除
        processEngine.getRepositoryService()//

                .deleteDeployment(deploymentId,true);//默认是false  实现级联删除。
    }
}

package com.demo.activiti;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 个人任务
 */
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class Person2TaskTest {
    private Logger logger = LoggerFactory.getLogger(Person2TaskTest.class);

    /**
     * 默认方式获取  流程引擎对象
     */
    @Autowired
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

    /**
     * 部署流程定义
     */
    @Test
    public void deployment() {
        //与流程定义和流程部署相关的service
        Deployment deploy = processEngine.getRepositoryService()
                .createDeployment() //创建一个部署对象
                .name("个人任务2") //添加部署的名称
                .addClasspathResource("workflow/person2Task.bpmn")//从classpath加载资源文件 一次只能加载一个文件
//                .addClasspathResource("workflow/exclusiveGaeWay.png")
                .deploy();//完成部署
        logger.info("id:" + deploy.getId());//1
        logger.info("id:" + deploy.getName());//对应的表act_re_procdef（） act_re_deployment（部署表） act_ge_bytearray （二进制表） act_ge_property（版本号控制的）
    }

    /**
     * 启动流程实例
     */
    @Test
    public void startProcessInstance() {
        //流程顶定义的key
        String processDefinitionKey = "person2Task";
        /** 启动流程实例的同时，设置流程变量**/
//        Map variables = new HashMap();//userId-->流程变量
//        variables.put("userId","周芷若");
        //返回流程实例对象
        ProcessInstance processInstance = processEngine.getRuntimeService() //正在执行的流程实例和执行对象相关的对象--执行管理 ，包括启动 推进 删除流程实例等操作
                .startProcessInstanceByKey(processDefinitionKey);//使用流程定义的key 启动实例，key 为bpmn 文件id 的属性值myProcess  或者 流程定义表：act_re_procdef 表中的key
        //默认使用的最新版本的流程定义启动
        logger.info("流程实例id:"+processInstance.getId());//流程实例id:2501
        logger.info("流程定义id:"+processInstance.getProcessDefinitionId());//流程定义id:myProcess:1:4
        //act_ru_execution  act_ru_task  act_ru_identitylink  act_ru_execution  act_hi_taskinst  act_hi_procinst  act_hi_identitylink act_hi_actinst
    }

    /**
     * 查询当前人的个人任务
     */
    @Test
    public void findMyPersonProcessTask(){
        String assignee = "张翠山";//张三丰  周芷若 张翠山
        //任务管理
        List list = processEngine.getTaskService() //与任务相关的service
                .createTaskQuery()
                .taskAssignee(assignee) //指定个人任务查询 指定办理人  act_ru_task
                .list();
        if(list!= null && list.size()>0){
            for(Task task:list){
                logger.info("任务id:"+task.getId());//任务id:2505  任务id:5002
                logger.info("任务名称:"+task.getName());//任务名称:提交申请  任务名称:部门审批
                logger.info("任务的创建时间:"+task.getCreateTime());//任务的创建时间:Tue Apr 14 18:08:52 CST 2020  任务的创建时间:Tue Apr 14 18:42:29 CST 20
                logger.info("任务的办理人:"+task.getAssignee());//任务的办理人:张三 任务的办理人:李四
                logger.info("流程实例Id:"+task.getProcessInstanceId());//流程实例Id:2501  流程实例Id:2501
                logger.info("执行对象Id:"+task.getExecutionId());//执行对象Id:2502 执行对象Id:2502
                logger.info("流程定义Id:"+task.getProcessDefinitionId());//流程定义Id:myProcess:1:4 流程定义Id:myProcess:1:4
                logger.info("***********************************************");
            }
        }
    }

    /**
     * 完成我的任务
     */
    @Test
    public void completeMyPersonTask(){
        //任务id
        String taskId = "147505"; //72505  75005   82505  85005 127507  142505 147505
        //完成任务的同时 设置流程变量  使用流程变量用来指定完成任务后 下一个连线，对应sequenceFlow.bpmn 文件中的 #{message=='不重要'}
//        Map variables = new HashMap();
//        variables.put("hahaha","哈哈哈");
        processEngine.getTaskService() //与任务相关的service
                .complete(taskId);
//                .complete(taskId,variables); //完成任务
        logger.info("完成任务，任务id:"+taskId); //完成任务，任务id:5002

    }

    /**
     * 可以分配个人任务从一个人到另一个人（认领任务）
     */
    @Test
    public void setAssigneeTask(){
        /** 任务ID  和指定办理人ID**/
        String taskId ="147505";
        String userId ="张翠山";
        processEngine.getTaskService()
                .setAssignee(taskId,userId);
    }

    /**
     * 删除流程定义
     */
    @Test
    public void deleteaProcessDefinition(){
        String deploymentId = "137501";
        //使用部署ID 完成删除
//        processEngine.getRepositoryService()//
//        .deleteDeployment(deploymentId); //不能级联删除，只能删除没有启动的流程，如果流程启动就会抛异常

        //不管流程是否启动，都能删除
        processEngine.getRepositoryService()//

                .deleteDeployment(deploymentId,true);//默认是false  实现级联删除。
    }
}

package com.demo.activiti;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.Execution;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 接收任务活动 即等待活动
 */
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class ReceiveTaskTest {
    private Logger logger = LoggerFactory.getLogger(ReceiveTaskTest.class);

    /**
     * 默认方式获取  流程引擎对象
     */
    @Autowired
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

    /**
     * 部署流程定义
     */
    @Test
    public void deployment() {
        //与流程定义和流程部署相关的service
        Deployment deploy = processEngine.getRepositoryService()
                .createDeployment() //创建一个部署对象
                .name("接收活动") //添加部署的名称
                .addClasspathResource("workflow/receiveTask.bpmn")//从classpath加载资源文件 一次只能加载一个文件
//                .addClasspathResource("workflow/sequenceFlow.png")
                .deploy();//完成部署
        logger.info("id:" + deploy.getId());//1
        logger.info("id:" + deploy.getName());//对应的表act_re_procdef（） act_re_deployment（部署表） act_ge_bytearray （二进制表） act_ge_property（版本号控制的）
    }

    /**
     * 启动流程实例，设置流程变量 获取流程变量 向后执行一步
     */
    @Test
    public void startProcessInstance() {
        //流程顶定义的key
        String processDefinitionKey = "receiveTask";
        //返回流程实例对象
        ProcessInstance processInstance = processEngine.getRuntimeService() //正在执行的流程实例和执行对象相关的对象--执行管理 ，包括启动 推进 删除流程实例等操作
                .startProcessInstanceByKey(processDefinitionKey);//使用流程定义的key 启动实例，key 为bpmn 文件id 的属性值myProcess  或者 流程定义表：act_re_procdef 表中的key
        //默认使用的最新版本的流程定义启动
        logger.info("流程实例id:" + processInstance.getId());//流程实例id:2501
        logger.info("流程定义id:" + processInstance.getProcessDefinitionId());//流程定义id:myProcess:1:4
        //act_ru_execution  act_ru_task  act_ru_identitylink  act_ru_execution  act_hi_taskinst  act_hi_procinst  act_hi_identitylink act_hi_actinst
        /** 查询执行对象ID**/
        String processInstanceId = processInstance.getId();
        String activityId = "_4";
        Execution execution = processEngine.getRuntimeService()
                .createExecutionQuery()//创建执行对象查询
                .processInstanceId(processInstanceId)
                .activityId(activityId)//当前活动Id,对应bpmn文件中的活动节点Id的值（receiveTask-->id）
                .singleResult();
/**使用流程变量设置当日销售额 用来传递业务参数*/
        String executionId = execution.getId();
        processEngine.getRuntimeService()
                .setVariable(executionId, "汇总当日销售额", 21000);

        /** 向后执行一步，如果流程处于等待状态，使得流程继续执行**/
        processEngine.getRuntimeService()
                .signalEventReceived(executionId);

        /** 流程变量中获取汇总当日销售额的值 **/
        String variableName = "汇总当日销售额";
        Integer value = (Integer) processEngine.getRuntimeService()
                .getVariable(executionId, variableName);

        System.out.println("给老板发送短信：金额是："+value);

        /**查询执行对象ID*/
        Execution execution2 = processEngine.getRuntimeService()
                .createExecutionQuery()//创建执行对象查询
                .processInstanceId(processInstanceId)//使用流程实例ID查询
                .activityId("_5")//当前活动的id，对应receiveTask.bpmn文件中的活动节点的id的属性值
                .singleResult();
        /** 向后执行一步，如果流程处于等待状态，使得流程继续执行**/
        processEngine.getRuntimeService()
                .signalEventReceived(execution2.getId());
    }

    /**
     * 查询当前人的个人任务
     */
    @Test
    public void findMyPersonProcessTask() {
        String assignee = "赵六";//张三 李四 赵六
        //任务管理
        List list = processEngine.getTaskService() //与任务相关的service
                .createTaskQuery()
                .taskAssignee(assignee) //指定个人任务查询 指定办理人  act_ru_task
                .list();
        if (list != null && list.size() > 0) {
            for (Task task : list) {
                logger.info("任务id:" + task.getId());//任务id:2505  任务id:5002
                logger.info("任务名称:" + task.getName());//任务名称:提交申请  任务名称:部门审批
                logger.info("任务的创建时间:" + task.getCreateTime());//任务的创建时间:Tue Apr 14 18:08:52 CST 2020  任务的创建时间:Tue Apr 14 18:42:29 CST 20
                logger.info("任务的办理人:" + task.getAssignee());//任务的办理人:张三 任务的办理人:李四
                logger.info("流程实例Id:" + task.getProcessInstanceId());//流程实例Id:2501  流程实例Id:2501
                logger.info("执行对象Id:" + task.getExecutionId());//执行对象Id:2502 执行对象Id:2502
                logger.info("流程定义Id:" + task.getProcessDefinitionId());//流程定义Id:myProcess:1:4 流程定义Id:myProcess:1:4
                logger.info("***********************************************");
            }
        }
    }

    /**
     * 完成我的任务
     */
    @Test
    public void completeMyPersonTask() {
        //任务id
        String taskId = "60004"; //50005  57505  60004
        //完成任务的同时 设置流程变量  使用流程变量用来指定完成任务后 下一个连线，对应sequenceFlow.bpmn 文件中的 #{message=='不重要'}
        Map variables = new HashMap();
        variables.put("message", "重要");
        processEngine.getTaskService() //与任务相关的service
                .complete(taskId, variables); //完成任务
        logger.info("完成任务，任务id:" + taskId); //完成任务，任务id:5002

    }
}

package com.demo.activiti;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.history.HistoricIdentityLink;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.IdentityLink;
import org.activiti.engine.task.Task;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

/**
 * 组任务
 */
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class GroupTaskTest {
    private Logger logger = LoggerFactory.getLogger(GroupTaskTest.class);

    /**
     * 默认方式获取  流程引擎对象
     */
    @Autowired
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

    /**
     * 部署流程定义
     */
    @Test
    public void deployment() {
        //与流程定义和流程部署相关的service
        Deployment deploy = processEngine.getRepositoryService()
                .createDeployment() //创建一个部署对象
                .name("组任务") //添加部署的名称
                .addClasspathResource("workflow/groupTask.bpmn")//从classpath加载资源文件 一次只能加载一个文件
//                .addClasspathResource("workflow/exclusiveGaeWay.png")
                .deploy();//完成部署
        logger.info("id:" + deploy.getId());//1
        logger.info("id:" + deploy.getName());//对应的表act_re_procdef（） act_re_deployment（部署表） act_ge_bytearray （二进制表） act_ge_property（版本号控制的）
    }

    /**
     * 启动流程实例
     */
    @Test
    public void startProcessInstance() {
        //流程顶定义的key
        String processDefinitionKey = "groupTask";
        /** 启动流程实例的同时，设置流程变量**/
//        Map variables = new HashMap();//userId-->流程变量
//        variables.put("userId","周芷若");
        //返回流程实例对象
        ProcessInstance processInstance = processEngine.getRuntimeService() //正在执行的流程实例和执行对象相关的对象--执行管理 ，包括启动 推进 删除流程实例等操作
                .startProcessInstanceByKey(processDefinitionKey);//使用流程定义的key 启动实例，key 为bpmn 文件id 的属性值myProcess  或者 流程定义表：act_re_procdef 表中的key
        //默认使用的最新版本的流程定义启动
        logger.info("流程实例id:"+processInstance.getId());//流程实例id:2501
        logger.info("流程定义id:"+processInstance.getProcessDefinitionId());//流程定义id:myProcess:1:4
        //act_ru_execution  act_ru_task  act_ru_identitylink  act_ru_execution  act_hi_taskinst  act_hi_procinst  act_hi_identitylink act_hi_actinst
    }

    /**
     * 查询当前人的个人任务/ 组任务和办理人查询
     */
    @Test
    public void findMyPersonProcessTask(){
//        String assignee = "张翠山";//张三丰  周芷若 张翠山
        String candidateUser = "小A";
        //任务管理
        List list = processEngine.getTaskService() //与任务相关的service
                .createTaskQuery()
//                .taskAssignee(assignee) //指定个人任务查询 指定办理人  act_ru_task
                .taskCandidateUser(candidateUser)//组任务和办理人查询
                .list();
        if(list!= null && list.size()>0){
            for(Task task:list){
                logger.info("任务id:"+task.getId());//任务id:2505  任务id:5002
                logger.info("任务名称:"+task.getName());//任务名称:提交申请  任务名称:部门审批
                logger.info("任务的创建时间:"+task.getCreateTime());//任务的创建时间:Tue Apr 14 18:08:52 CST 2020  任务的创建时间:Tue Apr 14 18:42:29 CST 20
                logger.info("任务的办理人:"+task.getAssignee());//任务的办理人:张三 任务的办理人:李四
                logger.info("流程实例Id:"+task.getProcessInstanceId());//流程实例Id:2501  流程实例Id:2501
                logger.info("执行对象Id:"+task.getExecutionId());//执行对象Id:2502 执行对象Id:2502
                logger.info("流程定义Id:"+task.getProcessDefinitionId());//流程定义Id:myProcess:1:4 流程定义Id:myProcess:1:4
                logger.info("***********************************************");
            }
        }
    }

    /** 查询正在执行的办理人表**/
    @Test
    public void findRunPeronsTask(){
        String taskId = "";
        List list = processEngine.getTaskService()
                .getIdentityLinksForTask(taskId);
        if(list!=null && list.size()>0){
            for(IdentityLink d:list){
                System.out.println(d.getTaskId()+" "+d.getType()+" "+d.getProcessInstanceId()+" "+d.getUserId());
            }
        }

    }

    /** 查询历史任务的办理人表**/
    @Test
    public void findHisPeronsTask(){
        //流程实例ID
        String processInstanceId ="";
        List list = processEngine.getHistoryService()
                .getHistoricIdentityLinksForProcessInstance(processInstanceId);
        if(list!=null && list.size()>0){
            for(HistoricIdentityLink h:list){
                System.out.println(h.getTaskId()+" "+h.getType()+ " "+h.getUserId());
            }
        }

    }

    /** 拾取任务，将组任务分给个人任务，指定任务的办理人字段**/
    @Test
    public void claim(){
        //将组任务分配给个人任务
        //任务id
        String taskId = "165005";//165005
        //分配个人任务，可以是组任务中的成员，也可以是非组任务的成员
        String userId ="大F";
        processEngine.getTaskService()
                .claim(taskId,userId);

    }

    /** 将个人任务回退到组任务,前提之前一定是组任务**/
    @Test
    public void setAssigee(){
//任务id
        String taskId = "165005";//165005
        processEngine.getTaskService()
                .setAssignee(taskId,null);
    }

    /** 向组任务中添加成员**/
    @Test
    public void addGroupUser(){
        //任务ID
        String taskId = "165005";
        //成员ID
        String userId = "大H";
        processEngine.getTaskService()
                .addCandidateUser(taskId,userId);
    }

    /** 从组任务中删除成员**/
    @Test
    public void deleteGroupUser(){
//任务ID
        String taskId = "165005";
        //成员ID
        String userId = "大H";
        processEngine.getTaskService()
                .deleteCandidateUser(taskId,userId);
    }

    /**
     * 完成我的任务
     */
    @Test
    public void completeMyPersonTask(){
        //任务id
        String taskId = "147505"; //72505  75005   82505  85005 127507  142505 147505
        //完成任务的同时 设置流程变量  使用流程变量用来指定完成任务后 下一个连线，对应sequenceFlow.bpmn 文件中的 #{message=='不重要'}
//        Map variables = new HashMap();
//        variables.put("hahaha","哈哈哈");
        processEngine.getTaskService() //与任务相关的service
                .complete(taskId);
//                .complete(taskId,variables); //完成任务
        logger.info("完成任务，任务id:"+taskId); //完成任务，任务id:5002

    }

    /**
     * 可以分配个人任务从一个人到另一个人（认领任务）
     */
    @Test
    public void setAssigneeTask(){
        /** 任务ID  和指定办理人ID**/
        String taskId ="147505";
        String userId ="张翠山";
        processEngine.getTaskService()
                .setAssignee(taskId,userId);
    }

    /**
     * 删除流程定义
     */
    @Test
    public void deleteaProcessDefinition(){
        String deploymentId = "157501";
        //使用部署ID 完成删除
//        processEngine.getRepositoryService()//
//        .deleteDeployment(deploymentId); //不能级联删除，只能删除没有启动的流程，如果流程启动就会抛异常

        //不管流程是否启动，都能删除
        processEngine.getRepositoryService()//

                .deleteDeployment(deploymentId,true);//默认是false  实现级联删除。
    }
}

项目源码连接https://download.csdn.net/download/weixin_39209728/12395117