java框架复习——Activiti工作流

最新推荐文章于 2024-05-17 02:15:01 发布

ww0peo

最新推荐文章于 2024-05-17 02:15:01 发布

阅读量1.7k

点赞数 3

分类专栏： java基础复习

本文链接：https://blog.csdn.net/qq_35262405/article/details/98396719

版权

java基础复习专栏收录该内容

34 篇文章 0 订阅

订阅专栏

工作流概述

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

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

工作流管理联盟(WfMC，Workflow Management Coalition)给出的关于工作流管理系统的定义是：工作流管理系统是一个软件系统，它通过执行经过计算的流程定义去支持一批专门设定的业务流程。工作流管理系统被用来定义、管理、和执行工作流程。

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

Activiti概述

Activiti5是由Alfresco软件在2010年5月17日发布的业务流程管理（BPM）框架，它是覆盖了业务流程管理、工作流、服务协作等领域的一个开源的、灵活的、易扩展的可执行流程语言框架。

Activiti基于Apache许可的开源BPM平台，创始人Tom Baeyens是JBoss jBPM的项目架构师，它特色是提供了eclipse插件，开发人员可以通过插件直接绘画出业务流程图。

工作流引擎

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

BPMN

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

数据库

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

ACT_RE_*：'RE’表示repository。这个前缀的表包含了流程定义和流程静态资源（图片，规则，等等）。
ACT_RU_*：'RU’表示runtime。这些运行时的表，包含流程实例，任务，变量，异步任务，等运行中的数据。 Activiti只在流程实例执行过程中保存这些数据，在流程结束时就会删除这些记录。这样运行时表可以一直很小速度很快。
ACT_ID_*：'ID’表示identity。这些表包含身份信息，比如用户，组等等。
ACT_HI_*：'HI’表示history。这些表包含历史数据，比如历史流程实例，变量，任务等等。
ACT_GE_*：通用数据，用于不同场景下，如存放资源文件。

资源库流程规则表

act_re_deployment 部署信息表
act_re_model 流程设计模型部署表
act_re_procdef 流程定义数据表

运行时数据库表

act_ru_execution 运行时流程执行实例表
act_ru_identitylink 运行时流程人员表，主要存储任务节点与参与者的相关信息
act_ru_task 运行时任务节点表
act_ru_variable 运行时流程变量数据表

历史数据库表

act_hi_actinst 历史节点表
act_hi_attachment 历史附件表
act_hi_comment 历史意见表
act_hi_identitylink 历史流程人员表
act_hi_detail 历史详情表，提供历史变量的查询
act_hi_procinst 历史流程实例表
act_hi_taskinst 历史任务实例表
act_hi_varinst 历史变量表

组织机构表

act_id_group 用户组信息表
act_id_info 用户扩展信息表
act_id_membership 用户与用户组对应信息表
act_id_user 用户信息表

通用数据表

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

activiti.cfg.xml（activiti的配置文件）

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

jdbcUrl: 数据库的JDBC URL。
jdbcDriver: 对应不同数据库类型的驱动。
jdbcUsername: 连接数据库的用户名。
jdbcPassword: 连接数据库的密码。基于JDBC参数配置的数据库连接会使用默认的MyBatis连接池。下面的参数可以用来配置连接池（来自MyBatis参数）：
jdbcMaxActiveConnections: 连接池中处于被使用状态的连接的最大值。默认为10。
jdbcMaxIdleConnections: 连接池中处于空闲状态的连接的最大值。
jdbcMaxCheckoutTime: 连接被取出使用的最长时间，超过时间会被强制回收。默认为20000（20秒）。
jdbcMaxWaitTime: 这是一个底层配置，让连接池可以在长时间无法获得连接时，打印一条日志，并重新尝试获取一个连接。（避免因为错误配置导致沉默的操作失败）。默认为20000（20秒）。

示例
在这里插入图片描述
也可以使用javax.sql.DataSource。（比如，Apache Commons的DBCP）：

logging.properties（日志处理）

日志的配置文件，Activiti操作数据库的时候，整合的日志文件

准备环境

引入依赖

    <!--- Activiti依赖导入 -->
    <dependency>
      <groupId>org.activiti</groupId>
      <artifactId>activiti-spring</artifactId>
      <version>5.18.0</version>
    </dependency>
    <dependency>
      <groupId>org.activiti</groupId>
      <artifactId>activiti-engine</artifactId>
      <version>5.18.0</version>
      <exclusions>
        <exclusion>
          <artifactId>slf4j-api</artifactId>
          <groupId>org.slf4j</groupId>
        </exclusion>
        <exclusion>
          <artifactId>spring-beans</artifactId>
          <groupId>org.springframework</groupId>
        </exclusion>
        <exclusion>
          <artifactId>jackson-core-asl</artifactId>
          <groupId>org.codehaus.jackson</groupId>
        </exclusion>
        <exclusion>
          <artifactId>commons-lang3</artifactId>
          <groupId>org.apache.commons</groupId>
        </exclusion>
        <exclusion>
          <artifactId>commons-lang3</artifactId>
          <groupId>org.apache.commons</groupId>
        </exclusion>
      </exclusions>
    </dependency>
    <!--MySQL 驱动包，如果是其他库的话需要更改驱动包-->
    <!--注意版本号，版本号必须一致，网上有查询数据库版本号的方法-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.0.8</version>
    </dependency>

初始化数据库

可以通过纯java代码初始化数据库
在这里插入图片描述
在Activiti中，在创建核心的流程引擎对象时会自动建表。如果程序正常执行，mysql会自动建库，然后创建23张表。

在Actiiti5中定制流程必定会操作到数据库，如果都像上面那样写一大段代码会非常麻烦，所以我们可以把数据库连接配置写入配置文件。

一个类似spring结构的配置文件，清空内容后改名为activiti.cfg.xml，用来做流程引擎的相关配置。

按照上面代码配置ProcessEngineConfiguration对象，主要定义数据库的连接配置和建表策略，配置文件代码如下：
在这里插入图片描述
Java代码如下：
createProcessEngineConfigurationFromResource的参数值为我们添加的配置文件activiti.cfg.xml的名称，执行java代码，流程引擎对象创建成功运行后数据库会自动建表。

idea的创建流程

核心API

ProcessEngine

在Activiti中最核心的类，其他的类都是由他而来。
产生方式：

ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();

ProcessEngine process = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml")
                .buildProcessEngine();

在前面看到了两种创建ProcessEngine（流程引擎）的方式，而这里要简化很多，调用ProcessEngines的getDefaultProceeEngine方法时会自动加载classpath下名为activiti.cfg.xml文件。

可以产生RepositoryService

RepositoryService repositoryService = process.getRepositoryService();

可以产生RuntimeService

RuntimeService runtimeService = process.getRuntimeService();

