Activiti7工作流

工作流概述

借助计算机实现流程的自动化控制

表概述

ACT_RE_*：'RE’表示Repository。这个前缀的表包含了流程定义和流程静态资源（图片、规则等等）。
ACT_RU_*：'RU’表示Runtime。这些运行时的表，包含流程实例，任务、变量，异步任务等运行中的数据。Activiti只在流程实例执行过程中保存这些数据，在流程结束时就会删除这些记录。这些运行时表可以一直很小并且速度很快。
ACT_HI_*：'HI’表示History。这些表包含历史数据，比如历史流程实例，变量，任务等等。

Service总览

Service接口	说明
RepositoryService	Activiti的资源管理、流程定义接口
RuntimeService	Activiti的流程运行管理接口
TaskService	Activiti的任务管理接口
HistoryService	Activiti的历史管理接口
ManagementService	Activiti的引擎管理接口

RepositoryService，是Activiti的资源管理接口，提供了管理和控制流程发布包和流程定义的操作。使用工作流建模工具设计的业务流程图需要使用此Service将流程定义文件的内容部署到计算机中。
RuntimeService，是Activiti的流程运行管理接口，可以从这个接口中获取很多关于流程执行相关的信息。
TaskService，是Activiti的任务管理接口，可以从这个接口中获取任务的信息。
HistoryService，是Activiti的历史管理类，可以查询历史信息，执行流程时，引擎会包含很多数据（根据配置），比如流程实例启动时间，任务的参与者，完成任务的时间，每个流程实例的执行路径，等等。
ManagementService，是Activiti的引擎管理接口，提供了对Activiti流程引擎的管理和维护功能，这些功能不在工作流驱动的应用程序中使用，主要用于Activiti系统的日常维护。

Activiti使用步骤

整合Activiti

搭建项目，把各种需要使用到的**依赖**导入项目中

 <properties><slf4j.version>1.6.6</slf4j.version><log4j.version>1.2.12</log4j.version><activiti.version>7.0.0.SR1</activiti.version></properties><dependencies><!-- activiti引擎 --><dependency><groupId>org.activiti</groupId><artifactId>activiti-engine</artifactId><version>${activiti.version}</version></dependency><!-- 整合Spring --><dependency><groupId>org.activiti</groupId><artifactId>activiti-spring</artifactId><version>${activiti.version}</version></dependency><!-- bpmn 模型处理 --><dependency><groupId>org.activiti</groupId><artifactId>activiti-bpmn-model</artifactId><version>${activiti.version}</version></dependency><!-- bpmn 转换 --><dependency><groupId>org.activiti</groupId><artifactId>activiti-bpmn-converter</artifactId><version>${activiti.version}</version></dependency><!-- bpmn json数据转换 --><dependency><groupId>org.activiti</groupId><artifactId>activiti-json-converter</artifactId><version>${activiti.version}</version></dependency><!-- bpmn 布局 --><dependency><groupId>org.activiti</groupId><artifactId>activiti-bpmn-layout</artifactId><version>${activiti.version}</version></dependency><!-- mysql驱动 --><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.40</version></dependency><!-- mybatis --><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.4.5</version></dependency><!-- 单元测试 --><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version></dependency><!-- log start --><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>${log4j.version}</version></dependency><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>${slf4j.version}</version></dependency><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId><version>${slf4j.version}</version></dependency><!-- log end --><dependency><groupId>commons-io</groupId><artifactId>commons-io</artifactId><version>2.6</version></dependency><!--数据库连接池--><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.2.4</version></dependency></dependencies>

配置**log4j日志文件**

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE debug info warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE
# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r[%15.15t] %-5p %30.30c %x - %m\n
# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=./activiti.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r[%15.15t] %-5p %30.30c %x - %m\n

