Activiti工作流引擎使用详解(一)

时间:2024-09-01 09:05:26

一、IDEA安装activiti插件

在插件库中查找actiBPM,安装该插件,如果找不到该插件,请到插件库中下载该包手动安装,插件地址

http://plugins.jetbrains.com/plugin/7429-actibpm 安装后重启IDEA

二、activiti基础环境搭建

2.1 actiBPM插件使用示例

将需要用到的activiti包引入到工程中

<dependency>
<groupId>org.activiti</groupId>
<artifactId>activiti-engine</artifactId>
<version>5.17.0</version>
</dependency>

resources目录下创建diagrams文件夹

Activiti工作流引擎使用详解(一)

右键new,点击BpmnFeil,然后取个名

Activiti工作流引擎使用详解(一)

鼠标左键拖拽StartEvent到界面上,同样再弄几个其他图标

Activiti工作流引擎使用详解(一)

鼠标放到图标中心会变成黑白扇形,拖拽连线到另一个图标进行画图

 Activiti工作流引擎使用详解(一)

生成png文件

右键点击hello.bpmn,选择Diagrams

Activiti工作流引擎使用详解(一)

点击箭头指的图标,选择生成位置即可

Activiti工作流引擎使用详解(一)

2.2 初始化activiti表结构

2.2.1 通过代码创建工作流使用的表

public class TestActiviti {
/**
* 使用代码创建工作流使用的23张表
*/
@Test
public void createTable(){
//创建引擎配置类
ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
configuration.setJdbcDriver("com.mysql.jdbc.Driver");
configuration.setJdbcUrl("jdbc:mysql://192.168.27.14:3306/activiti");
configuration.setJdbcUsername("root");
configuration.setJdbcPassword("root"); //不自动创建表,需要表存在 DB_SCHEMA_UPDATE_FALSE = "false";
//先删除表,再创建表 DB_SCHEMA_UPDATE_CREATE_DROP = "create-drop";
//如果表不存在,先创建表 DB_SCHEMA_UPDATE_TRUE = "true";
configuration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
//创建工作流核心对象
ProcessEngine processEngine = configuration.buildProcessEngine();
System.out.println(processEngine);
}
}

2.2.2 通过配置文件方式配置数据库等,resourses目录下添加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/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"> <bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
<!-- 连接数据的配置 -->
<property name="jdbcDriver" value="com.mysql.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql://192.168.27.14:3306/activiti?characterEncoding=utf8"/>
<property name="jdbcUsername" value="root"/>
<property name="jdbcPassword" value="root"/>
<!-- 不自动创建表,需要表存在 "false";
先删除表,再创建表 "create-drop";
如果表不存在,先创建表"true";
-->
<property name="databaseSchemaUpdate" value="true"/>
</bean>
</beans>
@Test
public void createTable2(){
ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml")
.buildProcessEngine();
}

2.2.3 那么,能不能再给力一点?前面看到了两种创建ProcessEngine(流程引擎)的方式,而这里要简化很多,调用ProcessEngines的getDefaultProceeEngine方法时会自动加载classpath下名为activiti.cfg.xml文件。

@Test
public void createTable3(){
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
}

三、activiti核心api讲解

3.1ProcessEngine

在Activiti中最核心的类,其他的类都是由他而来,由工作流引擎可以创建各个Service,这些Service是调用工作流23张表的服务

@Test
public void getService(){
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine(); //管理流程定义
RepositoryService repositoryService = processEngine.getRepositoryService();
//执行管理,包括启动、推进、删除流程实例等
RuntimeService runtimeService = processEngine.getRuntimeService();
//任务管理
TaskService taskService = processEngine.getTaskService();
//历史管理(执行完的数据的管理
HistoryService historyService = processEngine.getHistoryService();
//组织机构管理
IdentityService identityService = processEngine.getIdentityService();
//可选服务,任务表单管理
FormService formService = processEngine.getFormService(); ManagementService managementService = processEngine.getManagementService();
}

3.2 RepositoryService

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

@Test
public void testRespositoryService(){
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
RepositoryService repositoryService = processEngine.getRepositoryService();
//可产生DeploymentBuilder用来定义流程部署的相关参数
DeploymentBuilder deployment = repositoryService.createDeployment();
//删除流程定义
repositoryService.deleteDeployment("deploymentId");
}

3.3 RuntimeService

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

3.4 TaskService

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

3.5 HistoryService

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

3.6 ProcessDefinition

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

3.7 ProcessInstance

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

3.8 Execution

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

四、一个简单的HelloWorld程序示例

4.1 利用插件创建流程图