可以产生TaskService

TaskService taskService = process.getTaskService();

可以产生HistoryService

HistoryService historyService = process.getHistoryService();

各个Service的作用：

service	作用
RepositoryService	管理流程定义
RuntimeService	执行管理，包括启动、推进、删除流程实例等操作
TaskService	任务管理
HistoryService	历史管理(执行完的数据的管理)
IdentityService	组织机构管理
FormService	一个可选服务，任务表单管理
ManagerService

RepositoryService

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

产生方式

RepositoryService repositoryService = process.getRepositoryService();

可以产生DeploymentBuilder，用来定义流程部署的相关参数

DeploymentBuilder deployment = repositoryService.createDeployment();

删除流程定义

repositoryService.deleteDeployment(deploymentId);

RuntimeService

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

TaskService

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

HistoryService

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

ProcessDefinition

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

ProcessInstance

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

Execution

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

如图为ProcessInstance的源代码：
在这里插入图片描述
从源代码中可以看出ProcessInstance就是Execution。但在现实意义上有所区别：

在单线流程中，如上图的贷款流程，ProcessInstance与Execution是一致的。

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

总结：

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

Activiti的HelloWorld程序（模拟流程的执行）

流程图

在这里插入图片描述

部署流程定义

	@Test
	public void delpoyActiviti() {
		//创建部署对象
		DeploymentBuilder deploymentBuilder = repositoryService.createDeployment();
		//加载流程的配置文件和图片
		deploymentBuilder.addClasspathResource("diagrams2/activit_leave.bpmn")
						 .name("请假流程")
						 .category("请假")
						.addClasspathResource("diagrams2/activit_leave.png");
		//部署流程
		deploymentBuilder.deploy();
	}

这里使用RepositoryService部署流程定义
addClasspathResource表示从类路径下加载资源文件，一次只能加载一个文件

启动流程实例

@Test
	public void startProcess() {
	runtimeService.startProcessInstanceByKey("activit_leave");
}

这里使用RuntimeService启动流程实例

查看我的个人任务

	@Test
	public void queryTaksByAssignee() {
		String assignee = "boss";
		List<Task> taskList = taskService.createTaskQuery()//创建任务查询对象
		.processDefinitionKey("activit_leave")//根据流程定义的key来查询
		.taskAssignee(assignee)//根据办理人来查询
		.orderByTaskCreateTime()//根据时间倒序
		.desc()
		.list();
		
		for(Task task : taskList){
			System.out.println("任务的ID："+task.getId());
			System.out.println("任务的名字："+task.getName());
			System.out.println("任务的创建时间："+task.getCreateTime());
			System.out.println("办理人："+task.getAssignee());
		}
		
	}

这里使用TaskService完成任务的查询

完成我的个人任务

	@Test
	public void completeTaksByAssignee() {
		String assignee = "boss";
		List<Task> taskList = taskService.createTaskQuery()//创建任务查询对象
		.processDefinitionKey("activit_leave")//根据流程定义的key来查询
		.taskAssignee(assignee)//根据办理人来查询
		.orderByTaskCreateTime()//根据时间倒序
		.desc()
		.list();
		
		//拿到第一个任务
		Task task = taskList.get(0);
		//使用任务服务接口来办理任务
		taskService.complete(task.getId());
	}

这里使用TaskService完成任务的办理

管理流程定义

在这里插入图片描述

设计流程定义文档

流程图

在这里插入图片描述

bpmn文件

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

一个空的流程定义看起来像下面这样。注意，definitions元素最少也要包含xmlns 和 targetNamespace的声明。 targetNamespace可以是任意值，它用来对流程实例进行分类。
在这里插入图片描述
说明：流程定义文档有两部分组成：

bpmn文件

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

展示流程图的图片

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

部署流程定义（classpath路径加载文件）

在这里插入图片描述

先获取流程引擎对象：在创建时会自动加载classpath下得activiti.cfg.xml
首先获得默认的流程引擎，通过流程引擎获取了一个RepositoryService对象（仓库对象）
由仓库的服务对象产生一个部署对象配置对象，用来封装部署操作的相关配置。
这是一个链式编程，在部署配置对象中设置显示名，上传流程定义规则文件
向数据库表中存放流程定义的规则信息。
这一步在数据库中将操作三张表：
- act_re_deployment（部署对象表）
  存放流程定义的显示名和部署时间，每部署一次增加一条记录
- act_re_procdef（流程定义表）
  存放流程定义的属性信息，部署每个新的流程定义都会在这张表中增加一条记录。
  注意：当流程定义的key相同的情况下，使用的是版本升级
- act_ge_bytearray（资源文件表）

存储流程定义相关的部署信息，即流程定义文档的存放地。

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

部署流程定义（zip格式文件）

在这里插入图片描述

压缩成zip格式的文件，使用zip的输入流用作部署流程定义

查看流程定义

	/**
	 * 根据流程定义的ID来查询流程定义对象
	 */
	@Test
	public void queryProcessDefinitionById() {
		String processDefinitionId = "activit_leave:1:4";
		ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()//创建流程定义查询对象
						.processDefinitionId(processDefinitionId)//根据id来查询
						.singleResult();//得到唯一结果
		System.out.println("流程定义的Id："+processDefinition.getId());
		System.out.println("流程定义的key："+processDefinition.getKey());
		System.out.println("流程定义的名字："+processDefinition.getName());
		System.out.println("流程定义的资源文件名字："+processDefinition.getResourceName());
	}

程定义和部署对象相关的Service都是RepositoryService。
创建流程定义查询对象，可以在ProcessDefinitionQuery上设置查询的相关参数
调用ProcessDefinitionQuery对象的list方法，执行查询，获得符合条件的流程定义列表
由运行结果可以看出：
Key和Name的值为：bpmn文件process节点的id和name的属性值
key属性被用来区别不同的流程定义。
带有特定key的流程定义第一次部署时，version为1。之后每次部署都会在当前最高版本号上加1
Id的值的生成规则为:{processDefinitionKey}:{processDefinitionVersion}:{generated-id}, 这里的generated-id是一个自动生成的唯一的数字
重复部署一次，deploymentId的值以一定的形式变化
规则act_ge_property表生成

删除流程定义

	/**
	 * 删除流程部署
	 */
	@Test
	public void deleteActivitiDeploy() {
		
		String deploymentId = "201";
		//如果流程已经启动删除会报错
		//repositoryService.deleteDeployment(deploymentId);
		
		//如果第二个参数是true级联删除，即使有正在运行的数据也会被删除，如果是false非级联删除如果有数据在运行，会报错
		repositoryService.deleteDeployment(deploymentId, true);
	}

