工作流系统化思考（以acttiviti为例）

一、工作流的概念

1、基本理解

工作流(Workflow)，就是“业务过程的部分或整体在计算机应用环境下的自动化”，它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息或任务的过程自动进行，从而实现某个预期的业务目标，或者促使此目标的实现”。

工作流管理系统(Workflow Management System, WfMS)是一个软件系统，它完成工作量的定义和管理，并按照在系统中预先定义好的工作流规则进行工作流实例的执行。工作流管理系统不是企业的业务系统，而是为企业的业务系统的运行提供了一个软件的支撑环境。

工作流管理系统的目标：管理工作的流程以确保工作在正确的时间被期望的人员所执行——在自动化进行的业务过程中插入人工的执行和干预。审批和退回。

2、工作流引擎

ProcessEngine对象，这是Activiti工作的核心。负责生成流程运行时的各种实例及数据、监控和管理流程的运行。

3、BPMN

业务流程建模与标注（Business Process Model and Notation，BPMN) ，描述流程的基本符号，包括这些图元如何组合成一个业务流程图（Business Process Diagram）

4、流程数据库

Activiti的后台是有数据库的支持，所有的表都以ACT_开头。第二部分是表示表的用途的两个字母标识

资源库流程规则表：

act_re_deployment 部署信息表

act_re_model 流程设计模型部署表

act_re_procdef 流程定义数据表

运行时数据库表：

act_ru_execution 运行时流程执行实例表

act_ru_identitylink 运行时流程人员表，主要存储任务节点与参与者的相关信息

act_ru_task 运行时任务节点表

act_ru_variable 运行时流程变量数据表

历史数据库表：

act_hi_actinst 历史节点表

act_hi_attachment 历史附件表

act_hi_comment 历史意见表

act_hi_identitylink 历史流程人员表

act_hi_detail 历史详情表，提供历史变量的查询

act_hi_procinst 历史流程实例表

act_hi_taskinst 历史任务实例表

act_hi_varinst 历史变量表

组织机构表：

act_id_group 用户组信息表

act_id_info 用户扩展信息表

act_id_membership 用户与用户组对应信息表

act_id_user 用户信息表

通用数据表：

act_ge_bytearray 二进制数据表

act_ge_property 属性数据表存储整个流程引擎级别的数据,初始化表结构时，会默认插入三条记录

5、activity.cfg.xml (activiti的配置文件)

Activiti核心配置文件，配置流程引擎创建工具的基本参数和数据库连接池参数。

定义数据库配置参数

jdbcUrl: 数据库的JDBC URL。

jdbcDriver: 对应不同数据库类型的驱动。

jdbcUsername: 连接数据库的用户名。

jdbcPassword: 连接数据库的密码。

基于JDBC参数配置的数据库连接会使用默认的MyBatis连接池。下面的参数可以用来配置连接池（来自MyBatis参数）：

jdbcMaxActiveConnections: 连接池中处于被使用状态的连接的最大值。默认为10。

jdbcMaxIdleConnections: 连接池中处于空闲状态的连接的最大值。

jdbcMaxCheckoutTime: 连接被取出使用的最长时间，超过时间会被强制回收。默认为20000（20秒）。

jdbcMaxWaitTime: 这是一个底层配置，让连接池可以在长时间无法获得连接时，打印一条日志，并重新尝试获取一个连接。（避免因为错误配置导致沉默的操作失败）。默认为20000（20秒）。

一个最基本的 activiti.cfg.xml 代码。

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-2.5.xsd

http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

<!--

/**

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";如果表不存在，自动创建表

processEngineConfiguration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);

-->

</bean>

</beans>

6、安装 eclipse 插件

一般采用离线安装的形式。

二、核心 API

1、ProcessEngine

在 Activiti 中最核心的类，其他的类都是由他而来的。

ProcessEngine processEngine = ProcessEngine.getDefaultProcessEngine( )

调用ProcessEngines的getDefaultProceeEngine方法时会自动加载classpath下名为activiti.cfg.xml文件。

RepositoryService repositoryService = processEngine.getRepositoryService

RuntimeService RuntimeService =processEngine.getRuntimeService();

各个 service 的作用

RepositoryService是Activiti的仓库服务类。所谓的仓库指流程定义文档的两个文件：bpmn文件和流程图片。

RuntimeService是activiti的流程执行服务类。可以从这个服务类中获取很多关于流程执行相关的信息。

TaskService是activiti的任务服务类。可以从这个类中获取任务的信息。

HistoryService是activiti的查询历史信息的类。在一个流程执行完成后，这个对象为我们提供查询历史信息。

ProcessDefinition流程定义类。可以从这里获得资源文件等。

ProcessInstance代表流程定义的执行实例。

如范冰冰请了一天的假，她就必须发出一个流程实例的申请。一个流程实例包括了所有的运行节点。我们可以利用这个对象来了解当前流程实例的进度等信息。流程实例就表示一个流程从开始到结束的最大的流程分支，即一个流程中流程实例只有一个。

Execution

Activiti用这个对象去描述流程执行的每一个节点。在没有并发的情况下，Execution就是同ProcessInstance。流程按照流程定义的规则执行一次的过程，就可以表示执行对象Execution。

wire money(汇钱)和archive(存档)是并发执行的。这个时候，总线路代表ProcessInstance，而分线路中每个活动代表Execution。

总结：

一个流程中，执行对象可以存在多个，但是流程实例只能有一个。当流程按照规则只执行一次的时候，那么流程实例就是执行对象。

三、HelloWorld 程序

1、使用代码建立23张数据表

注意要连接好数据库，方式二的 activiti.cfg.xml 文件见上面

package com.meizi.test;

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.ProcessEngineConfiguration;

import org.junit.Test;

public class TestActiviti {

/**方式一、使用代码创建工作流需要的23张表*/