Activiti工作流引擎使用详解(一)

4.2 部署流程定义

/**
* 部署流程定义
*/
@Test
public void deploymentProcessDefinition(){ //获取流程定义与部署相关Service
Deployment deployment = processEngine.getRepositoryService()
.createDeployment() //创建一个部署对象
.name("helloworld入门程序")
.addClasspathResource("diagrams/helloworld.bpmn")//加载资源文件
.deploy();//完成部署
System.out.println(deployment.getId());
System.out.println(deployment.getName());
}

4.3 启动流程实例

/**
* 启动流程实例
*/
@Test
public void startProcessInstance(){
//获取与正在执行的流程示例和执行对象相关的Service
ProcessInstance processInstance = processEngine.getRuntimeService()
//使用流程定义的key启动实例,key对应bpmn文件中id的属性值,默认按照最新版本流程启动
.startProcessInstanceByKey("helloworld");
System.out.println(processInstance.getId());
System.out.println(processInstance.getProcessDefinitionId());
}

4.4 查看我的个人任务

/**
* 查询当前的个人任务
*/
@Test
public void findPersonalTask(){
//与正在执行的任务相关的Service
List<Task> list = processEngine.getTaskService()
.createTaskQuery() //创建查询任务对象
.taskAssignee("王五") //指定个人任务查询,指定办理人
.list();
if(list != null && list.size() > 0){
for(Task task : list){
System.out.println(task.getId());
System.out.println(task.getName());
System.out.println(task.getCreateTime());
System.out.println(task.getAssignee());
System.out.println(task.getProcessInstanceId());
System.out.println(task.getExecutionId());
System.out.println(task.getProcessDefinitionId());
}
}
}

4.5 完成我的个人任务

/**
* 完成我的任务
*/
@Test
public void completePersonalTask(){
processEngine.getTaskService()
.complete("7502");
}

五、管理流程定义

5.1 部署流程定义

通过classpath部署流程定义

/**部署流程定义(从classpath)*/
@Test
public void deploymentProcessDefinition_classpath(){
Deployment deployment = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service
.createDeployment()//创建一个部署对象
.name("流程定义")//添加部署的名称
.addClasspathResource("diagrams/helloworld.bpmn")//从classpath的资源中加载,一次只能加载一个文件
.addClasspathResource("diagrams/helloworld.png")//从classpath的资源中加载,一次只能加载一个文件
.deploy();//完成部署
System.out.println("部署ID:"+deployment.getId());//
System.out.println("部署名称:"+deployment.getName());//
}

通过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());//
}

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

a) act_re_deployment(部署对象表)

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

b) act_re_procdef(流程定义表)

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

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

c) act_ge_bytearray(资源文件表)

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

5.2 查看流程定义

/**查询流程定义*/
@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("#########################################################");
}
}
}

结果:

Activiti工作流引擎使用详解(一)

再部署一次运行结果为:

Activiti工作流引擎使用详解(一)

  可以看到流程定义的key值相同的情况下,版本是从1开始逐次升级的,流程定义的Id是【key:版本:生成ID】。由运行结果可以看出:Key和Name的值为:bpmn文件process节点的id和name的属性值。key属性被用来区别不同的流程定义,带有特定key的流程定义第一次部署时,version为1。之后每次部署都会在当前最高版本号上加1,Id的值的生成规则为:{processDefinitionKey}:{processDefinitionVersion}:{generated-id}, 这里的generated-id是一个自动生成的唯一的数字,重复部署一次,deploymentId的值以一定的形式变化,规则act_ge_property表生成。

5.3 删除流程定义

/**删除流程定义*/
@Test
public void deleteProcessDefinition(){
//使用部署ID,完成删除
String deploymentId = "601";
/**
* 不带级联的删除
* 只能删除没有启动的流程,如果流程启动,就会抛出异常
*/
// processEngine.getRepositoryService()//
// .deleteDeployment(deploymentId); /**
* 级联删除
* 不管流程是否启动,都能可以删除
*/
processEngine.getRepositoryService()//
.deleteDeployment(deploymentId, true);
System.out.println("删除成功!");
}

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

5.4 获取流程定义文档的资源

查询出流程定义文档。主要查的是图片,用于显示流程用。