因为删除的是流程定义，而流程定义的部署是属于仓库服务的，所以应该先得到RepositoryService
如果该流程定义下没有正在运行的流程，则可以用普通删除。如果是有关联的信息，用级联删除。项目开发中使用级联删除的情况比较多，删除操作一般只开放给超级管理员使用。

获取流程定义文档的资源（查看流程图附件）

查询出流程定义文档。主要查的是图片，用于显示流程用。
在这里插入图片描述

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

查询最新版本的流程定义

在这里插入图片描述

删除流程定义（删除key相同的所有不同版本的流程定义）

在这里插入图片描述

流程实例、任务的执行

在这里插入图片描述

流程图

在这里插入图片描述

部署流程定义

在这里插入图片描述

启动流程实例

在这里插入图片描述
当流程实例产生后会在act_ru_execution表中产生一条数据，代表正在执行的流程对象

需要理解的字段：

ID_：正在执行的流程对象的ID
PROCE_INST_ID_：流程实例ID
PROCE_DEF_ID：流程定义的ID
ACT_ID_：执行到的任务节点ID

在流程流程实例的历史表中也会产生一条数据
在这里插入图片描述
需要理解的字段：

ID_：正在执行的流程对象的ID
PROCE_INST_ID_：流程实例ID
PROCE_DEF_ID：流程定义的ID
ACT_ID_：执行到的任务节点ID
START_TIME_：流程开始的时间
END_TIME_：流程结束时间

流程实例启动后act_ru_task表中会有一条数据 在这里插入图片描述
需要理解的字段：

ID_：任务 ID
EXECUTION_ID_：正在执行的流程对象ID
PROC_INST_ID：流程实例的ID
PROC_DEF_ID_：流程定义ID
NAME：当前任务节点的名称
TASK_DEF_KEY：当前任务节点的ID
CREATE_TIME：任务节点的创建时间
ASSIGNEE：当前任务的分配人

任务的历史表中会有一条数据
在这里插入图片描述
需要理解的字段同上

所有活动历史表里面会有数据
在这里插入图片描述

查询我的个人任务

在这里插入图片描述

因为是任务查询，所以从processEngine中应该得到TaskService
使用TaskService获取到任务查询对象TaskQuery
为查询对象添加查询过滤条件，使用taskAssignee指定任务的办理者（即查询指定用户的代办任务），同时可以添加分页排序等过滤条件
调用list方法执行查询，返回办理者为指定用户的任务列表
任务ID、名称、办理人、创建时间可以从act_ru_task表中查到。
Execution与ProcessInstance见5.6和5.7章节的介绍。在这种情况下，ProcessInstance相当于Execution
如果assignee属性为部门经理，结果为空。因为现在流程只到了”填写请假申请”阶段，后面的任务还没有执行，即在数据库中没有部门经理可以办理的任务，所以查询不到。
一个Task节点和Execution节点是1对1的情况，在task对象中使用Execution_来标示他们之间的关系
任务ID在数据库表act_ru_task中对应“ID_”列

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

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

办理任务

在这里插入图片描述

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

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

在这里插入图片描述
在流程执行的过程中，创建的流程实例ID在整个过程中都不会变，当流程结束后，流程实例将会在正在执行的执行对象表中（act_ru_execution）被删除。

因为是查询流程实例，所以先获取runtimeService
创建流程实例查询对象，设置实例ID过滤参数
由于一个流程实例ID只对应一个实例，使用singleResult执行查询返回一个唯一的结果，如果结果数量大于1，则抛出异常
判断指定ID的实例是否存在，如果结果为空，则代表流程结束，实例在正在执行的执行对象表中已被删除，转换成历史数据。

流程变量

流程变量在整个工作流中扮演很重要的作用。例如：请假流程中有请假天数、请假原因等一些参数都为流程变量的范围。

流程变量的作用域范围是只对应一个流程实例。也就是说各个流程实例的流程变量是不相互影响的。流程实例结束完成以后流程变量还保存在数据库中（存放到流程变量的历史表中）。
在这里插入图片描述

流程图

在这里插入图片描述

部署流程定义

在这里插入图片描述

启动流程实例

在这里插入图片描述

设置流程变量

在这里插入图片描述

流程变量的作用域就是流程实例，所以只要设置就行了，不用管在哪个阶段设置
基本类型设置流程变量，在taskService中使用任务ID，定义流程变量的名称，设置流程变量的值。
Javabean类型设置流程变量，需要这个javabean实现了Serializable接口
设置流程变量的时候，向act_ru_variable这个表添加数据

获取流程变量

在这里插入图片描述

流程变量的获取针对流程实例（即1个流程），每个流程实例获取的流程变量时不同的
使用基本类型获取流程变量，在taskService中使用任务ID，流程变量的名称，获取流程变量的值。
Javabean类型设置获取流程变量，除了需要这个javabean实现了Serializable接口外，还要求流程变量对象的属性不能发生编号，否则抛出异常。

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

在这里插入图片描述

RuntimeService对象可以设置流程变量和获取流程变量
taskService对象可以设置流程变量和获取流程变量
流程实例启动的时候可以设置流程变量
任务办理完成的时候可以设置流程变量
流程变量可以通过名称/值的形式设置单个流程变量
流程变量可以通过Map集合，同时设置多个流程变量

Map集合的key表示流程变量的名称
Map集合的value表示流程变量的值

查询历史的流程变量

在这里插入图片描述

历史的流程变量查询，指定流程变量的名称，查询act_hi_varinst表（也可以针对，流程实例ID，执行对象ID，任务ID查询）

流程变量的支持的类型

如图是从官网列出来的流程变量的类型：
在这里插入图片描述
从图中可以看出包括了大部分封装类型和Date、String和实现了Serializable接口的类的类型。

流程执行历史记录

查询历史流程实例

在这里插入图片描述

	/**
	 * 查询历史的流程实例
	 */
	@Test
	public void selectHistoryProcessInstance() {
		List<HistoricProcessInstance> historicProcessInstanceList = historyService
				.createHistoricProcessInstanceQuery()//创建查询历史流程实例的对象
		.processDefinitionKey("activit_leave")
		.orderByProcessInstanceEndTime()
		.desc()
		.list();
		
		for(HistoricProcessInstance historicProcessInstance : historicProcessInstanceList){
			System.out.println("历史流程实例ID："+historicProcessInstance.getId());
			System.out.println("历史流程实例完成时间："+historicProcessInstance.getEndTime());
		}
		
	}

查询历史活动

在这里插入图片描述

	/**
	 * 查询当前的流程实例所经历所有的活动
	 */
	@Test
	public void selectHistoryActivityInstance() {
		List<HistoricActivityInstance> HistoricActivityInstance = historyService.createHistoricActivityInstanceQuery()
		.processInstanceId("3001")
		//.activityType("userTask")
		.list();
		
		for(HistoricActivityInstance historicActivityInstance : HistoricActivityInstance){
			System.out.println("历史活动ID："+historicActivityInstance.getId());
			System.out.println("历史活动名称："+historicActivityInstance.getActivityName());
			System.out.println("办理人："+historicActivityInstance.getAssignee());
		}
		
	}

