当前位置:首页 > 嵌入式培训 > 嵌入式学习 > 讲师博文 >
activity工作流,这里让你快速了解
时间:2018-07-18作者:华清远见

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

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

一、Activity表设计:

1、资源库流程规则表

1)act_re_deployment 部署信息表

2)act_re_model 流程设计模型部署表

3)act_re_procdef 流程定义数据表

2、运行时数据库表

1)act_ru_execution 运行时流程执行实例表

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

3)act_ru_task 运行时任务节点表

4)act_ru_variable 运行时流程变量数据表

3、历史数据库表

1)act_hi_actinst 历史节点表

2)act_hi_attachment 历史附件表

3)act_hi_comment 历史意见表

4)act_hi_identitylink 历史流程人员表

5)act_hi_detail 历史详情表,提供历史变量的查询

6)act_hi_procinst 历史流程实例表

7)act_hi_taskinst 历史任务实例表

8)act_hi_varinst 历史变量表

4、组织机构表

1)act_id_group 用户组信息表

2)act_id_info 用户扩展信息表

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

4)act_id_user 用户信息表

这四张表很常见,基本的组织机构管理,关于用户认证方面建议还是自己开发一套,组件自带的功能太简单,使用中有很多需求难以满足

5、通用数据表

1)act_ge_bytearray 二进制数据表

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

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

代码:【

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">

 

 

三、logging.properties(日志处理)

代码:【

log4j.rootLogger=INFO, CA

# ConsoleAppender

log4j.appender.CA=org.apache.log4j.ConsoleAppender

log4j.appender.CA.layout=org.apache.log4j.PatternLayout

log4j.appender.CA.layout.ConversionPattern= %d{hh:mm:ss,SSS} [%t] %-5p %c %x - %m%n

四、创建表

【package junit;

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.ProcessEngineConfiguration;

import org.junit.Test;

public class TestActiviti {

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

@Test

public void createTable(){

ProcessEngineConfiguration processEngineConfiguration = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();

//连接数据库的配置

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

processEngineConfiguration.setJdbcUrl("jdbc:mysql://localhost:3306/W_activiti_01?useUnicode=true&characterEncoding=utf8");

processEngineConfiguration.setJdbcUsername("root");

processEngineConfiguration.setJdbcPassword("");

/**

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);

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

ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();

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

}

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

@Test

public void createTable_2(){

// ProcessEngineConfiguration processEngineConfiguration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml");

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

// ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();

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

.buildProcessEngine();

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

}

}

五、HelloWorld

代码:【package test.a_helloworld;

import java.util.List;

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.ProcessEngines;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.runtime.ProcessInstance;

import org.activiti.engine.task.Task;

import org.junit.Test;

public class HelloWorld {

/** #:获取流程引擎 */

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

/** 1:部署流程定义 */

@Test

public void deploymentProcessDefinition() {// 表【act_re_deployment】

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入门程序

}

/** 2:启动流程实例 */

@Test

public void startProcessInstance() {// 表【act_hi_procinst/act_ru_execution】

// 流程定义的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

}

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

@Test

public void findMyPersonalTask() {

String assignee = "张三";

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

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

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

.list();

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

for (Task task : list) {

System.out

.println("###############################################");

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 = "7502";

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

.complete(taskId);

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

}

}

六、ProcessDefinitionTest

代码:【package test.b_processDefinition;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.zip.ZipInputStream;

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.ProcessEngines;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.repository.ProcessDefinition;

import org.apache.commons.io.FileUtils;

import org.junit.Test;

public class ProcessDefinitionTest {

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

/**部署流程定义(从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)*/

@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(){

Listlist = 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("#########################################################");

}

}

}

/**删除流程定义*/

@Test

public void deleteProcessDefinition(){

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

String deploymentId = "601";

/**

* 不带级联的删除

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

*/

// processEngine.getRepositoryService()//

// .deleteDeployment(deploymentId);

/**

* 级联删除

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

*/

processEngine.getRepositoryService()//

.deleteDeployment(deploymentId, true);

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

}

/**查看流程图

* @throws IOException */

@Test

public void viewPic() throws IOException{

/**将生成图片放到文件夹下*/

String deploymentId = "801";

//获取图片资源名称

Listlist = 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);

}

