Activiti——流程控制RuntimeService API详解

叁歲伎倆 2023-10-15 16:58 7阅读 0赞

#### 目录 ####

*  Activiti流程控制
 *   *  1、流程实例与执行流
     *   *  1.1、流程实例与执行流概念
         *  1.2、流程实例和执行流对象(ProcessInstance与Execution)
     *  2、启动流程
     *   *  2.1、startProcessInstanceById方法
         *  2.2、startProcessInstanceByKey方法
         *  2.3、startProcessInstanceByMessage方法
     *  3、流程参数
     *   *  3.1、设置与查询流程参数
         *  3.2、流程参数的作用域
         *  3.3、其他设置参数的方法
     *  4、流程操作
     *   *  4.1、流程触发
         *  4.2、触发信号事件
         *  4.3、触发消息事件
         *  4.4、中断与激活流程
         *  4.5、删除流程
     *  5、流程数据查询
     *   *  5.1、执行流查询
         *  5.2、流程实例查询

## Activiti流程控制 ##

Activiti提供了流程运行时对流程进行控制的API,可以使用RuntimeService的方法对流程进行控制。RuntimeService也是Activiti提供的业务组件之一。TaskService主要用于任务管理，RuntimeService则主要用于管理流程在运行时产生的数据，以及提供对流程进行操作的API。其中流程运行时产生的数据包括流程参数、事件、流程实例及执行流等。流程的操作包括启动流程、流程前进等。

### 1、流程实例与执行流 ###

以普通的请假流程为例，假设现在有这样一个流程：员工发起请假流程，如果请假天数小于5天，先由部门经理审批，然后由人力专员审批；如果请假天数大于5天，就需要人力资源总监与公司的副总经理同时审批。对于请假天数不足5天的情况，可以设计一个只有两个用户任务节点的流程：对于请假天数大于5天的情况（需要同时审批），则会产生流程分支。请假天数小于5天的流程如图9-1所示，请假天数大于5天的流程如图9-2所示。

![在这里插入图片描述][8a3d118d108846fa924c75593dc18a5b.png]

![在这里插入图片描述][3801306433e34ffbb8941fd2fc4423a8.png]

#### 1.1、流程实例与执行流概念 ####

在Activiti中，启动了一个流程，会创建一个流程实例(ProcessInstance),每个流程实例至少会有一个执行流(Execution)。当流程实例没有流程分支时，一般情况下只会存在一个执行流：假设流程出现两个分支（如图9-2所示），此时Activiti将会有三个执行流，第一个为原来流程的主执行流，而其余两个为子执行流。实际上，如果不考虑Activiti的实现，从业务的角度看，流程实例的执行流分为两个执行流，此时整个流程中只两个执行流存在（图9-2中的分支)，子执行流只是对Activiti设计的一个描述。

#### 1.2、流程实例和执行流对象(ProcessInstance与Execution) ####

ProcessInstance是一个接口，一个ProcessInstance实例表示一个流程实例，ProcessInstance实际上是执行流(Execution)的子接口，流程实例也是一个执行流。ProcessInstance中有Execution没有的属性，例如流程定义和业务主键。当得到的是一个ProcessInstance实例时，就将其看作一个流程实例；当得到一个Execution实例时，它就是一个执行流。

流程实例与执行流的数据保存在执行表(ACT\_RU\_EXECUTION)中，对应的映射实体为ExecutionEntityImpl。ExecutionEntityImpl主要包括以下映射属性。

*  id:主键ID,对应ACT RU EXECUTION表的D。
 *  revision:该数据的修订版本号，对应REV字段。
 *  businessKey:流程实例的业务主键，只有ProcessInstance实例才有该值。
 *  parentld:父执行流的D,在没有流程分支的情况下，流程实例与执行流的父ID为同一条数据，如果出现新的执行流，那么将会设置该值，对应PARENT\_ID字段。
 *  processDefinitionId:流程定义ID,不管是流程实例数据还是执行流数据，该字段均会被设置为相应的流程定义ID,对应PROC\_DEF\_ID字段。
 *  superExecutionId::父执行流的D,如果该执行流是子流程的一部分，则该值不为null,对应SUPER\_EXEC字段。
 *  activityld:当前执行流的动作，一般为流程节点的名称，对应ACT\_ID字段。
 *  isActive:该执行流状态是否活跃，如果当前的执行流分为两个子执行流，则当前的执行流被标识为非活跃状态，而两个子执行流则为活跃状态，对应IS ACTIVITE字段。
 *  isConcurrent:执行流是否并行，对应IS CONCURRENT字段。
 *  isScope:是否在执行流范围内。
 *  isEventScope::是否在事件范围内。
 *  suspensionState:流程中断状态，1为活跃，2为中断。

