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="//www.springframework.org/schema/context" xmlns:tx="//www.springframework.org/schema/tx"
xmlns:xsi="//www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="//www.springframework.org/schema/beans //www.springframework.org/schema/beans/spring-beans.xsd
//www.springframework.org/schema/context //www.springframework.org/schema/context/spring-context-2.5.xsd
//www.springframework.org/schema/tx //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