/***附加功能:查询最新版本的流程定义*/

@Test

public void findLastVersionProcessDefinition(){

Listlist = processEngine.getRepositoryService()//

.createProcessDefinitionQuery()//

.orderByProcessDefinitionVersion().asc()//使用流程定义的版本升序排列

.list();

/**

* Map

map集合的key:流程定义的key

map集合的value:流程定义的对象

map集合的特点:当map集合key值相同的情况下,后一次的值将替换前一次的值

*/

Mapmap = new LinkedHashMap();

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

for(ProcessDefinition pd:list){

map.put(pd.getKey(), pd);

}

}

ListpdList = new ArrayList(map.values());

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

for(ProcessDefinition pd:pdList){

System.out.println("流程定义ID:"+pd.getId());//流程定义的key+版本+随机生成数

System.out.println("流程定义的名称:"+pd.getName());//对应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相同的所有不同版本的流程定义)*/

@Test

public void deleteProcessDefinitionByKey(){

//流程定义的key

String processDefinitionKey = "helloworld";

//先使用流程定义的key查询流程定义,查询出所有的版本

Listlist = 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);

}

}

}

}

七、ProcessInstance

代码:【

package test.c_processInstance;

import java.io.InputStream;

import java.util.List;

import java.util.zip.ZipInputStream;

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.ProcessEngines;

import org.activiti.engine.history.HistoricProcessInstance;

import org.activiti.engine.history.HistoricTaskInstance;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.runtime.ProcessInstance;

import org.activiti.engine.task.Task;

import org.junit.Test;

public class ProcessInstanceTest {

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

/**部署流程定义(从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 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

}

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

@Test

public void findMyPersonalTask(){

String assignee = "王五";

Listlist = 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("########################################################");

}

}

}

/**完成我的任务*/

@Test

public void completeMyPersonalTask(){

//任务ID

String taskId = "1202";

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

.complete(taskId);

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

}

/**查询流程状态(判断流程正在执行,还是结束)*/

@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("流程没有结束");

}

}

/**查询历史任务(后面讲)*/

@Test

public void findHistoryTask(){

String taskAssignee = "张三";

Listlist = 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("################################");

}

}

}

/**查询历史流程实例(后面讲)*/

@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());

}

}

八、processVariables

代码1:【

package test.d_processVariables;

import java.io.Serializable;

public class Person implements Serializable {

/**

*

*/

private static final long serialVersionUID = 6757393795687480331L;

private Integer id;//编号

private String name;//姓名

private String education;

public String getEducation() {

return education;

}

public void setEducation(String education) {

this.education = education;

}

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

}

代码2:【

package test.d_processVariables;

import java.io.InputStream;

import java.util.List;

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.ProcessEngines;

import org.activiti.engine.RuntimeService;

import org.activiti.engine.TaskService;

import org.activiti.engine.history.HistoricVariableInstance;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.runtime.ProcessInstance;

import org.junit.Test;