查询历史任务

在这里插入图片描述

	/**
	 * 根据办理人查询他的历史任务
	 */
	@Test
	public void selectHistoryTaskInstanceByAssignee() {
		List<HistoricTaskInstance> historicTaskInstanceList =  historyService.createHistoricTaskInstanceQuery()
		.processDefinitionKey("activit_leave")
		.taskAssignee("employnee")
		.list();
		
		for(HistoricTaskInstance historicTaskInstance : historicTaskInstanceList){
			System.out.println("历史任务ID："+historicTaskInstance.getId());
			System.out.println("历史活动名称："+historicTaskInstance.getName());
			System.out.println("结束时间："+historicTaskInstance.getEndTime());
			System.out.println("办理人："+historicTaskInstance.getAssignee());
			System.out.println("----------------------------------------------------");
		}
		
	}

查询历史流程变量

在这里插入图片描述

	/**
	 * 根据流程实例的ID来查询历史流程变量
	 */
	@Test
	public void selectHistoryVariable() {
		List<HistoricVariableInstance> historicVariableInstanceList = historyService
				.createHistoricVariableInstanceQuery()
				.processInstanceId("1001")
				.list();
		
		for(HistoricVariableInstance historicVariableInstance : historicVariableInstanceList){
			System.out.println("流程变量ID："+historicVariableInstance.getId());
			System.out.println("变量名："+historicVariableInstance.getVariableName());
			System.out.println("变量值："+historicVariableInstance.getValue());
			System.out.println("----------------------------------------------------");
		}
		
	}

分支连线

流程图

在这里插入图片描述

部署流程定义和启动流程实例

在这里插入图片描述

查询我的个人任务

在这里插入图片描述

完成任务

在这里插入图片描述 使用流程变量，设置连线需要的流程变量的名称message，并设置流程变量的值，流程会按照指定的连线完成任务。

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

如果有多个，则需要使用流程变量设置codition的名称。message表示流程变量的名称，‘不重要’表示流程变量的值，${}中间的内容要使用boolean类型的表达式，用来判断应该执行的连线。
在这里插入图片描述

排他网关（ExclusiveGateWay）

在这里插入图片描述

部署流程定义和启动流程实例

在这里插入图片描述

查询我的个人任务

在这里插入图片描述

完成我的个人任务

在这里插入图片描述

一个排他网关对应一个以上的顺序流
由排他网关流出的顺序流都有个conditionExpression元素，在内部维护返回boolean类型的决策结果。
决策网关只会返回一条结果。当流程执行到排他网关时，流程引擎会自动检索网关出口，从上到下检索如果发现第一条决策结果为true或者没有设置条件的(默认为成立)，则流出。
如果没有任何一个出口符合条件，则抛出异常
使用流程变量，设置连线的条件，并按照连线的条件执行工作流，如果没有条件符合的条件，则以默认的连线离开。例如：

则执行连线：

如果使用流程变量设置

则执行连线：

并行网关(parallelGateWay)

流程图

在这里插入图片描述

部署流程定义和启动流程实例

在这里插入图片描述

查询我的个人任务

在这里插入图片描述

一个流程中流程实例只有1个，执行对象有多个
并行网关的功能是基于进入和外出的顺序流的：
分支(fork)：并行后的所有外出顺序流，为每个顺序流都创建一个并发分支。
汇聚(join)：所有到达并行网关，在此等待的进入分支，直到所有进入顺序流的分支都到达以后，流程就会通过汇聚网关。
并行网关的进入和外出都是使用相同节点标识
如果同一个并行网关有多个进入和多个外出顺序流，它就同时具有分支和汇聚功能。这时，网关会先汇聚所有进入的顺序流，然后再切分成多个并行分支。
并行网关不会解析条件。即使顺序流中定义了条件，也会被忽略。
并行网关不需要是“平衡的”（比如，对应并行网关的进入和外出节点数目不一定相等）。如图中标示是合法的：

开始活动节点

结束节点没有出口
其他节点有一个或多个出口。
如果有一个出口，则代表是一个单线流程；
如果有多个出口，则代表是开启并发流程。

流程图

在这里插入图片描述

部署流程定义、启动流程实例、查询流程实例、查询历史流程实例

在这里插入图片描述

接收活动（receiveTask，即等待活动）

接收任务是一个简单任务，它会等待对应消息的到达。当前，官方只实现了这个任务的java语义。当流程达到接收任务，流程状态会保存到数据库中。

在任务创建后，意味着流程会进入等待状态，直到引擎接收了一个特定的消息，这会触发流程穿过接收任务继续执行。

流程图

在这里插入图片描述

部署流程定义和启动流程实例

/**
 * ReceiceTask任务，机器自动完成的任务
 * 只会在act_ru_execution表中产生一条数据
 * @throws Exception
 */

@Test
public void testExecution() throws Exception {
	// 1 发布流程
	InputStream inputStreamBpmn = this.getClass().getResourceAsStream("receiveTask.bpmn");
	InputStream inputStreamPng = this.getClass().getResourceAsStream("receiveTask.png");
	processEngine.getRepositoryService()//
					.createDeployment()//
					.addInputStream("receiveTask.bpmn", inputStreamBpmn)//
					.addInputStream("receiveTask.png", inputStreamPng)//
					.deploy();
	
	// 2 启动流程
	ProcessInstance pi = processEngine.getRuntimeService()//
						.startProcessInstanceByKey("receiveTaskDemo");
	System.out.println("pid:" + pi.getId());
	String pid = pi.getId();
	
	// 3查询是否有一个执行对象在描述”汇总当日销售额“
	Execution e1 = processEngine.getRuntimeService()//
					.createExecutionQuery()//
					.processInstanceId(pid)//
					.activityId("汇总当日销售额")//
					.singleResult();

	// 4执行一堆逻辑，并设置流程变量
	Map<String,Object> vars = new HashMap<String, Object>();
	vars.put("当日销售额", 10000);
	//  5流程向后执行一步：往后推移e1,使用signal给流程引擎信号，告诉他当前任务已经完成了，可以往后执行
	processEngine.getRuntimeService()
			.signal(e1.getId(),vars);
	
	// 6判断当前流程是否在”给老板发短信“节点
	Execution e2 = processEngine.getRuntimeService()//
					.createExecutionQuery()//
					.processInstanceId(pid)//
					.activityId("给总经理发短信")//
					.singleResult();
	
	// 7获取流程变量
	Integer money = (Integer) processEngine.getRuntimeService()//
							.getVariable(e2.getId(), "当日销售额");
	System.out.println("老板，今天赚了" +money);
	// 8向后执行一步：任务完成，往后推移”给老板发短信“任务
	processEngine.getRuntimeService()//
			.signal(e2.getId());
	
	
	// 9查询流程状态
    pi = processEngine.getRuntimeService()//
    				.createProcessInstanceQuery()//
    				.processInstanceId(pid)//
    				.singleResult();
    if(pi==null){
    	    System.out.println("流程正常执行！！！，已经结束了");
    }
}