### 2、启动流程 ###

RuntimeService中提供多个启动流程的方法，这些方法命名均为startProcessInstanceByXXX,其中“XXX”可以为流程定义(ProcessDefinition)D、流程定义的key(流程描述文件中process的id属性)和流程定义的message。根据流程定义ID启动流程的方法为startProcessInstanceByld,该方法存在多个同名的重载方法，可以按照实际情况来使用这些方法。类似地，根据流程定义的key和根据流程定义的message启动流程的方法，同样存在多个重载方法。下面将介绍如何使用这些方法启动流程。

#### 2.1、startProcessInstanceById方法 ####

根据流程定义ID启动流程，RuntimeService提供了四个重载的方法，使用这些方法，可以设置流程的业务主键、流程的启动参数等。调用这些方法，均会返回一个流程实例  
(ProcessInstance对象)，这些方法描述如下。

*  **startProcessInstanceById(String processDefinitionId)**:根据流程定义ID启动流程，在进  
    行流程部署时，可以得到一个Deployment的实例，根据Deployment实例的ID可以查询到ProcessDefinition的实例。
 *  **startProcessInstanceById(String processDefinitionId,Map<String,Object>variables)**:  
    一个startProcessInstanceByld方法一样，使用该方法可以为流程设置参数，第二个参数为Map。
 *  **startProcessInstanceById(String processDefinitionId,String businessKey)**:使用流程定义ID和业务主键启动流程，业务主键会被保存到执行表的BUSINESS KEY字段。
 *  **startProcessInstanceById(String processDefinitionId,String businessKey,Map<String,  
    Object>variables)**:与前一个startProcessInstanceByld方法类似，该方法既可以设置业务主键，也允许传入流程参数。

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    RuntimeService runtimeService = processEngine.getRuntimeService();
    Deployment deploy = repositoryService.createDeployment().addClasspathResource("demo9/startById.bpmn20.xml").deploy();
    //查找流程定义
    ProcessDefinition pd = repositoryService.createProcessDefinitionQuery().deploymentId(deploy.getId()).singleResult();
    //设置流程参数
    Map<String, Object> vars = new HashMap<String, Object>();
    vars.put("days", 5);
    //启动流程
    runtimeService.startProcessInstanceById(pd.getId());
    runtimeService.startProcessInstanceById(pd.getId(), vars);
    runtimeService.startProcessInstanceById(pd.getId(), "varcationRequest1");
    runtimeService.startProcessInstanceById(pd.getId(), "vacationRequest2", vars);
    //查询流程实例，结果为4
    long count = runtimeService.createProcessInstanceQuery().count();
    System.out.println("流程实例数量：" + count);

在代码中，定义了一个简单的请假流程，一个编写请假申请的UserTask(write Vacation)和一个进行请假审核的User Task(audit)。调用startProcessInstanceByld方法启动流程后，Activiti会在各个数据表中写入相应的流程数据，包括流程任务(Task)、流程参数和流程实例等数据。根据前面章节的讲述可以知道，流程任务数据保存在任务表中，流程参数数据保存在参数表中，因此在调用startProcessInstanceByld方法时传入的流程参数，同样会  
保存到参数表中。调用了startProcessInstanceById方法后，打开执行表，可以看到产生的流程实例数据如图所示。

由图可以看到，执行表中有4条数据，即此时有4个流程实例。除了4条主执行流数据外，还会产生4条子执行流数据，这4条数据的parentld为对应的流程实例id,即主执行流id。  
![在这里插入图片描述][2168665464224529960e0c1ab3e116f4.png]

#### 2.2、startProcessInstanceByKey方法 ####