public class ProcessVariablesTest {

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

/** 部署流程定义(从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

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

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 = "7502";

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

// 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("设置流程变量成功!");

}

/** 获取流程变量 */

@Test

public void getVariables() {

/** 与任务(正在执行) */

TaskService taskService = processEngine.getTaskService();

// 任务ID

String taskId = "5002";

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

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

}

/** 模拟设置和获取流程变量的场景 */

public void setAndGetVariables() {

/** 与流程实例,执行对象(正在执行) */

RuntimeService runtimeService = processEngine.getRuntimeService();

/** 与任务(正在执行) */

TaskService taskService = processEngine.getTaskService();

/** 设置流程变量 */

// runtimeService.setVariable(executionId, variableName,

// value)//表示使用执行对象ID,和流程变量的名称,设置流程变量的值(一次只能设置一个值)

// runtimeService.setVariables(executionId,

// variables)//表示使用执行对象ID,和Map集合设置流程变量,map集合的key就是流程变量的名称,map集合的value就是流程变量的值(一次设置多个值)

// taskService.setVariable(taskId, variableName,

// value)//表示使用任务ID,和流程变量的名称,设置流程变量的值(一次只能设置一个值)

// taskService.setVariables(taskId,

// variables)//表示使用任务ID,和Map集合设置流程变量,map集合的key就是流程变量的名称,map集合的value就是流程变量的值(一次设置多个值)

// runtimeService.startProcessInstanceByKey(processDefinitionKey,

// variables);//启动流程实例的同时,可以设置流程变量,用Map集合

// taskService.complete(taskId, variables)//完成任务的同时,设置流程变量,用Map集合

/** 获取流程变量 */

// runtimeService.getVariable(executionId,

// variableName);//使用执行对象ID和流程变量的名称,获取流程变量的值

// runtimeService.getVariables(executionId);//使用执行对象ID,获取所有的流程变量,将流程变量放置到Map集合中,map集合的key就是流程变量的名称,map集合的value就是流程变量的值

// runtimeService.getVariables(executionId,

// variableNames);//使用执行对象ID,获取流程变量的值,通过设置流程变量的名称存放到集合中,获取指定流程变量名称的流程变量的值,值存放到Map集合中

// taskService.getVariable(taskId,

// variableName);//使用任务ID和流程变量的名称,获取流程变量的值

// taskService.getVariables(taskId);//使用任务ID,获取所有的流程变量,将流程变量放置到Map集合中,map集合的key就是流程变量的名称,map集合的value就是流程变量的值

// taskService.getVariables(taskId,

// variableNames);//使用任务ID,获取流程变量的值,通过设置流程变量的名称存放到集合中,获取指定流程变量名称的流程变量的值,值存放到Map集合中

}

/** 完成我的任务 */

@Test

public void completeMyPersonalTask() {

// 任务ID

String taskId = "2402";

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

.complete(taskId);

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

}

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

@Test

public void findHistoryProcessVariables() {

Listlist = 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("###############################################");

}

}

}

}

九、HistoryQuery

代码:【

package test.e_historyQuery;

import java.util.List;

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.ProcessEngines;

import org.activiti.engine.history.HistoricActivityInstance;

import org.activiti.engine.history.HistoricProcessInstance;

import org.activiti.engine.history.HistoricTaskInstance;

import org.activiti.engine.history.HistoricVariableInstance;

import org.junit.Test;

public class HistoryQueryTest {

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

/**查询历史流程实例*/

@Test

public void findHistoryProcessInstance(){

String processInstanceId = "2101";

HistoricProcessInstance hpi = processEngine.getHistoryService()//与历史数据(历史表)相关的Service

.createHistoricProcessInstanceQuery()//创建历史流程实例查询

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

.orderByProcessInstanceStartTime().asc()

.singleResult();

System.out.println(hpi.getId()+" "+hpi.getProcessDefinitionId()+" "+hpi.getStartTime()+" "+hpi.getEndTime()+" "+hpi.getDurationInMillis());

}

/**查询历史活动*/

@Test

public void findHistoryActiviti(){

String processInstanceId = "2101";

Listlist = processEngine.getHistoryService()//

.createHistoricActivityInstanceQuery()//创建历史活动实例的查询

.processInstanceId(processInstanceId)//

.orderByHistoricActivityInstanceStartTime().asc()//

.list();

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

for(HistoricActivityInstance hai:list){

System.out.println(hai.getId()+" "+hai.getProcessInstanceId()+" "+hai.getActivityType()+" "+hai.getStartTime()+" "+hai.getEndTime()+" "+hai.getDurationInMillis());

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

}

}

}