配置**activiti.cfg.xml**核心配置文件，在配置文件中配置数据库连接四要素，activiti单独运行的流程引擎

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xmlns:tx="http://www.springframework.org/schema/tx"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/contex
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd"><!--数据库连接池--><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver" /><property name="url" value="jdbc:mysql:///activiti" /><property name="username" value="root" /><property name="password" value="admin" /></bean><!-- 默认id对应的值 为processEngineConfiguration --><bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration"><property name="dataSource" ref="dataSource"/><!--activiti数据库表处理策略false(默认值)：检查数据库的版本和依赖库的版本，如果不匹配就抛出异常true：构建流程引擎时，执行检查，如果需要就执行更新。如果表不存在，就创建。create-drop：构建流程引擎时创建数据库报表，关闭流程引擎时就删除这些表。drop-create：先删除表再创建表。create：构建流程引擎时创建数据库表，关闭流程引擎时不删除这些表--><property name="databaseSchemaUpdate" value="true"/></bean>
</beans>

创建测试类，调用activiti的工具类，生成acitivti需要的**25张数据表**(注：数据库名为activiti)

public class ActivitiTestInit {/***初始化*/@Testpublic void testInit(){//通过流程引擎工具类来创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();System.out.println(processEngine);}
}

业务流程建模，就是画业务模型流程图

部署业务流程定义，把画好的模型流程图部署到Activiti

使用RepositoryService部署流程定义

**注：**在进行流程部署时，有三张表核心表发生了改变(act_ge_bytearray：将bpmn下的资源信息插入表中，act_re_deployment：插入了流程名称、插入时间等信息，act_re_procdef：把当前的部署业务流程信息插入表中)

/*** 部署业务流程，使用RepositoryService*/
@Test
public void textDeploy(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//流程部署涉及到对资源操作RepositoryService repositoryService = processEngine.getRepositoryService();//加载流程文件,获取部署对象Deployment deployment = repositoryService.createDeployment().addClasspathResource("bpmn/leave.bpmn").addClasspathResource("bpmn/leave.png").name("请假流程").deploy();//获取部署流程的一些信息System.out.println("流程部署ID:"+deployment.getId());System.out.println("流程部署名称:"+deployment.getName());System.out.println("流程部署时间：" + deployment.getDeploymentTime());
}

启动流程实例

使用RuntimeService启动流程实例

**注:**有7张核心表发生了改变(act_ru_task:存储当前的用户节点信息，查看当前流程处于哪个节点上，act_hi_identitylink：当前节点由谁来处理的节点信息如：hkj的相关信息，act_hi_taskinst：存储所有用户节点的历史任务信息，act_hi_procinst:存储流程实例的历史信息，act_hi_identitylink：存储了流程实例和当前用户节点的关系信息,，act_hi_actinst：存储所有经过的节点信息)

/*** 启动流程实例*/
@Test
public void testStartProcess(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//启动流程引擎对象，让流程跑起来，使用RuntimeServiceRuntimeService runtimeService = processEngine.getRuntimeService();//根据业务流程定义的key启动流程实例,这个key是在定义bpmn的时候设置的ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("leaveProcess");//获取流程实例的相关信息System.out.println("流程定义的id = " + processInstance.getProcessDefinitionId());System.out.println("流程实例的id = " + processInstance.getId());System.out.println("流程实例的name = " + processInstance.getName());
}

查询待办任务，各个任务的负责人可以查询自己当前需要处理的待办任务

使用TaskService查询待办任务

**注：**对于查询，api方法通常都是createXXXQuery()。有2张核心表发生了改变(``act_ru_task:存储当前的活动节点信息，查看当前流程处于哪个节点上，act_re_procdef`：把当前的部署业务流程信息插入表中)

/*** 查询当前用户拥有的待办任务*/
@Test
public void testCreateTaskQuery(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//获取当前指定用户的审核待办任务集合TaskService taskService = processEngine.getTaskService();List<Task> tasks = taskService.createTaskQuery()//查询指定业务流程定义key的任务.processDefinitionKey("leaveProcess")//任务负责人.taskAssignee("hkj").list();if(tasks != null && tasks.size() > 0){for (Task task : tasks) {System.out.println("任务负责人id = " + task.getId());System.out.println("任务名称：" + task.getName());System.out.println("流程实例ID：" + task.getProcessInstanceId());}}
}

任务负责人处理和完成待办任务，要么审核通过，要么拒绝

使用TaskService处理和完成待办任务

**注：**有5张核心表发生了改变(act_ge_property:流程实例id值会发生改变，act_hi_taskinst：存储所有用户节点的历史任务信息，act_hi_actinst：存储所有经过的节点信息，act_hi_identitylink：当前节点由谁来处理的节点信息是往后叠加的，如：yoona的相关信息，act_ru_task:存储当前的用户节点信息，查看当前流程处于哪个节点上，会把上一个用户节点进行覆盖 )

/*** 指定taskID或名称的任务负责人来执行处理完成任务*/
@Test
public void testCompleteTask(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//获取任务相关的serviceTaskService taskService = processEngine.getTaskService();//找到对应的任务，然后执行任务，让流程往后流转String taskID = "2505";taskService.complete(taskID);}

添加审批意见

使用TaskService添加审批意见

在执行任务之前可以给该任务添加审批意见,会存储在历史表中,我们后续可以在审批历史中查看到该意见

**注：**有1张核心表发生了改变(act_hi_comment: 存储了审批意见相关信息)

/*** 审批意见*/
@Test
public void testAddComment(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//获取任务相关的serviceTaskService taskService = processEngine.getTaskService();//给任务添加批注信息并完成处理任务String taskID = "5002";String processInstanceId = "2501";//任务和流程实例的关系taskService.addComment(taskID,processInstanceId, "审批通过");taskService.complete(taskID);
}

查询历史任务和审批记录

使用HistoryService,TaskService添加审批意见

/*** 查询历史任务和历史审批记录*/
@Test
public void testSelectHistoryTask(){/*//流程实例IDString processInstanceId = "2501";//任务负责人String taskAssignee = "hkj";*///创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//获取historyServiceHistoryService historyService = processEngine.getHistoryService();//获取taskServiceTaskService taskService = processEngine.getTaskService();//查询用户任务和历史审批记录信息List<HistoricActivityInstance> list = historyService.createHistoricActivityInstanceQuery().activityType("userTask").finished().list();for (HistoricActivityInstance activityInstance : list) {System.out.println("任务名称:"+activityInstance.getActivityName());System.out.println("任务开始时间:"+activityInstance.getStartTime());System.out.println("任务结束时间:"+activityInstance.getEndTime());System.out.println("任务耗时:"+activityInstance.getDurationInMillis());List<Comment> taskComments = taskService.getTaskComments(activityInstance.getTaskId());if(taskComments.size() > 0){System.out.println("审批批注意见:"+taskComments.get(0).getFullMessage());}System.out.println("********************************");}
}

进阶

查询流程定义

使用RepositoryService查询流程定义

查询业务流程相关信息，包含流程定义，流程部署，流程定义版本

/*** 查询流程定义*/
@Test
public void testDfinitionQuery(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//获取仓库服务RepositoryService repositoryService = processEngine.getRepositoryService();//获取指定leaveProcess流程定义集合List<ProcessDefinition> processDefinitionList = repositoryService.createProcessDefinitionQuery().processDefinitionKey("leaveProcess").list();for (ProcessDefinition definition : processDefinitionList) {System.out.println("流程定义ID:"+definition.getId());System.out.println("流程定义名称:"+definition.getName());System.out.println("流程定义key:"+definition.getKey());System.out.println("流程定义版本:"+definition.getVersion());System.out.println("流程部署ID:"+definition.getDeploymentId());System.out.println("====================");}
}

删除流程定义

注：使用RepositoryService查询流程定义

说明：

如果该流程定义下没有正在运行的流程，则可以用普通删除。
如果该流程定义下存在已经运行的流程，使用普通删除报错，可用级联删除方法将流程及相关记录全部删除。
项目开发中级联删除操作一般只开放给超级管理员使用.

/*** 流程定义删除*/
@Test
public void testDeleteDeploy(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//获取仓库服务RepositoryService repositoryService = processEngine.getRepositoryService();String deploymentId = "10001";//确保没有正在运行的流程实例，否则启动时会出错repositoryService.deleteDeployment(deploymentId);//在删除流程定义的时候，是否把当前流程定义启动的流程实例一并删除//repositoryService.deleteDeployment(deploymentId,true);
}

资源的下载

使用RepositoryService进行资源的下载

现在我们的流程资源文件已经上传到数据库了，如果其他用户想要查看这些资源文件，可以从数据库中把资源文件下载到本地。

/*** 资源的下载* @throws Exception*/
@Test
public void testDownloadResource() throws Exception {//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//获取仓库服务RepositoryService repositoryService = processEngine.getRepositoryService();//获取流程定义集合List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery().processDefinitionKey("leaveProcess").orderByProcessDefinitionVersion()//按照版本排序.desc()//降序.list();//获取最新流程定义ProcessDefinition definition =list.get(0);//获取部署IDString deploymentId = definition.getDeploymentId();//获取bpmn的输入流InputStream bpmnInput = repositoryService.getResourceAsStream(deploymentId,definition.getResourceName());//获取png的输入流InputStream pngInput = repositoryService.getResourceAsStream(deploymentId, definition.getDiagramResourceName());//设置bpmn输入FileOutputStream bpmnOutPut = new FileOutputStream("E:/leave.bpmn");//设置png输入FileOutputStream pngOutPut = new FileOutputStream("E:/leave.png");IOUtils.copy(bpmnInput,bpmnOutPut);IOUtils.copy(pngInput,pngOutPut);
}

BusinessKey（业务标识）

使用RuntimeService进行业务标识绑定

注：有1张核心表发生了改变(act_run_execution:往表中存储businessKey和流程定义、实例等相关信息)

步骤：先找任务Task，再找到流程实例，通过流程实例获取到业务标识，进而找到对应的请假单信息

//启动流程，需要进行BusinessKey绑定
//将请假条信息id作为BusinessKey并绑定要流程实例，通过id就可以查询出业务表中的请假信息
@Test
public void testStartProcessAddBusinessKey(){ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RuntimeService runtimeService = processEngine.getRuntimeService();//参数一：流程定义的key  参数二：业务标识Long businessKey = 8001L;//根据流程定义的key启动流程实例,这个key是在定义bpmn的时候设置的//在启动流程的时候将业务key加入进去,把BusinessKey绑定到整个流程实例中ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("leaveProcess",businessKey.toString());System.out.println("流程定义的id = " + processInstance.getProcessDefinitionId());System.out.println("流程实例的id = " + processInstance.getId());System.out.println("流程实例的name = " + processInstance.getName());System.out.println("流程实例中的业务标识 = "+ processInstance.getBusinessKey());
}//用户节点需要进行审批了，此时需要获取BusinessKey进而获取到请假单信息
@Test
public void testGetBusinessKey(){//审批前，用户节点需要查看具体审批信息(请假单信息)//1.获取当前用户节点的待办任务ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();TaskService taskService = processEngine.getTaskService();Task task = taskService.createTaskQuery()//获取指定流程定义的指定用户节点的任务.processDefinitionKey("leaveProcess").taskAssignee("hkj").singleResult();//2.获取BusinessKey，//由于之前流程启动时，BusinessKey是绑定在流程实例对象中的，所有要获取该业务标识需要先获取到流程实例对象String processInstanceId = task.getProcessInstanceId();RuntimeService runtimeService = processEngine.getRuntimeService();ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();String businessKey = processInstance.getBusinessKey();//3.通过获取到的BusinessKey进而可以关联查询到请假单信息System.out.println("任务id = " + task.getId());System.out.println("任务名称 = " + task.getName());System.out.println("业务标识：" + businessKey);
}

流程挂起、激活

全部流程实例挂起:

流程定义挂起的同时，流程实例也一并挂起(新的流程不能发起了，正在运行的流程也不能继续往后执行)
流程定义挂起，但是流程实例不挂起(新的流程不能发起，但是正在运行的流程是可以往后流转的)

/*** 挂起流程定义*/
@Test
public void testSuspendProcessDefinition(){ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RepositoryService repositoryService = processEngine.getRepositoryService();//获取流程定义对象ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionKey("leaveProcess").singleResult();//查看当前流程定义是否挂起boolean suspended = processDefinition.isSuspended();System.out.println(processDefinition.isSuspended() ? "激活" : "挂起");//判断流程定义的状态if(suspended){//说明是挂起状态，需要把流程定义改为激活状态，如果参数为true，把该流程定义下的所有流程实例也一并激活repositoryService.activateProcessDefinitionByKey("leaveProcess",true, null);//说明是挂起状态，需要把流程定义改为激活状态，如果参数为false，流程实例不激活//repositoryService.activateProcessDefinitionByKey("leaveProcess",false, null);}else{//说明是激活状态，需要把流程定义改为挂起状态，如果参数为true，把该流程定义下的所有流程实例也一并挂起repositoryService.suspendProcessDefinitionByKey("leaveProcess",true,null); //说明是激活状态，需要把流程定义改为挂起状态，如果参数为false,流程实例不挂起//repositoryService.suspendProcessDefinitionByKey("leaveProcess",false,null);}
}

/**
* 指定taskID的任务负责人来执行处理完成任务*/
@Test
public void testCompleteTask(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//获取任务相关的serviceTaskService taskService = processEngine.getTaskService();//找到对应的任务，然后执行任务，让流程往后流转String taskID = "5002";taskService.complete(taskID);
}

单个流程实例挂起:

操作流程实例对象，针对单个流程执行挂起操作，某个流程实例挂起则此流程不再执行，执行该流程实例的当前任务将报异常，但是不影响其开启一个新的流程实例，且不会影响到其他流程实例

@Test
public void testProcessInstanceSuspend(){ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RuntimeService runtimeService = processEngine.getRuntimeService();String processInstanceId = "2501";ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();System.out.println("流程实例的挂起状态：" + processInstance.isSuspended());if(processInstance.isSuspended()){//挂起状态,把它给为激活状态runtimeService.activateProcessInstanceById(processInstanceId);}else{//激活状态，把它改为挂起状态runtimeService.suspendProcessInstanceById(processInstanceId);}
}/*** 指定taskID的任务负责人来执行处理完成任务*/
@Test
public void testCompleteTask(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//获取任务相关的serviceTaskService taskService = processEngine.getTaskService();//找到对应的任务，然后执行任务，让流程往后流转String taskID = "5002";taskService.complete(taskID);
}

任务UEL动态分配负责人

使用RuntimeService进行业务标识绑定

注：有1张核心表发生了改变(act_ru_task:存储当前用户节点信息，act_ru_identitylink:存储审批过的用户节点，act_run_execution:往表中存储businessKey和流程定义、实例等相关信息，act_hi_varinst:存储uel等变量信息和值)

/*** 部署业务流程，创建流程定义对象*/
@Test
public void textDeploy(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//流程部署涉及到对资源操作，使用RepositoryServiceRepositoryService repositoryService = processEngine.getRepositoryService();//加载流程文件,获取部署对象Deployment deployment = repositoryService.createDeployment().addClasspathResource("bpmn/leaveUEL.bpmn").name("请假流程").deploy();//获取部署流程的一些信息System.out.println("流程部署ID:"+deployment.getId());System.out.println("流程部署名称:"+deployment.getName());System.out.println("流程部署时间：" + deployment.getDeploymentTime());
}/*** 开启流程实例*/
@Test
public void testStartProcess(){ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RuntimeService runtimeService = processEngine.getRuntimeService();//启动流程之前必须明确的给具体变量进行赋值操作Map<String,Object> variables = new HashMap<>();variables.put("assignee0","hkj");variables.put("assignee1","yoona");//根据流程定义的key获取流程实例,这个key是在定义bpmn的时候设置的ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("leaveProcessUEL", variables);//获取流程实例的相关信息System.out.println("流程定义的id = " + processInstance.getProcessDefinitionId());System.out.println("流程实例的id = " + processInstance.getId());
}/*** 指定taskID的任务负责人来执行处理完成任务*/
@Test
public void testCompleteTask(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//获取任务相关的serviceTaskService taskService = processEngine.getTaskService();//找到对应的任务，然后执行任务，让流程往后流转String taskID = "2507";taskService.complete(taskID);
}

流程变量

如果UEL表达式中流程变量名不存在则报错。
如果如果UEL表达式都不符合条件,流程报错。
如果连接不设置条件/条件都满足,每个连线都会走.

/*** 部署业务流程，创建流程定义对象*/
@Test
public void textDeploy(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//流程部署涉及到对资源操作，使用RepositoryServiceRepositoryService repositoryService = processEngine.getRepositoryService();//加载流程文件,获取部署对象Deployment deployment = repositoryService.createDeployment().addClasspathResource("bpmn/leaveVar.bpmn").name("请假流程").deploy();//获取部署流程的一些信息System.out.println("流程部署ID:"+deployment.getId());System.out.println("流程部署名称:"+deployment.getName());System.out.println("流程部署时间：" + deployment.getDeploymentTime());
}/*** 开启流程实例*/
@Test
public void testStartProcess(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RuntimeService runtimeService = processEngine.getRuntimeService();Map<String,Object> variables = new HashMap<>();variables.put("day",5);//根据流程定义的key启动流程实例,这个key是在定义bpmn的时候设置的ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("leaveProcessVar", variables);//获取流程实例的相关信息System.out.println("流程定义的id = " + processInstance.getProcessDefinitionId());System.out.println("流程实例的id = " + processInstance.getId());
}/*** 指定taskID的任务负责人来执行处理完成任务*/
@Test
public void testCompleteTask(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//获取任务相关的serviceTaskService taskService = processEngine.getTaskService();//找到对应的任务，然后执行任务，让流程往后流转String taskID = "7506";taskService.complete(taskID);
}

任务候选人

查询自己的候选人任务
对任务进行认领（变成个人的待办任务）
对任务进行执行

如果任务被某一个候选人领取了，就变成了个人任务，就只能通过taskAssignee方法进行查询，因为这时候就不属于候选人的任务了，而是属于个人的任务，这时候就可以指定taskID的任务负责人来执行处理完成任务了

/*** 部署业务流程，创建流程定义对象*/
@Test
public void textDeploy(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//流程部署涉及到对资源操作，使用RepositoryServiceRepositoryService repositoryService = processEngine.getRepositoryService();//加载流程文件,获取部署对象Deployment deployment = repositoryService.createDeployment().addClasspathResource("bpmn/leaveCandidate.bpmn").name("请假流程").deploy();//获取部署流程的一些信息System.out.println("流程部署ID:"+deployment.getId());System.out.println("流程部署名称:"+deployment.getName());System.out.println("流程部署时间：" + deployment.getDeploymentTime());
}/*** 启动流程实例，创建流程实例对象*/
@Test
public void testStartProcess(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//启动流程引擎对象，让流程跑起来，使用RuntimeServiceRuntimeService runtimeService = processEngine.getRuntimeService();//根据业务流程定义的key启动流程实例,这个key是在定义bpmn的时候设置的ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("leaveProcessCandidate");//获取流程实例的相关信息System.out.println("流程定义的id = " + processInstance.getProcessDefinitionId());System.out.println("流程实例的id = " + processInstance.getId());System.out.println("流程实例的name = " + processInstance.getName());
}/*** 查询当前用户节点候选任务*/
@Test
public void testCreateTaskQuery(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//获取当前指定用户的审核待办任务集合TaskService taskService = processEngine.getTaskService();List<Task> tasks = taskService.createTaskQuery()//查询指定业务流程定义key的任务.processDefinitionKey("leaveProcessCandidate")//任务负责人.taskCandidateUser("lisa").list();if(tasks != null && tasks.size() > 0){for (Task task : tasks) {System.out.println("任务负责人id = " + task.getId());System.out.println("任务名称：" + task.getName());System.out.println("流程实例ID：" + task.getProcessInstanceId());}}
}/*** 领取候选人任务*/
@Test
public void testSelectCandidateTaskList(){String taskId = "2505";ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();TaskService taskService = processEngine.getTaskService();//指定yoona候选人领取任务taskService.claim(taskId,"yoona");
}/*** 指定taskID的任务负责人来执行处理完成任务*/
@Test
public void testCompleteTask(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//获取任务相关的serviceTaskService taskService = processEngine.getTaskService();//找到对应的任务，然后执行任务，让流程往后流转String taskID = "2505";taskService.complete(taskID);
}

网关

排他网关

排他网关只会选择一个为true的分支执行（即使有两个分支条件都为true，排他网关也只会选择一条分支去执行,选择序号小的路径执行）。

/*** 部署业务流程，创建流程定义对象*/
@Test
public void textDeploy(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//流程部署涉及到对资源操作，使用RepositoryServiceRepositoryService repositoryService = processEngine.getRepositoryService();//加载流程文件,获取部署对象Deployment deployment = repositoryService.createDeployment().addClasspathResource("bpmn/leaveEGateWay.bpmn").name("请假流程").deploy();//获取部署流程的一些信息System.out.println("流程部署ID:"+deployment.getId());System.out.println("流程部署名称:"+deployment.getName());System.out.println("流程部署时间：" + deployment.getDeploymentTime());
}/*** 开启流程实例*/
@Test
public void testStartProcess(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RuntimeService runtimeService = processEngine.getRuntimeService();Map<String,Object> variables = new HashMap<>();variables.put("day",5);//根据流程定义的key启动流程实例,这个key是在定义bpmn的时候设置的ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("leaveEGateWayProcess", variables);//获取流程实例的相关信息System.out.println("流程定义的id = " + processInstance.getProcessDefinitionId());System.out.println("流程实例的id = " + processInstance.getId());
}/*** 指定taskID的任务负责人来执行处理完成任务*/
@Test
public void testCompleteTask(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//获取任务相关的serviceTaskService taskService = processEngine.getTaskService();//找到对应的任务，然后执行任务，让流程往后流转String taskID = "2506";taskService.complete(taskID);
}

并行网关

并行网关(InclusiveGateway)允许将流程分成多条分支，也可以把多条分支汇聚到一起，只有项目经理和技术经理都审批完成任务通过了，才可以到达人事复批节点

/*** 部署业务流程，创建流程定义对象*/
@Test
public void textDeploy(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//流程部署涉及到对资源操作，使用RepositoryServiceRepositoryService repositoryService = processEngine.getRepositoryService();//加载流程文件,获取部署对象Deployment deployment = repositoryService.createDeployment().addClasspathResource("bpmn/leaveProcessP.bpmn").name("请假流程-并行网关").deploy();//获取部署流程的一些信息System.out.println("流程部署ID:"+deployment.getId());System.out.println("流程部署名称:"+deployment.getName());System.out.println("流程部署时间：" + deployment.getDeploymentTime());
}/*** 开启流程实例*/
@Test
public void testStartProcess(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RuntimeService runtimeService = processEngine.getRuntimeService();//根据流程定义的key启动流程实例,这个key是在定义bpmn的时候设置的ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("leaveProcessP");//获取流程实例的相关信息System.out.println("流程定义的id = " + processInstance.getProcessDefinitionId());System.out.println("流程实例的id = " + processInstance.getId());
}/*** 指定taskID的任务负责人来执行处理完成任务*/
@Test
public void testCompleteTask(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//获取任务相关的serviceTaskService taskService = processEngine.getTaskService();//找到对应的任务，然后执行任务，让流程往后流转String taskID = "2509";taskService.complete(taskID);
}

包含网关

包含网关可以看做是排他网关和并行网关的结合体

/*** 部署业务流程，创建流程定义对象*/
@Test
public void textDeploy(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//流程部署涉及到对资源操作，使用RepositoryServiceRepositoryService repositoryService = processEngine.getRepositoryService();//加载流程文件,获取部署对象Deployment deployment = repositoryService.createDeployment().addClasspathResource("bpmn/leaveLGateWay.bpmn").name("请假流程-并行网关").deploy();//获取部署流程的一些信息System.out.println("流程部署ID:"+deployment.getId());System.out.println("流程部署名称:"+deployment.getName());System.out.println("流程部署时间：" + deployment.getDeploymentTime());
}/*** 开启流程实例*/
@Test
public void testStartProcess(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RuntimeService runtimeService = processEngine.getRuntimeService();Map<String,Object> variables = new HashMap<>();variables.put("day",5);//根据流程定义的key启动流程实例,这个key是在定义bpmn的时候设置的ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("leaveLGateWay",variables);//获取流程实例的相关信息System.out.println("流程定义的id = " + processInstance.getProcessDefinitionId());System.out.println("流程实例的id = " + processInstance.getId());
}/*** 指定taskID的任务负责人来执行处理完成任务*/
@Test
public void testCompleteTask(){//创建流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();//获取任务相关的serviceTaskService taskService = processEngine.getTaskService();//找到对应的任务，然后执行任务，让流程往后流转String taskID = "5011";taskService.complete(taskID);
}