除了可以使用流程定义的D来启动流程外，还可以根据流程描述文件中定义的process节点的id属性来启动流程，注意方法名的key不要与流程的BUSINESS KEY字段混淆，流  
程实例表的BUSINESS KEY字段值由启动方法传入。使用startProcessInstanceByKey方法，只需要知道process节点的id属性，而不需要到数据库中重新查找流程定义数据。与  
startProcessInstanceById方法类似，在RuntimeService中，startProcessInstanceByKey方法同样存在多个同名的重载方法。

*  **startProcessInstanceByKey(String processDefinitionKey)**:根据流程文件定义的process  
    节点的id启动流程。
 *  **startProcessInstanceByKey(String processDefinitionKey,Map<String,Object variables)**:  
    与前一个启动流程方法一样，在该方法中可以传入流程参数。
 *  **startProcessInstanceByKey(String processDefinitionKey,String businessKey)**:与第一个启  
    动流程的方法一样，该方法可以传入流程业务主键。
 *  **startProcessInstanceByKey(String processDefinitionKey,String businessKey,Map<String,  
    Object>variables)**:与前一个方法类似，该方法除了可以传入流程业务主键外，还可以传入流程参数。

调用了4个startProcessInstanceByKey方法启动流程，最后在进行流程实例查询时，结果同样为4。由于只需要根据流程d来启动，因此不需要查询流程定义。需要注意的是，与使用startProcessInstanceByld方法时一样，每个流程定义中只允许存在一个流程业务主键。

#### 2.3、startProcessInstanceByMessage方法 ####

在实际应用中，可能会出现以下场景：一个订单流程，当接收到相应订单信息后，自动启动该流程。解决这种需求，可以使用Activiti的消息事件，在流程定义的开始事件中，添加消息事件定义，当流程接收到某个消息时，就会启动流程。

<message id="startMsg" name="startMsg"></message>
    
    <process id="saleOrder" name="saleOrder">
    	<startEvent id="start" >
    		
    		<messageEventDefinition messageRef="startMsg"></messageEventDefinition >
    	</startEvent>
    	<sequenceFlow sourceRef="start" targetRef="confirmOrder" />
    	<userTask id="confirmOrder"></userTask>		
    	<sequenceFlow sourceRef="confirmOrder" targetRef="sendGoods" />		
    	<userTask id="sendGoods"></userTask>
    	<sequenceFlow sourceRef="sendGoods" targetRef="end" />
    	<endEvent id="end" />
    </process>

代码定义了一个订单流程，注意其中的粗体字代码，其在流程描述文件中定义了一个message节点，id为startMsg,再为开始事件添加消息事件定义，并且该事件定义引用了  
代码中定义的message。Activiti在加载流程描述文件时，如果发现开始事件中存在消息事件，则会向事件表(ACT RU\_EVENT\_SUBSCR)中写入事件描述数据。  
![在这里插入图片描述][fffa8d60f9c0485082eb56f2a9f1032b.png]

定义了流程后，此时可以使用  
startProcessInstanceByMessage方法来启动流程。RuntimeService中定义了几个同名的  
startProcessInstanceByMessage重载方法，这些方法描述如下。

*  **startProcessInstanceByMessage(String messageName)**:根据消息名称启动流程。
 *  **startProcessInstanceByMessage(String messageName,Map<String,Object process Variables)**:与前一个方法类似，使用该方法可以传入流程参数。
 *  **startProcessInstanceByMessage(String messageName,.String businessKey)**:根据消息名称  
    启动流程，可以传入业务主键。
 *  **startProcessInstanceByMessage(String messageName,String businessKey,Map<String,  
    Object>process Variables)**:与前一个方法类似，除可以传入业务主键外，还可以传入流程参数。

在此需要注意的是，流程名称并不是message节点的id属性，而是name属性，而消息事件定义(messageEventDefinition节点)的messageRef属性引用的是message节点的id属性。

### 3、流程参数 ###

Activiti中专门使用ACT\_RU\_VARIABLE表来保存流程中的参数，这些参数均有自己的生命周期和作用域，RuntimeService也提供了设置流程参数的方法：setVariables和set VariablesLocal。

#### 3.1、设置与查询流程参数 ####

RuntimeService的setVariable和setVariableLocal方法，允许传入基本类型参数，也允许传入序列化对象，它们的基本使用方法与TaskService的设置参数的方法类似，不同的是，对于RuntimeService中的设置参数的方法，需要传入执行流的ID。同样，查询流程参数也需要提供执行流的ID与参数名称。