/**查询历史任务*/

@Test

public void findHistoryTask(){

String processInstanceId = "2101";

Listlist = processEngine.getHistoryService()//与历史数据(历史表)相关的Service

.createHistoricTaskInstanceQuery()//创建历史任务实例查询

.processInstanceId(processInstanceId)//

.orderByHistoricTaskInstanceStartTime().asc()

.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("################################");

}

}

}

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

@Test

public void findHistoryProcessVariables(){

String processInstanceId = "2101";

Listlist = processEngine.getHistoryService()//

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

.processInstanceId(processInstanceId)//

.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("###############################################");

}

}

}

}

十、SequenceFlow

代码:【

package test.f_sequenceFlow;

import java.io.InputStream;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.ProcessEngines;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.runtime.ProcessInstance;

import org.activiti.engine.task.Task;

import org.junit.Test;

public class SequenceFlowTest {

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

/**部署流程定义(从inputStream)*/

@Test

public void deploymentProcessDefinition_inputStream(){

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

}

/**启动流程实例*/

@Test

public void startProcessInstance(){

//流程定义的key

String processDefinitionKey = "sequenceFlow";

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

}

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

@Test

public void findMyPersonalTask(){

String assignee = "赵六";

Listlist = 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("########################################################");

}

}

}

/**完成我的任务*/

@Test

public void completeMyPersonalTask(){

//任务ID

String taskId = "3103";

//完成任务的同时,设置流程变量,使用流程变量用来指定完成任务后,下一个连线,对应sequenceFlow.bpmn文件中${message=='不重要'}

Mapvariables = new HashMap();

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

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

.complete(taskId,variables);

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

}

}

十一、ExclusiveGateWay

代码:【

package test.g_exclusiveGateWay;

import java.io.InputStream;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.ProcessEngines;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.runtime.ProcessInstance;

import org.activiti.engine.task.Task;

import org.junit.Test;

public class ExclusiveGateWayTest {

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

}

/**启动流程实例*/

@Test

public void startProcessInstance(){

//流程定义的key

String processDefinitionKey = "exclusiveGateWay";

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

}

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

@Test

public void findMyPersonalTask(){

String assignee = "王小五";

Listlist = 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("########################################################");

}

}

}

/**完成我的任务*/

@Test

public void completeMyPersonalTask(){

//任务ID

String taskId = "3904";

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

Mapvariables = new HashMap();

variables.put("money", 200);

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

.complete(taskId,variables);

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

}

}

十二、ParallelGateWay

代码:【

package test.h_parallelGateWay;

import java.io.InputStream;

import java.util.List;

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.ProcessEngines;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.runtime.ProcessInstance;

import org.activiti.engine.task.Task;

import org.junit.Test;

public class ParallelGateWayTest {

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

}

/**启动流程实例*/

@Test

public void startProcessInstance(){

//流程定义的key

String processDefinitionKey = "parallelGateWay";

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

}

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

@Test

public void findMyPersonalTask(){

String assignee = "商家";

Listlist = 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("########################################################");

}

}

}

/**完成我的任务*/

@Test

public void completeMyPersonalTask(){

//任务ID

String taskId = "4302";

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

.complete(taskId);

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

}

}

十三、Start

代码:【

package test.i_start;

import java.io.InputStream;

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.ProcessEngines;

import org.activiti.engine.history.HistoricProcessInstance;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.runtime.ProcessInstance;

import org.junit.Test;