当前任务（一般指机器自动完成，但需要耗费一定时间的工作）完成后，向后推移流程，可以调用runtimeService.signal(executionId)，传递接收执行对象的id。

用户任务（userTask，即用户操作的任务）

个人任务

在这里插入图片描述

流程图

在这里插入图片描述

分配个人任务方式一（直接指定办理人）

1.流程图中任务节点的配置
在这里插入图片描述
2.测试代码

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//部署流程定义，启动流程实例
	@Test
	public void testTask() throws Exception {
		
		// 1 发布流程
		InputStream inputStreamBpmn = this.getClass().getResourceAsStream("taskProcess.bpmn");
		InputStream inputStreamPng = this.getClass().getResourceAsStream("taskProcess.png");
		processEngine.getRepositoryService()//
						.createDeployment()//
						.addInputStream("userTask.bpmn", inputStreamBpmn)//
						.addInputStream("userTask.png", inputStreamPng)//
						.deploy();
		
		// 2 启动流程
		//启动流程实例的同时，设置流程变量
		ProcessInstance pi = processEngine.getRuntimeService()//
							.startProcessInstanceByKey("taskProcess");
		System.out.println("pid:" + pi.getId());
	}
	
//查询我的个人任务列表
	@Test
	public void findMyTaskList(){
		String userId = "张三丰";
		List<Task> list = processEngine.getTaskService()//
		                .createTaskQuery()//
		                .taskAssignee(userId)//指定个人任务查询
		                .list();
		for(Task task:list ){
			System.out.println("id="+task.getId());
			System.out.println("name="+task.getName());
			System.out.println("assinee="+task.getAssignee());
			System.out.println("createTime="+task.getCreateTime());
			System.out.println("executionId="+task.getExecutionId());
			
		}
	}
	
//完成任务
	@Test
	public void completeTask(){
		String taskId = "3209";
		processEngine.getTaskService()//
					.complete(taskId);//
		System.out.println("完成任务");
	}

张三丰是个人任务的办理人
但是这样分配任务的办理人不够灵活，因为项目开发中任务的办理人不要放置XML文件中。

分配个人任务方式二（使用流程变量）

1.流程图中任务节点的配置
在这里插入图片描述
2.测试代码

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//部署流程定义，启动流程实例
	@Test
	public void testTask() throws Exception {
		
		// 1 发布流程
		InputStream inputStreamBpmn = this.getClass().getResourceAsStream("taskProcess.bpmn");
		InputStream inputStreamPng = this.getClass().getResourceAsStream("taskProcess.png");
		processEngine.getRepositoryService()//
						.createDeployment()//
						.addInputStream("userTask.bpmn", inputStreamBpmn)//
						.addInputStream("userTask.png", inputStreamPng)//
						.deploy();
		
	// 2 启动流程
	//启动流程实例的同时，设置流程变量
		Map<String, Object> variables = new HashMap<String, Object>();
		variables.put("userID", "张翠三");
		ProcessInstance pi = processEngine.getRuntimeService()//
							.startProcessInstanceByKey("taskProcess",variables);
		System.out.println("pid:" + pi.getId());
	}
	
	//查询我的个人任务列表
	@Test
	public void findMyTaskList(){
		String userId = "张翠三";
		List<Task> list = processEngine.getTaskService()//
		                .createTaskQuery()//
		                .taskAssignee(userId)//指定个人任务查询
		                .list();
		for(Task task:list ){
			System.out.println("id="+task.getId());
			System.out.println("name="+task.getName());
			System.out.println("assinee="+task.getAssignee());
			System.out.println("createTime="+task.getCreateTime());
			System.out.println("executionId="+task.getExecutionId());
			
		}
	}
	
	//完成任务
	@Test
	public void completeTask(){
		String taskId = "3209";
		processEngine.getTaskService()//
					.complete(taskId);//
		System.out.println("完成任务");
	}

张翠山是个人任务的办理人
在开发中，可以在页面中指定下一个任务的办理人，通过流程变量设置下一个任务的办理人

分配个人任务方式三（使用监听器，常用）

1.流程图中任务节点的配置
在这里插入图片描述

此时流程图的XML文件，如图：

2.TaskListenerImpl类，用来设置任务的办理人

一定要实现TaskListener接口

public class TaskListenerImpl implements TaskListener {

	/**指定个人任务和组任务的办理人*/
	@Override
	public void notify(DelegateTask delegateTask) {
		String assignee = "张无忌";
		//指定个人任务
		delegateTask.setAssignee(assignee);
	}

}

3.测试代码

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
//部署流程定义，启动流程实例
	@Test
	public void testTask() throws Exception {
		
		// 1 发布流程
		InputStream inputStreamBpmn = this.getClass().getResourceAsStream("taskProcess.bpmn");
		InputStream inputStreamPng = this.getClass().getResourceAsStream("taskProcess.png");
		processEngine.getRepositoryService()//
						.createDeployment()//
						.addInputStream("userTask.bpmn", inputStreamBpmn)//
						.addInputStream("userTask.png", inputStreamPng)//
						.deploy();
		
		// 2 启动流程
		ProcessInstance pi = processEngine.getRuntimeService()//
							.startProcessInstanceByKey("taskProcess");
		System.out.println("pid:" + pi.getId());
	}
	
	//查询我的个人任务列表
	@Test
	public void findMyTaskList(){
		String userId = "张无忌";
		List<Task> list = processEngine.getTaskService()//
		                .createTaskQuery()//
		                .taskAssignee(userId)//指定个人任务查询
		                .list();
		for(Task task:list ){
			System.out.println("id="+task.getId());
			System.out.println("name="+task.getName());
			System.out.println("assinee="+task.getAssignee());
			System.out.println("createTime="+task.getCreateTime());
			System.out.println("executionId="+task.getExecutionId());
			
		}
	}
	
	//完成任务
	@Test
	public void completeTask(){
		String taskId = "3408";
		processEngine.getTaskService()//
					.complete(taskId);//
		System.out.println("完成任务");
	}

	//可以分配个人任务从一个人到另一个人（认领任务）
	@Test
	public void setAssigneeTask(){
		//任务ID
		String taskId = "3408";
		//指定认领的办理者
		String userId = "周芷若";
		processEngine.getTaskService()//
					.setAssignee(taskId, userId);
	}