/**查看流程图
* @throws IOException */
@Test
public void viewPic() throws IOException {
/**将生成图片放到文件夹下*/
String deploymentId = "801";
//获取图片资源名称
List<String> list = processEngine.getRepositoryService()//
.getDeploymentResourceNames(deploymentId);
//定义图片资源的名称
String resourceName = "";
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);
}

  deploymentId为流程部署ID,resourceName为act_ge_bytearray表中NAME_列的值,使用repositoryService的getDeploymentResourceNames方法可以获取指定部署下得所有文件的名称,使用repositoryService的getResourceAsStream方法传入部署ID和资源图片名称可以获取部署下指定名称文件的输入流,最后的有关IO流的操作,使用FileUtils工具的copyInputStreamToFile方法完成流程流程到文件的拷贝,将资源文件以流的形式输出到指定文件夹下。

5.5 查询最新版本的流程定义

/***附加功能:查询最新版本的流程定义*/
@Test
public void findLastVersionProcessDefinition(){
List<ProcessDefinition> list = processEngine.getRepositoryService()//
.createProcessDefinitionQuery()//
.orderByProcessDefinitionVersion().asc()//使用流程定义的版本升序排列
.list();
/**
* Map<String,ProcessDefinition>
map集合的key:流程定义的key
map集合的value:流程定义的对象
map集合的特点:当map集合key值相同的情况下,后一次的值将替换前一次的值
*/
Map<String, ProcessDefinition> map = new LinkedHashMap<String, ProcessDefinition>();
if(list!=null && list.size()>0){
for(ProcessDefinition pd:list){
map.put(pd.getKey(), pd);
}
}
List<ProcessDefinition> pdList = new ArrayList<ProcessDefinition>(map.values());
if(pdList!=null && pdList.size()>0){
for(ProcessDefinition pd:pdList){
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("#########################################################");
}
}
}

5.6 删除流程定义

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

 六、流程实例、任务的执行

涉及到的表

Activiti工作流引擎使用详解(一)

6.1 启动流程实例

    /**
* 启动流程实例
*/
@Test
public void startProcessInstance(){
//获取与正在执行的流程示例和执行对象相关的Service
ProcessInstance processInstance = processEngine.getRuntimeService()
//使用流程定义的key启动实例,key对应bpmn文件中id的属性值,默认按照最新版本流程启动
.startProcessInstanceByKey("helloworld");
System.out.println(processInstance.getId());
System.out.println(processInstance.getProcessDefinitionId());
}

  通过流程定义的key启动流程实例,这时打开数据库act_ru_execution表,ID_表示执行对象ID,PROC_INST_ID_表示流程实例ID,如果是单例流程(没有分支和聚合),那么流程实例ID和执行对象ID是相同的。

Activiti工作流引擎使用详解(一)

一个流程流程实例只有一个,执行对象可以存在多个。

 6.2 查询我的个人任务

/**查询当前人的个人任务*/
@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表中查到。在这种情况下,ProcessInstance相当于Execution, 如果assignee属性为部门经理,结果为空。因为现在流程只到了”填写请假申请”阶段,后面的任务还没有执行,即在数据库中没有部门经理可以办理的任务,所以查询不到。 一个Task节点和Execution节点是1对1的情况,在task对象中使用Execution_来表示他们之间的关系任务ID在数据库表act_ru_task中对应“ID_”列。

  在activiti任务中,主要分为两大类查询任务(个人任务和组任务):

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

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

 6.3 办理任务

    /**完成我的任务*/
@Test
public void completeMyPersonalTask(){
//任务ID
String taskId = "1202";
processEngine.getTaskService()//与正在执行的任务管理相关的Service
.complete(taskId);
System.out.println("完成任务:任务ID:"+taskId);
}

  是办理任务,所以从ProcessEngine得到的是TaskService。当执行完这段代码,再以员工的身份去执行查询的时候,会发现这个时候已经没有数据了,因为正在执行的任务中没有数据。对于执行完的任务,activiti将从act_ru_task表中删除该任务,下一个任务会被插入进来。以”部门经理”的身份进行查询,可以查到结果。因为流程执行到部门经理审批这个节点了。再执行办理任务代码,执行完以后以”部门经理”身份进行查询,没有结果。重复这个步骤直到流程执行完。

6.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的实例是否存在,如果结果为空,则代表流程结束,实例在正在执行的执行对象表中已被删除,转换成历史数据。

6.5 查询历史任务

/**查询历史任务*/
@Test
public void findHistoryTask(){
String taskAssignee = "张三";
List<HistoricTaskInstance> 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.getProcessInstanceId()+" "+hti.getStartTime()+" "+hti.getEndTime()+" "+hti.getDurationInMillis());
System.out.println("################################");
}
}
}

6.6 查询历史流程实例