public class StartTest {

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

/**部署流程定义(从inputStream)*/

@Test

public void deploymentProcessDefinition_inputStream(){

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

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

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

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

.name("开始活动")//添加部署的名称

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

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

.deploy();//完成部署

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

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

}

/**启动流程实例+判断流程是否结束+查询历史*/

@Test

public void startProcessInstance(){

//流程定义的key

String processDefinitionKey = "start";

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

/**判断流程是否结束,查询正在执行的执行对象表*/

ProcessInstance rpi = processEngine.getRuntimeService()//

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

.processInstanceId(pi.getId())

.singleResult();

//说明流程实例结束了

if(rpi==null){

/**查询历史,获取流程的相关信息*/

HistoricProcessInstance hpi = processEngine.getHistoryService()//

.createHistoricProcessInstanceQuery()//

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

.singleResult();

System.out.println(hpi.getId()+" "+hpi.getStartTime()+" "+hpi.getEndTime()+" "+hpi.getDurationInMillis());

}

}

}

十四、ReceiveTask

代码:【

import java.io.InputStream;

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.ProcessEngines;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.runtime.Execution;

import org.activiti.engine.runtime.ProcessInstance;

import org.junit.Test;

public class ReceiveTaskTest {

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

/**部署流程定义(从inputStream)*/

@Test

public void deploymentProcessDefinition_inputStream(){

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

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

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

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

.name("接收活动任务")//添加部署的名称

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

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

.deploy();//完成部署

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

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

}

/**启动流程实例+设置流程变量+获取流程变量+向后执行一步*/

@Test

public void startProcessInstance(){

//流程定义的key

String processDefinitionKey = "receiveTask";

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*/

Execution execution1 = processEngine.getRuntimeService()//

.createExecutionQuery()//创建执行对象查询

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

.activityId("receivetask1")//当前活动的id,对应receiveTask.bpmn文件中的活动节点id的属性值

.singleResult();

/**使用流程变量设置当日销售额,用来传递业务参数*/

processEngine.getRuntimeService()//

.setVariable(execution1.getId(), "汇总当日销售额", 21000);

/**向后执行一步,如果流程处于等待状态,使得流程继续执行*/

processEngine.getRuntimeService()

.signal(execution1.getId());

/**查询执行对象ID*/

Execution execution2 = processEngine.getRuntimeService()//

.createExecutionQuery()//创建执行对象查询

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

.activityId("receivetask2")//当前活动的id,对应receiveTask.bpmn文件中的活动节点id的属性值

.singleResult();

/**从流程变量中获取汇总当日销售额的值*/

Integer value = (Integer)processEngine.getRuntimeService()//

.getVariable(execution2.getId(), "汇总当日销售额");

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

/**向后执行一步,如果流程处于等待状态,使得流程继续执行*/

processEngine.getRuntimeService()

.signal(execution2.getId());

}

}

十五、Task

代码:【

package test.k_personalTask;

import java.io.InputStream;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.ProcessEngines;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.runtime.ProcessInstance;

import org.activiti.engine.task.Task;

import org.junit.Test;

public class TaskTest {

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

/**部署流程定义(从inputStream)*/

@Test

public void deploymentProcessDefinition_inputStream(){

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

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

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

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

.name("任务")//添加部署的名称

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

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

.deploy();//完成部署

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

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

}

/**启动流程实例*/

@Test

public void startProcessInstance(){

//流程定义的key

String processDefinitionKey = "task";

/**启动流程实例的同时,设置流程变量,使用流程变量用来指定任务的办理人,对应task.pbmn文件中#{userID}*/

Mapvariables = new HashMap();

variables.put("userID", "周芷若");

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

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

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

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

}

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

@Test

public void findMyPersonalTask(){

String assignee = "周芷若";

Listlist = 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("########################################################");

}

}

}

/**完成我的任务*/

@Test

public void completeMyPersonalTask(){

//任务ID

String taskId = "5505";

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

.complete(taskId);

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

}

}

十六、group

代码:【

package test.l_group;

import java.io.InputStream;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.activiti.engine.ProcessEngine;

import org.activiti.engine.ProcessEngines;

import org.activiti.engine.history.HistoricIdentityLink;

import org.activiti.engine.repository.Deployment;

import org.activiti.engine.runtime.ProcessInstance;