在类中使用delegateTask.setAssignee(assignee)的方式分配个人任务的办理人，此时张无忌是下一个任务的办理人
通过processEngine.getTaskService().setAssignee(taskId, userId)将个人任务从一个人分配给另一个人，此时张无忌不再是下一个任务的办理人，而换成了周芷若
在开发中，可以将每一个任务的办理人规定好，例如张三的领导是李四，李四的领导是王五，这样张三提交任务，就可以查询出张三的领导是李四，通过类的方式设置下一个任务的办理人

组任务

在这里插入图片描述

流程图

在这里插入图片描述

分配组任务方式一（直接指定办理人）

1.流程图中任务节点的配置
在这里插入图片描述
2.测试代码

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
	
	//部署流程定义，启动流程实例
	@Test
	public void testTask() throws Exception {
		// 1 发布流程
		InputStream inputStreamBpmn = this.getClass().getResourceAsStream("taskProcess.bpmn");
		InputStream inputStreamPng = this.getClass().getResourceAsStream("taskProcess.png");
		processEngine.getRepositoryService()//
						.createDeployment()//
						.addInputStream("userTask.bpmn", inputStreamBpmn)//
						.addInputStream("userTask.png", inputStreamPng)//
						.deploy();
		// 2 启动流程
		ProcessInstance pi = processEngine.getRuntimeService()//
							.startProcessInstanceByKey("taskProcess");
		System.out.println("pid:" + pi.getId());
	}
	
	//3 查询我的个人任务列表
	@Test
	public void findMyTaskList(){
		String userId = "小A";
		List<Task> list = processEngine.getTaskService()//
		                .createTaskQuery()//
		                .taskAssignee(userId)//指定个人任务查询
		                .list();
		for(Task task:list ){
			System.out.println("id="+task.getId());
			System.out.println("name="+task.getName());
			System.out.println("assinee="+task.getAssignee());
			System.out.println("createTime="+task.getCreateTime());
			System.out.println("executionId="+task.getExecutionId());
			
		}
	}
	
	//4 查询组任务列表
	@Test
	public void findGroupList(){
		String userId = "小A";
		List<Task> list = processEngine.getTaskService()//
		                .createTaskQuery()//
		                .taskCandidateUser(userId)//指定组任务查询
		                .list();
		for(Task task:list ){
			System.out.println("id="+task.getId());
			System.out.println("name="+task.getName());
			System.out.println("assinee="+task.getAssignee());
			System.out.println("createTime ="+task.getCreateTime());
			System.out.println("executionId="+task.getExecutionId());
			System.out.println("##################################");
			
		}
	}
	
	//5 查询组任务成员列表
	@Test
	public void findGroupUser(){
		String taskId = "3709";
		List<IdentityLink> list = processEngine.getTaskService()//
		                .getIdentityLinksForTask(taskId);
         //List<IdentityLink> list = processEngine.getRuntimeService()//
		//				.getIdentityLinksForProcessInstance(instanceId);
		for(IdentityLink identityLink:list ){
			System.out.println("userId="+identityLink.getUserId());
			System.out.println("taskId="+identityLink.getTaskId());
			System.out.println("piId="+identityLink.getProcessInstanceId());
			System.out.println("######################");
		}
	}
	
	//6 查询组任务成员历史列表
	@Test
	public void findGroupHisUser(){
		String taskId = "3709";
		List<HistoricIdentityLink> list = processEngine.getHistoryService()//
						.getHistoricIdentityLinksForTask(taskId);
        // List<HistoricIdentityLink> list = processEngine.getHistoryService()//
          // .getHistoricIdentityLinksForProcessInstance(processInstanceId);
		for(HistoricIdentityLink identityLink:list ){
			System.out.println("userId="+identityLink.getUserId());
			System.out.println("taskId="+identityLink.getTaskId());
			System.out.println("piId="+identityLink.getProcessInstanceId());
			System.out.println("######################");
		}
	}
	
	//完成任务
	@Test
	public void completeTask(){
		String taskId = "3709";
		processEngine.getTaskService()//
					.complete(taskId);//
		System.out.println("完成任务");
	}

小A，小B，小C，小D是组任务的办理人
但是这样分配组任务的办理人不够灵活，因为项目开发中任务的办理人不要放置XML文件中。
act_ru_identitylink表存放任务的办理人，包括个人任务和组任务，表示正在执行的任务
act_hi_identitylink表存放任务的办理人，包括个人任务和组任务，表示历史任务

个人任务和组任务的区别：

如果是个人任务TYPE的类型表示participant（参与者）
如果是组任务TYPE的类型表示candidate（候选者）和participant（参与者）

在这里插入图片描述

分配个人任务方式二（使用流程变量）

1.流程图中任务节点的配置
在这里插入图片描述
2.测试代码

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
	
	//部署流程定义，启动流程实例
	@Test
	public void testTask() throws Exception {
		// 1 发布流程
		InputStream inputStreamBpmn = this.getClass().getResourceAsStream("taskProcess.bpmn");
		InputStream inputStreamPng = this.getClass().getResourceAsStream("taskProcess.png");
		processEngine.getRepositoryService()//
						.createDeployment()//
						.addInputStream("userTask.bpmn", inputStreamBpmn)//
						.addInputStream("userTask.png", inputStreamPng)//
						.deploy();
		// 2 启动流程
		//启动流程实例，同时设置流程变量，用来指定组任务的办理人
		Map<String, Object> variables = new HashMap<String, Object>();
		variables.put("userIDs", "大大,小小,中中");
		ProcessInstance pi = processEngine.getRuntimeService()//
						.startProcessInstanceByKey("taskProcess",variables);
		System.out.println("pid:" + pi.getId());
	}
	
	//查询我的个人任务列表
	@Test
	public void findMyTaskList(){
		String userId = "大大";
		List<Task> list = processEngine.getTaskService()//
		                .createTaskQuery()//
		                .taskAssignee(userId)//指定个人任务查询
		                .list();
		for(Task task:list ){
			System.out.println("id="+task.getId());
			System.out.println("name="+task.getName());
			System.out.println("assinee="+task.getAssignee());
			System.out.println("assinee="+task.getCreateTime());
			System.out.println("executionId="+task.getExecutionId());
			
		}
	}
	
	//查询组任务列表
	@Test
	public void findGroupList(){
		String userId = "大大";
		List<Task> list = processEngine.getTaskService()//
		                .createTaskQuery()//
		                .taskCandidateUser(userId)//指定组任务查询
		                .list();
		for(Task task:list ){
			System.out.println("id="+task.getId());
			System.out.println("name="+task.getName());
			System.out.println("assinee="+task.getAssignee());
			System.out.println("assinee="+task.getCreateTime());
			System.out.println("executionId="+task.getExecutionId());
			System.out.println("##################################");
			
		}
	}
	
	//查询组任务成员列表
	@Test
	public void findGroupUser(){
		String taskId = "3709";
		List<IdentityLink> list = processEngine.getTaskService()//
		                .getIdentityLinksForTask(taskId);
		for(IdentityLink identityLink:list ){
			System.out.println("userId="+identityLink.getUserId());
			System.out.println("taskId="+identityLink.getTaskId());
			System.out.println("piId="+identityLink.getProcessInstanceId());
			System.out.println("######################");
		}
	}
	
	//查询组任务成员历史列表
	@Test
	public void findGroupHisUser(){
		String taskId = "3709";
		List<HistoricIdentityLink> list = processEngine.getHistoryService()//
						.getHistoricIdentityLinksForTask(taskId);
		for(HistoricIdentityLink identityLink:list ){
			System.out.println("userId="+identityLink.getUserId());
			System.out.println("taskId="+identityLink.getTaskId());
			System.out.println("piId="+identityLink.getProcessInstanceId());
			System.out.println("######################");
		}
	}
	
	//完成任务
	@Test
	public void completeTask(){
		String taskId = "3709";
		processEngine.getTaskService()//
					.complete(taskId);//
		System.out.println("完成任务");
	}