/**查询历史流程实例*/
@Test
public void findHistoryProcessInstance(){
String processInstanceId = "1001";
HistoricProcessInstance hpi = processEngine.getHistoryService()//与历史数据(历史表)相关的Service
.createHistoricProcessInstanceQuery()//创建历史流程实例查询
.processInstanceId(processInstanceId)//使用流程实例ID查询
.singleResult();
System.out.println(hpi.getId()+" "+hpi.getProcessDefinitionId()+" "+hpi.getStartTime()+" "+hpi.getEndTime()+" "+hpi.getDurationInMillis());
}

七、流程变量

流程变量涉及到的表

Activiti工作流引擎使用详解(一)

7.1模拟获取流程变量的场景

/**模拟设置和获取流程变量的场景 */
@Test
public void setAndGetVariables(){
RuntimeService runtimeService = processEngine.getRuntimeService();
TaskService taskService = processEngine.getTaskService(); //使用执行对象ID设置
runtimeService.setVariable(executionId, variableName, value);(设置一个)
runtimeService.setVariables(executionId, variables); //使用任务ID设置
taskService.setVariable(taskId, variableName, value);(设置一个)
taskService.setVariables(taskId, variables); //启动流程实例的同时设置
runtimeService.startProcessInstanceByKey(processDefinitionKey, variables); //完成任务的同时设置
taskService.complete(taskId, variables); /**获取流程变量*/
//使用执行对象ID和流程变量的名称,获取流程变量的值
runtimeService.getVariable(executionId, variableName);
//使用执行对象ID,获取所有的流程变量,将流程变量放置到Map集合中,map集合的key就是流程变量的名称,map集合的value就是流程变量的值
runtimeService.getVariables(executionId);
//使用执行对象ID,获取流程变量的值,通过设置流程变量的名称存放到集合中,获取指定流程变量名称的流程变量的值,值存放到Map集合中
runtimeService.getVariables(executionId, variableNames); //使用任务ID和流程变量的名称,获取流程变量的值
taskService.getVariable(taskId, variableName);
//使用任务ID,获取所有的流程变量,将流程变量放置到Map集合中,map集合的key就是流程变量的名称,map集合的value就是流程变量的值
taskService.getVariables(taskId);
//使用任务ID,获取流程变量的值,通过设置流程变量的名称存放到集合中,获取指定流程变量名称的流程变量的值,值存放到Map集合中
taskService.getVariables(taskId, variableNames);
}

7.2 设置流程变量

/**设置流程变量 */
@Test
public void setVariables(){
TaskService taskService = processEngine.getTaskService();
//任务ID
String taskId = "50004";
//一、设置流程变量,使用基本数据类型
taskService.setVariableLocal(taskId,"请假天数",3);//local与当前task绑定,下一个task不可见
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("流程变量设置成功");
}

流程变量支持的类型:

Activiti工作流引擎使用详解(一)

  从图中可以看出包括了大部分封装类型和Date、String和实现了Serializable接口的类的类型。流程变量的获取针对流程实例(即1个流程),每个流程实例获取的流程变量时不同的,使用基本类型获取流程变量,在taskService中使用任务ID,流程变量的名称,获取流程变量的值。Javabean类型设置获取流程变量,除了需要这个javabean实现了Serializable接口外,还要求流程变量对象的属性不能发生变化,否则抛出异常。解决方案,固定序列化ID。

setVariable和setVariableLocal的区别:

setVariable:设置流程变量的时候,流程变量名称相同的时候,后一次的值替换前一次的值,而且可以看到TASK_ID的字段不会存放任务ID的值

setVariableLocal:

1. 设置流程变量的时候,针对当前活动的节点设置流程变量,如果一个流程中存在2个活动节点,对每个活动节点都设置流程变量,即使流程变量的名称相同,后一次的版本的值也不会替换前一次版本的值,它会使用不同的任务ID作为标识,存放2个流程变量值,而且可以看到TASK_ID的字段会存放任务ID的值

例如act_hi_varinst 表的数据:不同的任务节点,即使流程变量名称相同,存放的值也是不同的。

如图:

Activiti工作流引擎使用详解(一)

2. 使用setVariableLocal说明流程变量绑定了当前的任务,当流程继续执行时,下个任务获取不到这个流程变量(因为正在执行的流程变量中没有这个数据),所有查询正在执行的任务时不能查询到我们需要的数据,此时需要查询历史的流程变量。

7.3 获取流程变量

/**获取流程变量 */
@Test
public void getVariables(){
TaskService taskService = processEngine.getTaskService();
//任务ID
String taskId = "55002";
/**一:获取流程变量,使用基本数据类型*/
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());
}

7.4 查询历史流程变量

/**查询流程变量的历史表*/
@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_hi_varinst表(也可以针对,流程实例ID,执行对象ID,任务ID查询)