import org.activiti.engine.task.IdentityLink;

import org.activiti.engine.task.Task;

import org.junit.Test;

public class TaskTest {

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

/**部署流程定义(从inputStream)*/

@Test

public void deploymentProcessDefinition_inputStream(){

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

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

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

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

.name("任务")//添加部署的名称

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

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

.deploy();//完成部署

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

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

}

/**启动流程实例*/

@Test

public void startProcessInstance(){

//流程定义的key

String processDefinitionKey = "task";

/**启动流程实例的同时,设置流程变量,使用流程变量用来指定任务的办理人,对应task.pbmn文件中#{userIDs}*/

Mapvariables = new HashMap();

variables.put("userIDs", "大大,中中,小小");

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

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

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

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

}

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

@Test

public void findMyPersonalTask(){

String assignee = "小A";

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

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

/**查询条件(where部分)*/

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

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

/**排序*/

.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("########################################################");

}

}

}

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

@Test

public void findMyGroupTask(){

String candidateUser = "大大";

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

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

/**查询条件(where部分)*/

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

/**排序*/

.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("########################################################");

}

}

}

/**完成我的任务*/

@Test

public void completeMyPersonalTask(){

//任务ID

String taskId = "6905";

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

.complete(taskId);

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

}

/**查询正在执行的任务办理人表*/

@Test

public void findRunPersonTask(){

//任务ID

String taskId = "6204";

Listlist = processEngine.getTaskService()//

.getIdentityLinksForTask(taskId);

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

for(IdentityLink identityLink:list){

System.out.println(identityLink.getTaskId()+" "+identityLink.getType()+" "+identityLink.getProcessInstanceId()+" "+identityLink.getUserId());

}

}

}

/**查询历史任务的办理人表*/

@Test

public void findHistoryPersonTask(){

//流程实例ID

String processInstanceId = "6201";

Listlist = processEngine.getHistoryService()//

.getHistoricIdentityLinksForProcessInstance(processInstanceId);

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

for(HistoricIdentityLink identityLink:list){

System.out.println(identityLink.getTaskId()+" "+identityLink.getType()+" "+identityLink.getProcessInstanceId()+" "+identityLink.getUserId());

}

}

}

/**拾取任务,将组任务分给个人任务,指定任务的办理人字段*/

@Test

public void claim(){

//将组任务分配给个人任务

//任务ID

String taskId = "6905";

//分配的个人任务(可以是组任务中的成员,也可以是非组任务的成员)

String userId = "大大";

processEngine.getTaskService()//

.claim(taskId, userId);

}

/**将个人任务回退到组任务,前提,之前一定是个组任务*/

@Test

public void setAssigee(){

//任务ID

String taskId = "6204";

processEngine.getTaskService()//

.setAssignee(taskId, null);

}

/**向组任务中添加成员*/

@Test

public void addGroupUser(){

//任务ID

String taskId = "6204";

//成员办理人

String userId = "大H";

processEngine.getTaskService()//

.addCandidateUser(taskId, userId);

}

/**从组任务中删除成员*/

@Test

public void deleteGroupUser(){

//任务ID

String taskId = "6204";

//成员办理人

String userId = "小B";

processEngine.getTaskService()//

.deleteCandidateUser(taskId, userId);

}

}

工作流activiti eclipse 插件不自动生成png

步骤:

window

——> preferences

——>activiti

——>save

——>选中create process definition image when saving the diagram


发表评论

全国咨询电话:400-611-6270,双休日及节假日请致电值班手机:15010390966

在线咨询: 曹老师QQ(3337544669), 徐老师QQ(1462495461), 刘老师 QQ(3108687497)

企业培训洽谈专线:010-82600901,院校合作洽谈专线:010-82600350,在线咨询:QQ(248856300)

Copyright 2004-2018 华清远见教育集团 版权所有 ,京ICP备16055225号,京公海网安备11010802025203号