@Test

public void createTable(){

ProcessEngineConfiguration processEngineConfiguration = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();

//连接数据库的配置

processEngineConfiguration.setJdbcDriver("com.mysql.jdbc.Driver");

processEngineConfiguration.setJdbcUrl("jdbc:mysql://localhost:3306/flow");

processEngineConfiguration.setJdbcUsername("root");

processEngineConfiguration.setJdbcPassword("123");

/**

public static final String DB_SCHEMA_UPDATE_TRUE = "true";如果表不存在，自动创建表

processEngineConfiguration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);

//工作流的核心对象，ProcessEnginee对象

ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();

System.out.println("processEngine:"+processEngine);

}

/**方式二、使用配置文件创建工作流需要的23张表*/

@Test

public void createTable_2(){

ProcessEngine processEngine = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml") //

.buildProcessEngine();

System.out.println("processEngine:"+processEngine);

}

以后直接这段代码，只要把配置文件放好，直接就可以自动生成23张表。

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd

http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

<!--

/**

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";如果表不存在，自动创建表

processEngineConfiguration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);

-->

</bean>

</beans>

注意这里，一定要把数据库配合适了，而且 ?useUnicode=true&characterEncoding=utf8

2、部署流程定义

每一次部署，都可以在 act_re_deployment中查找一个部署信息，在 act_ge_bytearray 中看见 .bpmn 和 .bnp 的文件。这里使用RepositoryService部署流程定义

addClasspathResource表示从类路径下加载资源文件，一次只能加载一个文件

/**部署流程定义*/

@Test

public void deploymentProcessDefinition(){

Deployment deployment = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service

.createDeployment()//创建一个部署对象

.name("helloworld入门程序")//添加部署的名称

.addClasspathResource("diagrams/helloworld.bpmn")//从classpath的资源中加载，一次只能加载一个文件

.addClasspathResource("diagrams/helloworld.png")//从classpath的资源中加载，一次只能加载一个文件

.deploy();//完成部署

System.out.println("部署ID："+deployment.getId());//1

System.out.println("部署名称："+deployment.getName());//helloworld入门程序

}

3、启动流程实例

启动流程实例后在 act_ru_execution 中看到这个流程实例。这里使用RuntimeService启动流程实例

/**启动流程实例*/

@Test

public void startProcessInstance(){

//流程定义的key

String processDefinitionKey = "helloworld";

ProcessInstance pi = processEngine.getRuntimeService()//与正在执行的流程实例和执行对象相关的Service

.startProcessInstanceByKey(processDefinitionKey);//使用流程定义的key启动流程实例，key对应helloworld.bpmn文件中id的属性值，使用key值启动，默认是按照最新版本的流程定义启动

System.out.println("流程实例ID:"+pi.getId());//流程实例ID 101

System.out.println("流程定义ID:"+pi.getProcessDefinitionId());//流程定义ID helloworld:1:4

}

注意每一次新的发布，流程 ID 就要考虑是不是还是这个。

4、查询当前的个人任务

在 act_ru_task 中看到当前的任务状态。这里使用TaskService完成任务的查询

/**查询当前人的个人任务*/

@Test

public void findMyPersonalTask(){

String assignee = "李思思";

List<Task> list = processEngine.getTaskService()//与正在执行的任务管理相关的Service

.createTaskQuery()//创建任务查询对象

.taskAssignee(assignee)//指定个人任务查询，指定办理人

.list();

if(list!=null && list.size()>0){

for(Task task:list){

System.out.println("任务ID:"+task.getId());

System.out.println("任务名称:"+task.getName());

System.out.println("任务的创建时间:"+task.getCreateTime());

System.out.println("任务的办理人:"+task.getAssignee());

System.out.println("流程实例ID："+task.getProcessInstanceId());

System.out.println("执行对象ID:"+task.getExecutionId());

System.out.println("流程定义ID:"+task.getProcessDefinitionId());

System.out.println("########################################################");

}

5、完成我的任务

这里使用TaskService完成任务的办理,此时任务已经提交了，代办任务到分管领导陈冠希哪儿去了（可以把上面4的李思思改成陈冠希查看便知道）

/**完成我的任务*/

@Test

public void completeMyPersonalTask(){

//任务ID

String taskId = "204";

processEngine.getTaskService()//与正在执行的任务管理相关的Service

.complete(taskId);

System.out.println("完成任务：任务ID："+taskId);

}

总结：查看数据库表的时候，很多都没有 end_time ，也就是上级正在代办，懂了没？

四、BPMN 文件

BPMN 2.0根节点是definitions节点。这个元素中，可以定义多个流程定义（不过我们建议每个文件只包含一个流程定义，可以简化开发过程中的维护难度）。一个空的流程定义看起来像下面这样。

注意，definitions元素最少也要包含xmlns 和 targetNamespace的声明。 targetNamespace可以是任意值，它用来对流程实例进行分类。

<?xml version="1.0" encoding="UTF-8"?>

</process>

<bpmndi:BPMNDiagram id="BPMNDiagram_helloworld">

<bpmndi:BPMNPlane bpmnElement="helloworld" id="BPMNPlane_helloworld">

<bpmndi:BPMNShape bpmnElement="startevent1" id="BPMNShape_startevent1">

<omgdc:Bounds height="35.0" width="35.0" x="60.0" y="20.0"></omgdc:Bounds>

</bpmndi:BPMNShape>

<bpmndi:BPMNShape bpmnElement="endevent1" id="BPMNShape_endevent1">

<omgdc:Bounds height="35.0" width="35.0" x="305.0" y="340.0"></omgdc:Bounds>

</bpmndi:BPMNShape>

<bpmndi:BPMNShape bpmnElement="usertask1" id="BPMNShape_usertask1">

<omgdc:Bounds height="55.0" width="105.0" x="140.0" y="70.0"></omgdc:Bounds>

</bpmndi:BPMNShape>

<bpmndi:BPMNShape bpmnElement="usertask2" id="BPMNShape_usertask2">

<omgdc:Bounds height="55.0" width="105.0" x="305.0" y="70.0"></omgdc:Bounds>

</bpmndi:BPMNShape>

<bpmndi:BPMNShape bpmnElement="usertask3" id="BPMNShape_usertask3">

<omgdc:Bounds height="55.0" width="105.0" x="403.0" y="170.0"></omgdc:Bounds>

</bpmndi:BPMNShape>

<bpmndi:BPMNEdge bpmnElement="flow1" id="BPMNEdge_flow1">

<omgdi:waypoint x="77.0" y="55.0"></omgdi:waypoint>

<omgdi:waypoint x="192.0" y="70.0"></omgdi:waypoint>

</bpmndi:BPMNEdge>

<bpmndi:BPMNEdge bpmnElement="flow2" id="BPMNEdge_flow2">

<omgdi:waypoint x="245.0" y="97.0"></omgdi:waypoint>

<omgdi:waypoint x="305.0" y="97.0"></omgdi:waypoint>

</bpmndi:BPMNEdge>

<bpmndi:BPMNEdge bpmnElement="flow3" id="BPMNEdge_flow3">

<omgdi:waypoint x="357.0" y="125.0"></omgdi:waypoint>

<omgdi:waypoint x="455.0" y="170.0"></omgdi:waypoint>

</bpmndi:BPMNEdge>

<bpmndi:BPMNEdge bpmnElement="flow4" id="BPMNEdge_flow4">

<omgdi:waypoint x="455.0" y="225.0"></omgdi:waypoint>

<omgdi:waypoint x="322.0" y="340.0"></omgdi:waypoint>

</bpmndi:BPMNEdge>

</bpmndi:BPMNPlane>

</bpmndi:BPMNDiagram>

</definitions>

流程定义文档有两部分组成：

1、bpmn文件

流程规则文件。在部署后，每次系统启动时都会被解析，把内容封装成流程定义放入项目缓存中。Activiti框架结合这个xml文件自动管理流程，流程的执行就是按照bpmn文件定义的规则执行的，bpmn文件是给计算机执行用的。

2、展示流程图的图片

在系统里需要展示流程的进展图片，图片是给用户看的。

五、部署流程定义

/**部署流程定义（从classpath）*/

@Test

public void deploymentProcessDefinition(){

Deployment deployment = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service

.createDeployment()//创建一个部署对象

.name("helloworld入门程序")//添加部署的名称

.addClasspathResource("diagrams/helloworld.bpmn")//从classpath的资源中加载，一次只能加载一个文件

.addClasspathResource("diagrams/helloworld.png")//从classpath的资源中加载，一次只能加载一个文件

.deploy();//完成部署

System.out.println("部署ID："+deployment.getId());//1

System.out.println("部署名称："+deployment.getName());//helloworld入门程序

}

1、先获取流程引擎对象：在创建时会自动加载classpath下的activiti.cfg.xml

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

2、首先获得默认的流程引擎，通过流程引擎获取了一个RepositoryService对象（仓库对象）

3、由仓库的服务对象产生一个部署对象配置对象，用来封装部署操作的相关配置。

4、这是一个链式编程，在部署配置对象中设置显示名，上传流程定义规则文件

5、向数据库表中存放流程定义的规则信息。

这一步在数据库中将操作三张表：

act_re_deployment（部署对象表）

存放流程定义的显示名和部署时间，每部署一次增加一条记录

act_re_procdef（流程定义表）

存放流程定义的属性信息，部署每个新的流程定义都会在这张表中增加一条记录。

注意：当流程定义的key相同的情况下，使用的是版本升级

act_ge_bytearray（资源文件表）

存储流程定义相关的部署信息。即流程定义文档的存放地。每部署一次就会增加两条记录，一条是关于bpmn规则文件的，一条是图片的（如果部署时只指定了bpmn一个文件，activiti会在部署时解析bpmn文件内容自动生成流程图）。两个文件不是很大，都是以二进制形式存储在数据库中。

部署流程定义 ,将 png 和 bpmn 打包成 zip 格式

/**部署流程定义（从zip）*/

@Test

public void deploymentProcessDefinition_zip(){

InputStream in = this.getClass().getClassLoader().getResourceAsStream("diagrams/helloworld.zip");

ZipInputStream zipInputStream = new ZipInputStream(in);

Deployment deployment = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service

.createDeployment()//创建一个部署对象

.name("流程定义")//添加部署的名称

.addZipInputStream(zipInputStream)//指定zip格式的文件完成部署

.deploy();//完成部署

System.out.println("部署ID："+deployment.getId());//

System.out.println("部署名称："+deployment.getName());//

}

六、查看流程定义

/**查询流程定义*/

@Test

public void findProcessDefinition(){

List<ProcessDefinition> list = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service

.createProcessDefinitionQuery()//创建一个流程定义的查询

/**指定查询条件,where条件*/

// .deploymentId(deploymentId)//使用部署对象ID查询

// .processDefinitionId(processDefinitionId)//使用流程定义ID查询

// .processDefinitionKey(processDefinitionKey)//使用流程定义的key查询

// .processDefinitionNameLike(processDefinitionNameLike)//使用流程定义的名称模糊查询

/**排序*/

.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());//对应helloworld.bpmn文件中的name属性值

System.out.println("流程定义的key:"+pd.getKey());//对应helloworld.bpmn文件中的id属性值

System.out.println("流程定义的版本:"+pd.getVersion());//当流程定义的key值相同的相同下，版本升级，默认1

System.out.println("资源名称bpmn文件:"+pd.getResourceName());

System.out.println("资源名称png文件:"+pd.getDiagramResourceName());

System.out.println("部署对象ID："+pd.getDeploymentId());

System.out.println("#########################################################");

}

可以看到流程定义的key值相同的情况下，版本是从1开始逐次升级的

流程定义的Id是【key：版本：生成ID】

说明：

1、流程定义和部署对象相关的Service都是RepositoryService。

2、创建流程定义查询对象，可以在ProcessDefinitionQuery上设置查询的相关参数

3、调用ProcessDefinitionQuery对象的list方法，执行查询，获得符合条件的流程定义列表

4、由运行结果可以看出：

Key和Name的值为：bpmn文件process节点的id和name的属性值：

5、key属性被用来区别不同的流程定义。

带有特定key的流程定义第一次部署时，version为1。之后每次部署都会在当前最高版本号上加1

6、Id的值的生成规则为:{processDefinitionKey}:{processDefinitionVersion}:{generated-id}, 这里的generated-id是一个自动生成的唯一的数字

7、重复部署一次，deploymentId的值以一定的形式变化

8、规则act_ge_property表生成

Deployment 部署对象

1、一次部署的多个文件的信息。对于不需要的流程可以删除和修改。

2、对应的表：

act_re_deployment：部署对象表

act_re_procdef：流程定义表

act_ge_bytearray：资源文件表

act_ge_property：主键生成策略表

ProcessDefinition 流程定义

1、解析.bpmn后得到的流程定义规则的信息，工作流系统就是按照流程定义的规则执行的。

七、删除流程定义

/**删除流程定义*/

@Test

public void deleteProcessDefinition(){

//使用部署ID，完成删除

String deploymentId = "601";

/**

* 不带级联的删除

* 只能删除没有启动的流程，如果流程启动，就会抛出异常

// processEngine.getRepositoryService()//

// .deleteDeployment(deploymentId);

/**

* 级联删除

* 不管流程是否启动，都能可以删除

processEngine.getRepositoryService()//

.deleteDeployment(deploymentId, true);

System.out.println("删除成功！");

}

说明：

因为删除的是流程定义，而流程定义的部署是属于仓库服务的，所以应该先得到RepositoryService

如果该流程定义下没有正在运行的流程，则可以用普通删除。如果是有关联的信息，用级联删除。项目开发中使用级联删除的情况比较多，删除操作一般只开放给超级管理员使用。

八、启动流程实例

/**启动流程实例*/

@Test

public void startProcessInstance(){

//流程定义的key

String processDefinitionKey = "helloworld";

ProcessInstance pi = processEngine.getRuntimeService()//与正在执行的流程实例和执行对象相关的Service

System.out.println("流程实例ID:"+pi.getId());//流程实例ID 101

System.out.println("流程定义ID:"+pi.getProcessDefinitionId());//流程定义ID helloworld:1:4

}

操作数据库的act_ru_execution表,如果是用户任务节点，同时也会在act_ru_task添加一条记录

九、查询当前人的个人任务

/**查询当前人的个人任务*/

@Test

public void findMyPersonalTask(){

String assignee = "王五";

List<Task> list = processEngine.getTaskService()//与正在执行的任务管理相关的Service

.createTaskQuery()//创建任务查询对象

/**查询条件（where部分）*/

.taskAssignee(assignee)//指定个人任务查询，指定办理人

// .taskCandidateUser(candidateUser)//组任务的办理人查询

// .processDefinitionId(processDefinitionId)//使用流程定义ID查询

// .processInstanceId(processInstanceId)//使用流程实例ID查询

// .executionId(executionId)//使用执行对象ID查询

/**排序*/

.orderByTaskCreateTime().asc()//使用创建时间的升序排列

/**返回结果集*/

// .singleResult()//返回惟一结果集

// .count()//返回结果集的数量

// .listPage(firstResult, maxResults);//分页查询

.list();//返回列表

if(list!=null && list.size()>0){

for(Task task:list){

System.out.println("任务ID:"+task.getId());

System.out.println("任务名称:"+task.getName());

System.out.println("任务的创建时间:"+task.getCreateTime());

System.out.println("任务的办理人:"+task.getAssignee());

System.out.println("流程实例ID："+task.getProcessInstanceId());

System.out.println("执行对象ID:"+task.getExecutionId());

System.out.println("流程定义ID:"+task.getProcessDefinitionId());

System.out.println("########################################################");

}

因为是任务查询，所以从processEngine中应该得到TaskService

使用TaskService获取到任务查询对象TaskQuery

为查询对象添加查询过滤条件，使用taskAssignee指定任务的办理者（即查询指定用户的代办任务），同时可以添加分页排序等过滤条件

调用list方法执行查询，返回办理者为指定用户的任务列表

任务ID、名称、办理人、创建时间可以从act_ru_task表中查到。

Execution与ProcessInstance见5.6和5.7章节的介绍。在这种情况下，ProcessInstance相当于Execution

如果assignee属性为部门经理，结果为空。因为现在流程只到了”填写请假申请”阶段，后面的任务还没有执行，即在数据库中没有部门经理可以办理的任务，所以查询不到。

一个Task节点和Execution节点是1对1的情况，在task对象中使用Execution_来表示他们之间的关系

任务ID在数据库表act_ru_task中对应“ID_”列

确切指定了办理者的任务，这个任务将成为指定者的私有任务，即个人任务。

无法指定具体的某一个人来办理的任务，可以把任务分配给几个人或者一到多个小组，让这个范围内的用户可以选择性（如有空余时间时）来办理这类任务，即组任务。

附加：

在activiti任务中，主要分为两大类查询任务（个人任务和组任务）：

先知道个人任务的查询和办理，组任务的操作后面讲

十、完成我的任务

/**完成我的任务*/

@Test

public void completeMyPersonalTask(){

//任务ID

String taskId = "1202";

processEngine.getTaskService()//与正在执行的任务管理相关的Service

.complete(taskId);

System.out.println("完成任务：任务ID："+taskId);

}

是办理任务，所以从ProcessEngine得到的是TaskService。

当执行完这段代码，再以员工的身份去执行查询的时候，会发现这个时候已经没有数据了，因为正在执行的任务中没有数据。

对于执行完的任务，activiti将从act_ru_task表中删除该任务，下一个任务会被插入进来。

以”部门经理”的身份进行查询，可以查到结果。因为流程执行到部门经理审批这个节点了。

再执行办理任务代码，执行完以后以”部门经理”身份进行查询，没有结果。

重复第3和4步直到流程执行完。

十一、查询流程状态

/**查询流程状态（判断流程正在执行，还是结束）*/

@Test

public void isProcessEnd(){

String processInstanceId = "1001";

ProcessInstance pi = processEngine.getRuntimeService()//表示正在执行的流程实例和执行对象

.createProcessInstanceQuery()//创建流程实例查询

.processInstanceId(processInstanceId)//使用流程实例ID查询

.singleResult();

if(pi==null){

System.out.println("流程已经结束");

}

else{

System.out.println("流程没有结束");

}

在流程执行的过程中，创建的流程实例ID在整个过程中都不会变，当流程结束后，流程实例将会在正在执行的执行对象表中（act_ru_execution）被删除

说明：

因为是查询流程实例，所以先获取runtimeService

创建流程实例查询对象，设置实例ID过滤参数

由于一个流程实例ID只对应一个实例，使用singleResult执行查询返回一个唯一的结果，如果结果数量大于1，则抛出异常

判断指定ID的实例是否存在，如果结果为空，则代表流程结束，实例在正在执行的执行对象表中已被删除，转换成历史数据。

Execution 执行对象

按流程定义的规则执行一次的过程.

对应的表：

act_ru_execution：正在执行的信息

act_hi_procinst：已经执行完的历史流程实例信息

act_hi_actinst：存放历史所有完成的活动

ProcessInstance 流程实例

特指流程从开始到结束的那个最大的执行分支，一个执行的流程中，流程实例只有1个。

注意

（1）如果是单例流程，执行对象ID就是流程实例ID

（2）如果一个流程有分支和聚合，那么执行对象ID和流程实例ID就不相同

（3）一个流程中，流程实例只有1个，执行对象可以存在多个。

Task 任务

执行到某任务环节时生成的任务信息。

对应的表：

act_ru_task：正在执行的任务信息

act_hi_taskinst：已经执行完的历史任务信息

十二、流程变量

流程变量在整个工作流中扮演很重要的作用。例如：请假流程中有请假天数、请假原因等一些参数都为流程变量的范围。流程变量的作用域范围是只对应一个流程实例。也就是说各个流程实例的流程变量是不相互影响的。流程实例结束完成以后流程变量还保存在数据库中（存放到流程变量的历史表中）。

两个不同的流程实例，但是同一个流程定义。两个流程变量相互独立的，没有关系。一个流程变量只属于一个流程实例。

部署流程定义

/**部署流程定义（从InputStream）*/

@Test

public void deploymentProcessDefinition_inputStream(){

InputStream inputStreambpmn = this.getClass().getResourceAsStream("/diagrams/processVariables.bpmn");

InputStream inputStreampng = this.getClass().getResourceAsStream("/diagrams/processVariables.png");

Deployment deployment = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service

.createDeployment()//创建一个部署对象

.name("流程定义")//添加部署的名称

.addInputStream("processVariables.bpmn", inputStreambpmn)//使用资源文件的名称（要求：与资源文件的名称要一致），和输入流完成部署

.addInputStream("processVariables.png", inputStreampng)//使用资源文件的名称（要求：与资源文件的名称要一致），和输入流完成部署

.deploy();//完成部署

System.out.println("部署ID："+deployment.getId());//

System.out.println("部署名称："+deployment.getName());//

}

启动流程实例

/**启动流程实例*/

@Test

public void startProcessInstance(){

//流程定义的key

String processDefinitionKey = "processVariables";

ProcessInstance pi = processEngine.getRuntimeService()//与正在执行的流程实例和执行对象相关的Service

System.out.println("流程实例ID:"+pi.getId());//流程实例ID

System.out.println("流程定义ID:"+pi.getProcessDefinitionId());//流程定义ID

}

设置流程变量

/**设置流程变量*/

@Test

public void setVariables(){

/**与任务（正在执行）*/

TaskService taskService = processEngine.getTaskService();

//任务ID

String taskId = "2104";

/**一：设置流程变量，使用基本数据类型*/

// taskService.setVariableLocal(taskId, "请假天数", 5);//与任务ID绑定

// taskService.setVariable(taskId, "请假日期", new Date());

// taskService.setVariable(taskId, "请假原因", "回家探亲，一起吃个饭");

/**二：设置流程变量，使用javabean类型*/

/**

* 当一个javabean（实现序列号）放置到流程变量中，要求javabean的属性不能再发生变化

* * 如果发生变化，再获取的时候，抛出异常

* 解决方案：在Person对象中添加：

* private static final long serialVersionUID = 6757393795687480331L;

* 同时实现Serializable

* */

Person p = new Person();

p.setId(20);

p.setName("翠花");

taskService.setVariable(taskId, "人员信息(添加固定版本)", p);

System.out.println("设置流程变量成功！");

}

1、流程变量的作用域就是流程实例，所以只要设置就行了，不用管在哪个阶段设置。

2、基本类型设置流程变量，在taskService中使用任务ID，定义流程变量的名称，设置流程变量的值。

3、Javabean类型设置流程变量，需要这个javabean实现了Serializable接口。

4、设置流程变量的时候，向act_ru_variable这个表添加数据。

获取流程变量

@Test

public void getVariables(){

/**与任务（正在执行）*/

TaskService taskService = processEngine.getTaskService();

//任务ID

String taskId = "2104";

/**一：获取流程变量，使用基本数据类型*/

// Integer days = (Integer) taskService.getVariable(taskId, "请假天数");

// Date date = (Date) taskService.getVariable(taskId, "请假日期");

// String resean = (String) taskService.getVariable(taskId, "请假原因");

// System.out.println("请假天数："+days);

// System.out.println("请假日期："+date);

// System.out.println("请假原因："+resean);

/**二：获取流程变量，使用javabean类型*/

Person p = (Person)taskService.getVariable(taskId, "人员信息(添加固定版本)");

System.out.println(p.getId()+" "+p.getName());

}

流程变量的获取针对流程实例（即1个流程），每个流程实例获取的流程变量时不同的

使用基本类型获取流程变量，在taskService中使用任务ID，流程变量的名称，获取流程变量的值。

Javabean类型设置获取流程变量，除了需要这个javabean实现了Serializable接口外，还要求流程变量对象的属性不能发生变化，否则抛出异常。解决方案，固定序列化ID

完成我的任务

/**完成我的任务*/

@Test

public void completeMyPersonalTask(){

//任务ID

String taskId = "2402";

processEngine.getTaskService()//与正在执行的任务管理相关的Service

.complete(taskId);

System.out.println("完成任务：任务ID："+taskId);

}

查询流程变量的历史表

/**查询流程变量的历史表*/

@Test

public void findHistoryProcessVariables(){

List<HistoricVariableInstance> list = processEngine.getHistoryService()//

.createHistoricVariableInstanceQuery()//创建一个历史的流程变量查询对象

.variableName("请假天数")

.list();

if(list!=null && list.size()>0){

for(HistoricVariableInstance hvi:list){

System.out.println(hvi.getId()+" "+hvi.getProcessInstanceId()+" "+hvi.getVariableName()+" "+hvi.getVariableTypeName()+" "+hvi.getValue());

System.out.println("###############################################");

}

在流程执行或者任务执行的过程中，用于设置和获取变量，使用流程变量在流程传递的过程中传递业务参数。

对应的表：

act_ru_variable：正在执行的流程变量表

act_hi_varinst：流程变量历史表

Mysql 中查看表的情况

#1、部署对象和流程定义相关的表

#部署对象表

select * from act_re_deployment

#流程定义表

select * from act_re_procdef

#资源文件表

select * from act_ge_bytearray

#主键生成策略表

select * from act_ge_property

#2、流程实例，执行对象，任务

#正在执行的执行对象表 (一般只能对应的查出一个，而且还没有执行完)

Select * from act_ru_execution

#流程实例的历史表（一般只能查一个）

Select * from act_hi_procinst

#正在执行的任务表（只有节点是 USerTask 的时候，该表中存在数据）一般只能查一个，查出当前所在的代办理人

Select * from act_ru_task

#任务历史表（只有节点是 UserTask 的时候，该表中存在数据）可以查出以前的办理人

Select * from act_hi_taskinst

#所有活动节点的历史表，可以查出所有的活动，所有的。

Select * from act_hi_actinst

#3、流程变量

#正在执行的流程变量表

Select * from act_ru_variable

#历史的流程变量表

Select * from act_hi_varinst

@@@第二天@@@

画完流程图，部署到启动

一、流程变量

这个是绘制的流程图，这个要使用英文字母。

1、部署流程定义

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

/**

* 部署流程定义

@Test

public void deploymentProcessDefinition() {

InputStream inputStreamBpmn = this.getClass().getResourceAsStream("sequenceFlow.bpmn");

InputStream inputStreamPng = this.getClass().getResourceAsStream("sequenceFlow.png");

Deployment deployment = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service

.createDeployment()//创建一个部署对象

.name("流程变量的测试")//添加部署的名称

.addInputStream("sequenceFlow.bpmn", inputStreamBpmn)

.addInputStream("sequenceFlow.png", inputStreamPng)

.deploy();//完成部署

System.out.println("部署ID：" + deployment.getId());//

System.out.println("部署名称：" + deployment.getName());//

}

2、启动流程实例

/**

* 启动流程实例

@Test

public void startProcessInstance() {

//流程定义的key

String processDefinitionKey = "sequenceFlow";

ProcessInstance pi = processEngine.getRuntimeService()//与正在执行的流程实例和执行对象相关的Service

System.out.println("流程实例ID:" + pi.getId());//流程实例ID 101

System.out.println("流程定义ID:" + pi.getProcessDefinitionId());//流程定义ID helloworld:1:4

}

3、查询当前人的个人任务

/**

* 查询当前人的个人任务

@Test

public void findMyPersonalTask() {

String assignee = "养柱";

List<Task> list = processEngine.getTaskService()//与正在执行的任务管理相关的Service

.createTaskQuery()//创建任务查询对象

/**查询条件（where部分）*/

.taskAssignee(assignee)//指定个人任务查询，指定办理人

/**排序*/

.orderByTaskCreateTime().asc()//使用创建时间的升序排列

/**返回结果集*/

.list();//返回列表

if (list != null && list.size() > 0) {

for (Task task : list) {

System.out.println("任务ID:" + task.getId());

System.out.println("任务名称:" + task.getName());

System.out.println("任务的创建时间:" + task.getCreateTime());

System.out.println("任务的办理人:" + task.getAssignee());

System.out.println("流程实例ID：" + task.getProcessInstanceId());

System.out.println("执行对象ID:" + task.getExecutionId());

System.out.println("流程定义ID:" + task.getProcessDefinitionId());

System.out.println("########################################################");

}

4、完成我的任务

/**

* 完成我的任务

@Test

public void completeMyPersonalTask() {

//任务ID

String taskId = "3103";

//完成任务的同时，设置流程变量，使用流程变量用来指定完成任务后，下一个连线

Map<String, Object> variables = new HashMap<String,Object>();

variables.put("message", "重要");

processEngine.getTaskService()//与正在执行的任务管理相关的Service

.complete(taskId, variables);

System.out.println("完成任务：任务ID：" + taskId);

}

提交分支任务时，根据不同流程变量的 message。如果这里填写的是不重要，流程直接结束，查询流程状态为完成；如果填写的是重要，流程变量流向总经理，进行分支流程的进行。

5、查询流程状态（判断流程正在执行，还是结束）

/**

* 查询流程状态（判断流程正在执行，还是结束）

@Test

public void isProcessEnd() {

String processInstanceId = "3103";

ProcessInstance pi = processEngine.getRuntimeService()//表示正在执行的流程实例和执行对象

.createProcessInstanceQuery()//创建流程实例查询

.processInstanceId(processInstanceId)//使用流程实例ID查询

.singleResult();

if (pi == null) {

System.out.println("流程已经结束");

} else {

System.out.println("流程没有结束");

}

总结

1、一个活动中可以指定一个或多个SequenceFlow（Start中有一个，End中没有）

2、如果只有一个，则可以不使用流程变量设置codition的名称；

如果有多个，则需要使用流程变量设置codition的名称。

message表示流程变量的名称，‘不重要’表示流程变量的值，${}中间的内容要使用boolean类型的表达式，用来判断应该执行的连线。

二、排他网关(ExclusiveGateWay)

为什么开始报错是加载出错了，解决不了？

后来删掉了。重画以一下，发现问题解决好了了。

1、部署流程定义

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

/**部署流程定义（从inputStream）*/

@Test

public void deploymentProcessDefinition_inputStream(){

InputStream inputStreamBpmn = this.getClass().getResourceAsStream("exclusiveGateWay.bpmn");

InputStream inputStreamPng = this.getClass().getResourceAsStream("exclusiveGateWay.png");

Deployment deployment = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service

.createDeployment()//创建一个部署对象

.name("排他网关测试")//添加部署的名称

.addInputStream("exclusiveGateWay.bpmn", inputStreamBpmn)//

.addInputStream("exclusiveGateWay.png", inputStreamPng)//

.deploy();//完成部署

System.out.println("部署ID："+deployment.getId());//

System.out.println("部署名称："+deployment.getName());//

}

2、启动流程实例

/**启动流程实例*/

@Test

public void startProcessInstance(){

//流程定义的key

String processDefinitionKey = "exclusiveGateWay";

ProcessInstance pi = processEngine.getRuntimeService()//与正在执行的流程实例和执行对象相关的Service

System.out.println("流程实例ID:"+pi.getId());//流程实例ID 101

System.out.println("流程定义ID:"+pi.getProcessDefinitionId());//流程定义ID helloworld:1:4

}

3、查询当前人的个人任务

这里的查询当前个人任务，可以反复的查询，可以查询别人的当前流程。

/**查询当前人的个人任务*/

@Test

public void findMyPersonalTask(){

String assignee = "柳岩";

List<Task> list = processEngine.getTaskService()//与正在执行的任务管理相关的Service

.createTaskQuery()//创建任务查询对象

/**查询条件（where部分）*/

.taskAssignee(assignee)//指定个人任务查询，指定办理人

/**排序*/

.orderByTaskCreateTime().asc()//使用创建时间的升序排列

/**返回结果集*/

.list();//返回列表

if(list!=null && list.size()>0){

for(Task task:list){

System.out.println("任务ID:"+task.getId());

System.out.println("任务名称:"+task.getName());

System.out.println("任务的创建时间:"+task.getCreateTime());

System.out.println("任务的办理人:"+task.getAssignee());

System.out.println("流程实例ID："+task.getProcessInstanceId());

System.out.println("执行对象ID:"+task.getExecutionId());

System.out.println("流程定义ID:"+task.getProcessDefinitionId());

System.out.println("########################################################");

}

4、完成我的任务

/**完成我的任务*/

@Test

public void completeMyPersonalTask(){

//任务ID

String taskId = "5004";

//完成任务的同时，设置流程变量，使用流程变量用来指定完成任务后，下一个连线，对应exclusiveGateWay.bpmn文件中${money>1000}

Map<String, Object> variables = new HashMap<String, Object>();

variables.put("money",1700); // 300 700

processEngine.getTaskService()//与正在执行的任务管理相关的Service

.complete(taskId,variables);

System.out.println("完成任务：任务ID："+taskId);

}

这里通过传入不同的数据，就可以走不同的流程咯。1700元走总监的流程，700元走部门总监的流程。

5、血淋淋的教训

org.activiti.engine.ActivitiException: Unknown property used in expression: ${ message <1000 && message >= 500 }

一直不知道咋了，明明赋值的是 money ，之前的 message 早就改了，后来查阅数据库的部署流程表，发现 XXX.bpmn 里面保存的还是message ，所以我赶紧把数据删掉，重新再部署一边，解决了。

6、反思：

1、流程执行到一个分支里面去了后，不能再退回到起初的判断节点，只能一直向下流去

2、很多时候，已经部署的错误流程，是要清理掉的。不然会造成严重的错误。

比如你通过审批人 “柳岩” 查询代办流程，发现该审批节点下代办的任务一堆，但是大部分都不知道的。

三、并行网关(parallelGateWay)

付款是买家，收款是商家；

发货是商家，收货是买家。

1、部署流程定义

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

/**部署流程定义（从inputStream）*/

@Test

public void deploymentProcessDefinition_inputStream(){

InputStream inputStreamBpmn = this.getClass().getResourceAsStream("parallelGateWay.bpmn");

InputStream inputStreamPng = this.getClass().getResourceAsStream("parallelGateWay.png");

Deployment deployment = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service

.createDeployment()//创建一个部署对象

.name("并行网关测试代码"

+ "")//添加部署的名称

.addInputStream("parallelGateWay.bpmn", inputStreamBpmn)//

.addInputStream("parallelGateWay.png", inputStreamPng)//

.deploy();//完成部署

System.out.println("部署ID："+deployment.getId());//

System.out.println("部署名称："+deployment.getName());//

}

2、启动流程实例

/**启动流程实例*/

@Test

public void startProcessInstance(){

//流程定义的key

String processDefinitionKey = "parallelGateWay";

ProcessInstance pi = processEngine.getRuntimeService()//与正在执行的流程实例和执行对象相关的Service

System.out.println("流程实例ID:"+pi.getId());//流程实例ID 101

System.out.println("流程定义ID:"+pi.getProcessDefinitionId());//流程定义ID helloworld:1:4

}

3、查询当前人的个人任务

/**查询当前人的个人任务*/

@Test

public void findMyPersonalTask(){

String assignee = "买家";

List<Task> list = processEngine.getTaskService()//与正在执行的任务管理相关的Service

.createTaskQuery()//创建任务查询对象

/**查询条件（where部分）*/

.taskAssignee(assignee)//指定个人任务查询，指定办理人

/**排序*/

.orderByTaskCreateTime().asc()//使用创建时间的升序排列

/**返回结果集*/

.list();//返回列表

if(list!=null && list.size()>0){

for(Task task:list){

System.out.println("任务ID:"+task.getId());

System.out.println("任务名称:"+task.getName());

System.out.println("任务的创建时间:"+task.getCreateTime());

System.out.println("任务的办理人:"+task.getAssignee());

System.out.println("流程实例ID："+task.getProcessInstanceId());

System.out.println("执行对象ID:"+task.getExecutionId());

System.out.println("流程定义ID:"+task.getProcessDefinitionId());

System.out.println("########################################################");

}

这里的 String assignee = "买家”;可以是 “买家”、“商家”，查询后发现，买家是付款节点，商家是发货节点。这样就并行咯。

4、完成我的任务

/**完成我的任务*/

@Test

public void completeMyPersonalTask(){

//任务ID

String taskId = "5807";

processEngine.getTaskService()//与正在执行的任务管理相关的Service

.complete(taskId);

System.out.println("完成任务：任务ID："+taskId);

}

这里首先买家付款，然后调用上面的方法，查看 “买家” 任务执行情况，发现没有任务。

再查看 “商家”情况，发现有两个任务，一个是 “发货” ，还有一个 “收款”。

反思

1、反复的执行查询当前人的个人任务、完成我的任务，就是执行流程操作呢。

2、一个排他网关对应一个以上的顺序流

3、一个流程中流程实例只有1个，执行对象有多个

4、并行网关的功能是基于进入和外出的顺序流的：

分支(fork)：并行后的所有外出顺序流，为每个顺序流都创建一个并发分支。

汇聚(join)：所有到达并行网关，在此等待的进入分支，直到所有进入顺序流的分支都到达以后，流程就会通过汇聚网关。

5、并行网关的进入和外出都是使用相同节点标识

如果同一个并行网关有多个进入和多个外出顺序流，它就同时具有分支和汇聚功能。这时，网关会先汇聚所有进入的顺序流，然后再切分成多个并行分支。

并行网关不会解析条件。即使顺序流中定义了条件，也会被忽略。

也就是说并行网关，都要到汇聚一起，然后才行动。

一、工作流的概念

二、核心 API

RepositoryService是Activiti的仓库服务类。所谓的仓库指流程定义文档的两个文件：bpmn文件和流程图片。

TaskService是activiti的任务服务类。可以从这个类中获取任务的信息。

HistoryService是activiti的查询历史信息的类。在一个流程执行完成后，这个对象为我们提供查询历史信息。

ProcessDefinition流程定义类。可以从这里获得资源文件等。

ProcessInstance代表流程定义的执行实例。

Execution

Activiti用这个对象去描述流程执行的每一个节点。在没有并发的情况下，Execution就是同ProcessInstance。流程按照流程定义的规则执行一次的过程，就可以表示执行对象Execution。

三、HelloWorld 程序

四、BPMN 文件

五、部署流程定义

六、查看流程定义

七、删除流程定义

八、 启动流程实例

九、查询当前人的个人任务

十、完成我的任务

十 一、查询流程状态

十二、流程变量

@@@第二天@@@

一、流程变量

1、部署流程定义

二、排他网关(ExclusiveGateWay)

三、并行网关(parallelGateWay)

八、启动流程实例

十一、查询流程状态