#### 3.2、流程参数的作用域 ####

当使用TaskService的set VariableLocal方法时，流程参数只作用于当前的任务节点，RuntimeService中的setVariableLocal方法与之类似，使用  
setVariableLocal方法时，流程参数只作用于设置的执行流，一旦该执行流结束，该参数将失效。

使用setVariable方法设置的参数，使用get VariableLocal方法不能获取，而使用set VariableLocal设置的参数，则可以使用getVariable方法获取。

![在这里插入图片描述][fab14c09972442509a6a83402630c13f.png]

如图所示，当流程启动时，将会执行流程分支，分别执行“Manager Audit”和“HR Audit”任务。此时对Activiti来说，将会产生两个子执行流，当两个任务都完成后，流程将会执行“End Task”任务。本例将会在执行“Manager Audit”和“HR Audit”任务节点时，分别为两个执行流设置不同的参数，完成任务后（流程向前进行），再查找设置的参数。

ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = engine.getRepositoryService();
    RuntimeService runtimeService = engine.getRuntimeService();
    TaskService taskService = engine.getTaskService();
    // 部署流程描述文件
    repositoryService.createDeployment().addClasspathResource("demo9/localVariable.bpmn20.xml").deploy();
    //启动流程
    ProcessInstance pi = runtimeService.startProcessInstanceByKey("vacationRequest");
    //查询全部的任务，得到相应的执行流，设置不同的参数
    List<Task> tasks = taskService.createTaskQuery().processInstanceId(pi.getId()).list();
    for (Task task : tasks) {
        
        Execution exe = runtimeService.createExecutionQuery().executionId(task.getExecutionId()).singleResult();
        if ("Manager Audit".equals(task.getName())) {
        
            //经理审核节点，设置Local参数
            runtimeService.setVariableLocal(exe.getId(), "managerVar", "manager var");
        } else {
        
            //HR审核节点，设置全局参数
            runtimeService.setVariable(exe.getId(), "hrVar", "hr var");
        }
    }
    //两个执行流时输出参数
    for (Task task : tasks) {
        
        Execution exe = runtimeService.createExecutionQuery().executionId(task.getExecutionId()).singleResult();
        if ("Manager Audit".equals(task.getName())) {
        
            System.out.println("使用getVariableLocal方法获取经理参数：" +
                    runtimeService.getVariableLocal(exe.getId(), "managerVar"));
            System.out.println("使用getVariable方法获取经理参数：" +
                    runtimeService.getVariableLocal(exe.getId(), "managerVar"));
        } else {
        
            System.out.println("使用getVariableLocal方法获取HR参数：" +
                    runtimeService.getVariableLocal(exe.getId(), "hrVar"));
            System.out.println("使用getVariable方法获取HR参数：" +
                    runtimeService.getVariable(exe.getId(), "hrVar"));
        }
    }
    //完成任务
    for (Task task : tasks) {
        
        taskService.complete(task.getId());
    }
    System.out.println("========  完成流程分支后     ========");
    //重新查找流程任务
    tasks = taskService.createTaskQuery().processInstanceId(pi.getId()).list();
    for (Task task : tasks) {
        
        System.out.println("当前流程节点：" + task.getName());
        Execution exe = runtimeService.createExecutionQuery()
                .executionId(task.getExecutionId()).singleResult();
        System.out.println("经理参数：" + runtimeService.getVariable(exe.getId(), "managerVar"));
        System.out.println("HR参数：" + runtimeService.getVariable(exe.getId(), "hrVar"));
    }

使用getVariableLocal方法获取经理参数：manager var
    使用getVariable方法获取经理参数：manager var
    使用getVariableLocal方法获取HR参数：null
    使用getVariable方法获取HR参数：hr var
    ========  完成流程分支后     ========
    当前流程节点：End Task
    经理参数：null
    HR参数：hr var

根据输出的结果可以看出，对于使用setVariableLocal方法设置的参数，只要该执行流存在，那么不管使用getVariable方法还是使用get VariableLocal方法均可以获得参数。而对于使用setVariable方法设置的参数，只能通过getVariable方法取得。一个执行流结束后，将不能获取使用setVariableLocal方法设置的参数，而通过setVariable方法设置的参数，不管当前执行流是否结束，只要流程尚未结束，仍然可以通过getVariable方法获取该参数。因此，  
setVariableLocal方法设置的参数的作用域仅仅局限于当前设置的执行流中，一旦该执行流结束，该参数会失效，而使用setVariable方法设置的参数，可以作用于整个流程。