大大，中中，小小是组任务的办理人
在开发中，可以在页面中指定下一个组任务的办理人，通过流程变量设置下一个任务的办理人

分配个人任务方式三（使用监听器）

1.流程图中任务节点的配置
在这里插入图片描述
此时流程图的XML文件，如图：

2.TaskListenerImpl类，用来设置任务的办理人

public class TaskListenerImpl implements TaskListener {

	/**指定个人任务和组任务的办理人*/
	@Override
	public void notify(DelegateTask delegateTask) {
		String userId1 = "孙悟空";
		String userId2 = "猪八戒";
		//指定组任务
		delegateTask.addCandidateUser(userId1);
		delegateTask.addCandidateUser(userId2);
	}

}
3：测试代码
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
	
	//部署流程定义，启动流程实例
	@Test
	public void testTask() throws Exception {
		// 1 发布流程
		InputStream inputStreamBpmn = this.getClass().getResourceAsStream("taskProcess.bpmn");
		InputStream inputStreamPng = this.getClass().getResourceAsStream("taskProcess.png");
		processEngine.getRepositoryService()//
						.createDeployment()//
						.addInputStream("userTask.bpmn", inputStreamBpmn)//
						.addInputStream("userTask.png", inputStreamPng)//
						.deploy();
		// 2 启动流程
		ProcessInstance pi = processEngine.getRuntimeService()//
							.startProcessInstanceByKey("taskProcess");
		System.out.println("pid:" + pi.getId());
	}
	
	//查询我的个人任务列表
	@Test
	public void findMyTaskList(){
		String userId = "孙悟空";
		List<Task> list = processEngine.getTaskService()//
		                .createTaskQuery()//
		                .taskAssignee(userId)//指定个人任务查询
		                .list();
		for(Task task:list ){
			System.out.println("id="+task.getId());
			System.out.println("name="+task.getName());
			System.out.println("assinee="+task.getAssignee());
			System.out.println("assinee="+task.getCreateTime());
			System.out.println("executionId="+task.getExecutionId());
			
		}
	}
	
	//查询组任务列表
	@Test
	public void findGroupList(){
		String userId = "孙悟空";
		List<Task> list = processEngine.getTaskService()//
		                .createTaskQuery()//
		                .taskCandidateUser(userId)//指定组任务查询
		                .list();
		for(Task task:list ){
			System.out.println("id="+task.getId());
			System.out.println("name="+task.getName());
			System.out.println("assinee="+task.getAssignee());
			System.out.println("assinee="+task.getCreateTime());
			System.out.println("executionId="+task.getExecutionId());
			System.out.println("##################################");
			
		}
	}
	
	//查询组任务成员列表
	@Test
	public void findGroupUser(){
		String taskId = "4008";
		List<IdentityLink> list = processEngine.getTaskService()//
		                .getIdentityLinksForTask(taskId);
		for(IdentityLink identityLink:list ){
			System.out.println("userId="+identityLink.getUserId());
			System.out.println("taskId="+identityLink.getTaskId());
			System.out.println("piId="+identityLink.getProcessInstanceId());
			System.out.println("######################");
		}
	}
	
	//查询组任务成员历史列表
	@Test
	public void findGroupHisUser(){
		String taskId = "4008";
		List<HistoricIdentityLink> list = processEngine.getHistoryService()//
						.getHistoricIdentityLinksForTask(taskId);
		for(HistoricIdentityLink identityLink:list ){
			System.out.println("userId="+identityLink.getUserId());
			System.out.println("taskId="+identityLink.getTaskId());
			System.out.println("piId="+identityLink.getProcessInstanceId());
			System.out.println("######################");
		}
	}
	
	//完成任务
	@Test
	public void completeTask(){
		String taskId = "4008";
		processEngine.getTaskService()//
					.complete(taskId);//
		System.out.println("完成任务");
	}
	
	//将组任务分配给个人任务（认领任务）
	@Test
	public void claimTask(){
		String taskId = "4008";
		//个人任务的办理人
		String userId = "如来";
		processEngine.getTaskService().claim(taskId, userId);
	}

	//可以分配个人任务回退到组任务，（前提之前是个组任务）
	@Test
	public void setAssigneeTask(){
		//任务ID
		String taskId = "4008";
		processEngine.getTaskService()//
					.setAssignee(taskId, null);
	}
	
	//向组任务中添加成员
	@Test
	public void addUser(){
		String taskId = "4008";
		String userId = "沙和尚";
		processEngine.getTaskService().addCandidateUser(taskId, userId);
	}

	//向组任务中删除成员
	@Test
	public void removeUser(){
		String taskId = "4008";
		String userId = "沙和尚";
		processEngine.getTaskService().deleteCandidateUser(taskId, userId);
	}

在类中使用delegateTask.addCandidateUser (userId);的方式分配组任务的办理人，此时孙悟空和猪八戒是下一个任务的办理人。
通过processEngine.getTaskService().claim (taskId, userId);将组任务分配给个人任务，也叫认领任务，即指定某个人去办理这个任务，此时由如来去办理任务。
addCandidateUser()即向组任务添加成员，deleteCandidateUser()即删除组任务的成员。
在开发中，可以将每一个任务的办理人规定好，例如张三的领导是李四和王五，这样张三提交任务，由李四或者王五去查询组任务，可以看到对应张三的申请，李四或王五再通过认领任务（claim）的方式，由某个人去完成这个任务。

业务键（重点）