#### 3.3、其他设置参数的方法 ####

与TaskService类似，RuntimeService也提供了可以设置多个参数的方法：setVariables和setVariablesLocal方法，调用这两个方法时，只需要将参数封装到一个Map对象中即可。这两个方法的使用在此不再赘述。需要注意的是，如果设置的参数类型不是基本数据类型，就会将其进行序列化并转换为byte数组，保存到资源表(ACT\_GE\_BYTEARRAY)中。

### 4、流程操作 ###

#### 4.1、流程触发 ####

在工作流程中，对于用户任务，可以使用TaskService的complete方法将当前流程节点的任务完成，完成后流程就会向前进行，而对于receiveTask等流程节点，则可以使用trigger方法将其触发，使流程往前进行。RuntimeService的trigger方法描述如下。

*  **trigger(String executionId)**:触发流程中的等待节点，让流程往下执行。
 *  **trigger((String executionld,Map<String,Object>processVariables)**:与前面的trigger方法类似，可以设置流程参数。
 *  **trigger(String executionId,Map<String,Object> processVariables,Map<String.Object> transientVariables)**:与前面的trigger方法类似，可以设置临时参数。

这里的第二个trigger方法允许传入多个流程参数，  
需要注意的是，此处传入的参数将作用于整个流程，而不仅仅局限于某个执行流，第三个tigger方法允许传入临时参数。

![在这里插入图片描述][49d1fa3a8536469e8c9c475650e544d7.png]

当前流程节点为： receivetask1
    当前流程节点为： usertask1

#### 4.2、触发信号事件 ####

事件节点是在流程中记录事件发生的流程元素，BPMN2.0规范中主要有两种类型的事件：捕获(Catching)事件和抛出(Throwing)事件。如果在一个流程中定义了Catching事件节点，则流程执行到该节点时，会一直等待触发的信号，直到接收到相应的信号后，流程才继续向前执行，此为Catching事件。如果在一个流程中定义了Throwing事件，则当流程执行到该节点时，该事件节点会自动往下执行，并不需要任何的信号指示，此为Throwing事件。在Catching事件中，如果希望流程继续往下执行，可以使用RuntimeService的signalEventReceived方法抛出信号，那么Catching事件节点就会捕获到相应的信号，让流程继续往下执行。当流程到达信号Catching事件时，事件表(ACT RU\_EVENT\_SUBSCR)中会产生相应的事件描述数据，  
对应的EVENT\_TYPE字段值为signal。

![在这里插入图片描述][22028a2035884801b873ff985b5e3763.png]

如图所示，当流程启动后，会到达“First Task”节点，流程继续向下执行，则会到达定义的Catching事件:

当前节点：usertask1
    调用trigger方法后当前节点：signalCatchEvent
    触发Catch事件后，执行流数量：0

#### 4.3、触发消息事件 ####

Activiti中除了提供了信号事件节点外，还提供了消息事件节点。可以使用messageEventDefinition元素定义一个消息事件，该元素可以被定义在startEvent和intermediateCatchEvent元素中。如果在startEvent中定义了消息事件，就可以使用RuntimeService的startProcess-  
InstanceByMessage方法来启动流程；如果在intermediateCatchEvent元素下定义了消息事件，那么就意味着该消息事件是一个Catching事件。换言之，当执行流执行到该节点时，会一直等待触发的消息，直到收到触发的消息后，执行流才会继续往下进行。流程到达消息Catching事件时，会在事件表中产生事件描述数据，对应的EVENT\_TYPE字段值为message.

当执行流遇到消息事件时，可以使用RuntimService的messageEventReceived方法向其发送信号，通知流程引擎该事件被接收。

![在这里插入图片描述][82b8f8e4db9d4826b0581a43a575f81c.png]

// 创建流程引擎
    ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
    // 得到流程存储服务实例
    RepositoryService repositoryService = engine.getRepositoryService();
    // 得到运行时服务组件
    RuntimeService runtimeService = engine.getRuntimeService();
    // 部署流程描述文件
    repositoryService.createDeployment()
    		.addClasspathResource("bpmn/MessageEvent.bpmn").deploy();
    // 开始流流程
    runtimeService.startProcessInstanceByKey("testProcess");
    // 查询当前节点
    Execution exe = runtimeService.createExecutionQuery()
    		.activityId("messageintermediatecatchevent1").singleResult();
    System.out.println("当前流程节点：" + exe.getActivityId());
    // 触发消息事件
    runtimeService.messageEventReceived("testMsg", exe.getId());
    // 查询当前事件
    exe = runtimeService.createExecutionQuery().activityId("usertask1")
    		.singleResult();
    System.out.println("当前流程节点：" + exe.getActivityId());

当前流程节点：messageintermediatecatchevent1
    当前流程节点：usertask1

#### 4.4、中断与激活流程 ####

由前面的讲述可知，流程表使用SUSPENSION\_STATE字段来保存流程的中断状态，若该字段值为1，则表示该流程为活跃状态；如果值为2，则表示该流程为中断状态。  
RuntimeService中提供了中断流程(suspendProcessInstanceByld)和激活流程(activateProcessInstanceById)的方法，在调用这两个方法时，需要提供流程实例的ID。

#### 4.5、删除流程 ####

删除运行时的流程，可以使用RuntimeService的deleteProcessInstance(String processInstanceld,  
String deleteReason)方法，调用该方法时只需要提供流程实例的ID和删除原因字符串即可。流程实例被删除后，相关的数据将会从原来运行时的表中被删除，将这部分数据存放到历史表中，其中包括流程实例、流程任务和流程节点等数据。

启动时流程实例数量：3
    删除后流程实例数量：2

### 5、流程数据查询 ###

经过操作后，流程中也会产生相关的数据，Activiti为流程实例和执行流提供了相应的Query查询象.RuntimeService提供了创建这些查询对象的方法，得到相应的Query对象后，可以使用其提供的设置查询条件的方法，最后使用list、singleResult等方法返回查询结果，也可以使用orderByXXX方法对查询结果进行排序。

#### 5.1、执行流查询 ####

使用RuntimeService的createExecutionQuery方法可以得到一个ExecutionQuery对象，使用该对象可以根据执行流的相关数据查询执行流，这些数据包括执行流的参数、执行流的活动状态、执行流信号事件和执行流消息事件等。

在图中定义了一个含有信号事件、消息事件的流程。下面将使用该流程作为例子，调用ExecutionQuery的几个主要查询方法：

ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = engine.getRepositoryService();
    RuntimeService runtimeService = engine.getRuntimeService();
    repositoryService.createDeployment().addClasspathResource("demo9/ExecutionQuery.bpmn").deploy();
    //设置参数
    Map<String, Object> vars1 = new HashMap<String, Object>();
    vars1.put("days", 5);
    Map<String, Object> vars2 = new HashMap<String, Object>();
    vars2.put("days", 6);
    Map<String, Object> vars3 = new HashMap<String, Object>();
    vars3.put("days", 7);
    vars3.put("name", "crazyit");
    // 开始流流程
    ProcessInstance pi1 = runtimeService.startProcessInstanceByKey("testProcess",
            "businessKey1", vars1);
    ProcessInstance pi2 = runtimeService.startProcessInstanceByKey("testProcess",
            "businessKey2", vars2);
    ProcessInstance pi3 = runtimeService.startProcessInstanceByKey("testProcess",
            "businessKey3", vars3);
    // 使用执行流查询方法
    List<Execution> exes = runtimeService.createExecutionQuery()
            .processDefinitionKey("testProcess").list();
    System.out.println("使用processDefinitionKey方法查询执行流：" + exes.size());
    exes = runtimeService.createExecutionQuery()
            .processInstanceBusinessKey("businessKey1").list();
    System.out.println("使用processInstanceBusinessKey方法查询执行流：" + exes.size());
    exes = runtimeService.createExecutionQuery()
            .messageEventSubscriptionName("messageName").list();
    System.out.println("使用messageEventSubscriptionName方法查询执行流：" + exes.size());
    // 根据节点id属性查询当前的执行流
    Execution exe = runtimeService.createExecutionQuery()
            .activityId("messageintermediatecatchevent1")
            .processInstanceId(pi1.getId()).singleResult();
    System.out.println("使用activityId和processInstanceId方法查询执行流，得到执行ID：" + exe.getId());
    //让流程往下执行
    runtimeService.messageEventReceived("messageName", exe.getId());
    exes = runtimeService.createExecutionQuery().signalEventSubscriptionName("signalName").list();
    System.out.println("使用signalEventSubscriptionName方法查询执行流：" + exes.size());
    // 根据参数查询执行流
    exes = runtimeService.createExecutionQuery().variableValueEquals("name", "crazyit").list();
    System.out.println("使用variableValueEquals方法查询执行流：" + exes.size());
    exes = runtimeService.createExecutionQuery().variableValueGreaterThan("days", 5).list();
    System.out.println("使用variableValueGreaterThan方法查询执行流：" + exes.size());
    exes = runtimeService.createExecutionQuery().variableValueGreaterThanOrEqual("days", 5).list();
    System.out.println("使用variableValueGreaterThanOrEqual方法查询执行流：" + exes.size());
    exes = runtimeService.createExecutionQuery().variableValueLessThan("days", 6).list();
    System.out.println("使用variableValueLessThan方法查询执行流：" + exes.size());
    exes = runtimeService.createExecutionQuery().variableValueLessThanOrEqual("days", 6).list();
    System.out.println("使用variableValueLessThanOrEqual方法查询执行流：" + exes.size());
    exes = runtimeService.createExecutionQuery().variableValueLike("name", "%crazy%").list();
    System.out.println("使用variableValueLike方法查询执行流：" + exes.size());
    exes = runtimeService.createExecutionQuery().variableValueNotEquals("days", 8).list();
    System.out.println("使用variableValueNotEquals方法查询执行流：" + exes.size());

使用processDefinitionKey方法查询执行流：6
    使用processInstanceBusinessKey方法查询执行流：1
    使用messageEventSubscriptionName方法查询执行流：3
    使用activityId和processInstanceId方法查询执行流，得到执行ID：10007
    使用signalEventSubscriptionName方法查询执行流：1
    使用variableValueEquals方法查询执行流：1
    使用variableValueGreaterThan方法查询执行流：2
    使用variableValueGreaterThanOrEqual方法查询执行流：3
    使用variableValueLessThan方法查询执行流：1
    使用variableValueLessThanOrEqual方法查询执行流：2
    使用variableValueLike方法查询执行流：1
    使用variableValueNotEquals方法查询执行流：3

#### 5.2、流程实例查询 ####

与执行流类似，可以使用RuntimeService中的createProcessInstanceQuery方法获取  
ProcessInstanceQuery实例，ProcessInstanceQuery提供的设置查询条件的方法与ExecutionQuery提供的类似。

使用processDefinitionKey方法查询流程实例：3
    使用active方法查询流程实例：2
    使用processInstanceBusinessKey方法查询流程实例：1
    使用processInstanceIds方法查询流程实例：2

[8a3d118d108846fa924c75593dc18a5b.png]: https://img-blog.csdnimg.cn/8a3d118d108846fa924c75593dc18a5b.png
[3801306433e34ffbb8941fd2fc4423a8.png]: https://img-blog.csdnimg.cn/3801306433e34ffbb8941fd2fc4423a8.png
[2168665464224529960e0c1ab3e116f4.png]: https://img-blog.csdnimg.cn/2168665464224529960e0c1ab3e116f4.png
[fffa8d60f9c0485082eb56f2a9f1032b.png]: https://img-blog.csdnimg.cn/fffa8d60f9c0485082eb56f2a9f1032b.png
[fab14c09972442509a6a83402630c13f.png]: https://img-blog.csdnimg.cn/fab14c09972442509a6a83402630c13f.png
[49d1fa3a8536469e8c9c475650e544d7.png]: https://img-blog.csdnimg.cn/49d1fa3a8536469e8c9c475650e544d7.png
[22028a2035884801b873ff985b5e3763.png]: https://img-blog.csdnimg.cn/22028a2035884801b873ff985b5e3763.png
[82b8f8e4db9d4826b0581a43a575f81c.png]: https://img-blog.csdnimg.cn/82b8f8e4db9d4826b0581a43a575f81c.png