在act_ru_execution表中存在BUSINESS_KEY_，这个业务键会伴随这个流程实例的一生，所以一般用来存储与业务相关的数据，一般会是与流程实例相对应的数据。
在这里插入图片描述
在开启流程的时候存入业务键，这里存入的是订单ID，对应的是一张订单表，而这个流程则是订单流程，所以两两相互对应。

ProcessInstance pi = runtimeService.startProcessInstanceByKey("OrderFlow", orderId+"");

通过流程实例获得业务键，注意流程实例和业务键是一一对应的。

ProcessInstance pi =pq.processInstanceId(task.getProcessInstanceId()).singleResult();
pi.getBusinessKey()；

一些常用的方法

获得当前节点的所有出路

	/**
	 * 获得当前节点的所有出路
	 */
	public List<String> selectTaskOutcomes(String taskId) {
		List<String> outcomeList = new ArrayList<String>();
		//根据任务的id来查询任务对象
		Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
		//获得当前流程实例
		ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processDefinitionKey("leave_manage")
		.processInstanceId(task.getProcessInstanceId()).singleResult();
		//获得流程定义的实体对象
		ProcessDefinitionEntity processDefinitionEntity = (ProcessDefinitionEntity) repositoryService.getProcessDefinition(task.getProcessDefinitionId());
		//获得当前正在活动的节点id
		String activityId = processInstance.getActivityId();
		ActivityImpl ai = processDefinitionEntity.findActivity(activityId);
		List<PvmTransition> pvmList = ai.getOutgoingTransitions();
		for(PvmTransition pvm : pvmList){
			String name = (String) pvm.getProperty("name");
			outcomeList.add(name);
		}
		return outcomeList;
	}

获得当前任务的所有可能来路

	/**
	 * 获得当前任务的来路
	 */
	public List<String> selectTaskIncomes(String taskId) {
		
		List<String> incomingList = new ArrayList<String>();
		//根据任务的id来查询任务对象
		Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
		//获得当前流程实例
		ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processDefinitionKey("leave_manage")
		.processInstanceId(task.getProcessInstanceId()).singleResult();
		//获得流程定义的实体对象
		ProcessDefinitionEntity processDefinitionEntity = (ProcessDefinitionEntity) repositoryService.getProcessDefinition(task.getProcessDefinitionId());
		//获得当前正在活动的节点id
		String activityId = processInstance.getActivityId();
		ActivityImpl ai = processDefinitionEntity.findActivity(activityId);
		List<PvmTransition> pvmList = ai.getIncomingTransitions();
		for(PvmTransition pvm : pvmList){
			String name = (String) pvm.getProperty("name");
			incomingList.add(name);
		}
		return incomingList;
	}

获得所有的活动的出路（包括开始节点）

	/**
	 * 获得所有的活动的出路（包括开始节点）
	 *传入的是历史活动节点的实例
	 * @param hai
	 * @return
	 */
	public List<String> selectAcitvityOutcomes(HistoricActivityInstance hai) {
		List<String> outcomeList = new ArrayList<String>();
		//查询流程定义的实体对象
		ProcessDefinitionEntity processDefinitionEntity = 
				(ProcessDefinitionEntity) repositoryService
				.getProcessDefinition(hai.getProcessDefinitionId());
		//获得历史活动的节点
		ActivityImpl ai = processDefinitionEntity.findActivity(hai.getActivityId());
		List<PvmTransition> pvmList = ai.getOutgoingTransitions();
		for(PvmTransition pvm : pvmList){
			String name = (String) pvm.getProperty("name");
			outcomeList.add(name);
		}
		return outcomeList;
	}

获得当前节点的指定来路（唯一）

	/**
	 * 获得当前节点的指定来路（唯一）
	 * @param taskId
	 * @return
	 */
	public String getTaskIncome(String taskId){
		Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
		List<HistoricActivityInstance> historicActivityInstanceList =  
				historyService
				.createHistoricActivityInstanceQuery()
		.processInstanceId(task.getProcessInstanceId())
		.finished()
		.orderByHistoricActivityInstanceEndTime()
		.desc()
		.list();
		HistoricActivityInstance hai = null;
		List<String> outcomeList= null;
		List<String> incomeList= null;
		if(historicActivityInstanceList.size() > 0){
			hai = historicActivityInstanceList.get(0);
			outcomeList = this.selectAcitvityOutcomes(hai);
			
		}
		incomeList = this.selectTaskIncomes(taskId);
		String income = null;
		for(String incomes : incomeList){
			for(String outcomes : outcomeList){
				if(incomes.equals(outcomes)){
					income = outcomes;
					break;
				}
			}
		}
				
		return income;
	}
	
	/**
	 * 获得所有的活动的出路（包括开始节点）
	 *传入的是历史活动节点的实例
	 * @param hai
	 * @return
	 */
	public List<String> selectAcitvityOutcomes(HistoricActivityInstance hai) {
		List<String> outcomeList = new ArrayList<String>();
		//查询流程定义的实体对象
		ProcessDefinitionEntity processDefinitionEntity = 
				(ProcessDefinitionEntity) repositoryService
				.getProcessDefinition(hai.getProcessDefinitionId());
		//获得历史活动的节点
		ActivityImpl ai = processDefinitionEntity.findActivity(hai.getActivityId());
		List<PvmTransition> pvmList = ai.getOutgoingTransitions();
		for(PvmTransition pvm : pvmList){
			String name = (String) pvm.getProperty("name");
			outcomeList.add(name);
		}
		return outcomeList;
	}
	
	/**
	 * 获得当前任务的来路
	 */
	public List<String> selectTaskIncomes(String taskId) {
		
		List<String> incomingList = new ArrayList<String>();
		//根据任务的id来查询任务对象
		Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
		//获得当前流程实例
		ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processDefinitionKey("leave_manage")
		.processInstanceId(task.getProcessInstanceId()).singleResult();
		//获得流程定义的实体对象
		ProcessDefinitionEntity processDefinitionEntity = (ProcessDefinitionEntity) repositoryService.getProcessDefinition(task.getProcessDefinitionId());
		//获得当前正在活动的节点id
		String activityId = processInstance.getActivityId();
		ActivityImpl ai = processDefinitionEntity.findActivity(activityId);
		List<PvmTransition> pvmList = ai.getIncomingTransitions();
		for(PvmTransition pvm : pvmList){
			String name = (String) pvm.getProperty("name");
			incomingList.add(name);
		}
		return incomingList;
	}

ww0peo

关注

3
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
java框架复习——Activiti工作流

工作流概述工作流(Workflow)，就是“业务过程的部分或整体在计算机应用环境下的自动化”，它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息或任务的过程自动进行，从而实现某个预期的业务目标，或者促使此目标的实现”。工作流管理系统(Workflow Management System, WfMS)是一个软件系统，它完成工作量的定义和管理，并按照在系统中预先定义好的工作流规则...
复制链接

扫一扫

专栏目录