java activity工做流

时间 2019-12-01

标签 java activity 栏目 Java 繁體版

原文原文链接

java activity工做流html

参考资料：java

1.https://blog.csdn.net/jiangyu1013/article/details/73250902mysql

2.https://blog.csdn.net/xnf1991/article/details/52610277 -----这个比较详细spring

3.https://www.cnblogs.com/shyroke/p/7988147.html ----这个也不错sql

4.https://blog.csdn.net/fanxiangru999/article/details/79381966 ---- springboot整合activiti数据库

5.https://blog.csdn.net/acmman/article/details/58656378编程

6.https://www.cnblogs.com/hongwz/p/5548473.html缓存

7.https://blog.csdn.net/ITlsc --- 可查看activiti的总体流程信息springboot

Activiti工做流
一：Activiti第一天
1：工做流的概念网络

说明：
1) 假设：这两张图就是华谊兄弟的请假流程图
2) 图的组成部分：
A. 人物：范冰冰冯小刚王中军
B. 事件（动做）：请假、批准、不批准

工做流(Workflow)，就是“业务过程的部分或总体在计算机应用环境下的自动化”，它主要解决的是“使在多个参与者之间按照某种预约义的规则传递文档、信息或任务的过程自动进行，从而实现某个预期的业务目标，或者促使此目标的实现”。
工做流管理系统(Workflow Management System, WfMS)是一个软件系统，它完成工做量的定义和管理，并按照在系统中预先定义好的工做流规则进行工做流实例的执行。工做流管理系统不是企业的业务系统，而是为企业的业务系统的运行提供了一个软件的支撑环境。
工做流管理联盟(WfMC，Workflow Management Coalition)给出的关于工做流管理系统的定义是：工做流管理系统是一个软件系统，它经过执行通过计算的流程定义去支持一批专门设定的业务流程。工做流管理系统被用来定义、管理、和执行工做流程。
工做流管理系统的目标：管理工做的流程以确保工做在正确的时间被指望的人员所执行——在自动化进行的业务过程当中插入人工的执行和干预。
2：工做流的执行过程
演示程序：Activiti控制台
3：Activiti介绍
Activiti5是由Alfresco软件在2010年5月17日发布的业务流程管理（BPM）框架，它是覆盖了业务流程管理、工做流、服务协做等领域的一个开源的、灵活的、易扩展的可执行流程语言框架。Activiti基于Apache许可的开源BPM平台，创始人Tom Baeyens是JBoss jBPM的项目架构师，它特点是提供了eclipse插件，开发人员能够经过插件直接绘画出业务
流程图。

3.1：工做流引擎
ProcessEngine对象，这是Activiti工做的核心。负责生成流程运行时的各类实例及数据、监控和管理流程的运行。
3.2：BPMN
业务流程建模与标注（Business Process Model and Notation，BPMN) ，描述流程的基本符号，包括这些图元如何组合成一个业务流程图（Business Process Diagram）

3.3：数据库（先学后看）
Activiti数据库支持：
Activiti的后台是有数据库的支持，全部的表都以ACT_开头。第二部分是表示表的用途的两个字母标识。用途也和服务的API对应。
ACT_RE_*: 'RE'表示repository。这个前缀的表包含了流程定义和流程静态资源（图片，规则，等等）。
ACT_RU_*: 'RU'表示runtime。这些运行时的表，包含流程实例，任务，变量，异步任务，等运行中的数据。 Activiti只在流程实例执行过程当中保存这些数据，在流程结束时就会删除这些记录。这样运行时表能够一直很小速度很快。
ACT_ID_*: 'ID'表示identity。这些表包含身份信息，好比用户，组等等。
ACT_HI_*: 'HI'表示history。这些表包含历史数据，好比历史流程实例，变量，任务等等。
ACT_GE_*: 通用数据，用于不一样场景下，如存放资源文件。

表结构操做：
3.3.1：资源库流程规则表
1) act_re_deployment 部署信息表
2) act_re_model 流程设计模型部署表
3) act_re_procdef 流程定义数据表
3.3.2：运行时数据库表
1) act_ru_execution 运行时流程执行实例表
2) act_ru_identitylink 运行时流程人员表，主要存储任务节点与参与者的相关信息
3) act_ru_task 运行时任务节点表
4) act_ru_variable 运行时流程变量数据表
3.3.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 历史变量表
3.3.4：组织机构表
1) act_id_group 用户组信息表
2) act_id_info 用户扩展信息表
3) act_id_membership 用户与用户组对应信息表
4) act_id_user 用户信息表
这四张表很常见，基本的组织机构管理，关于用户认证方面建议仍是本身开发一套，组件自带的功能太简单，使用中有不少需求难以知足
3.3.5：通用数据表
1) act_ge_bytearray 二进制数据表
2) act_ge_property 属性数据表存储整个流程引擎级别的数据,初始化表结构时，会默认插入三条记录，
3.4：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）：

3.5：logging.properties（日志处理）
日志的配置文件，Activiti操做数据库的时候，整合的日志文件
4：准备环境
4.1：activiti5 软件环境
1) JDK1.6或者更高版本
2) 支持的数据库有：h2, mysql, oracle, postgres, mssql, db2等。
3) 支持activiti5运行的jar包
4) 开发环境为Eclipse3.7或者以上版本,myeclipse为8.6版本
4.2：相关资源下载
1) JDK能够到sun的官网下载
http://www.oracle.com/technetwork/java/javase/downloads/index.html
2) 数据库，例如：mysql能够在官网上下载。
http://www.mysql.com
3) activiti也能够到Activiti官方网站下载获得。
http://activiti.org/download.html
4) Eclipse3.7或者MyEclipse8.6也能够到相应的网站上得到下载。
4.3：安装流程设计器(eclipse插件)
4.3.1：安装方式一
在有网络的状况下，安装流程设计器步骤以下：
1) 打开 Help -> Install New Software. 在以下面板中:

2) 在以下Install界面板中，点击Add按钮：

配置新装插件的地址和名称

3) 而后填入下列字段
Name: Activiti BPMN 2.0 designer
Location: http://activiti.org/designer/update/

4) 回到Install界面，在面板正中列表中把全部展现出来的项目都勾上：

5) 点击复选框
在Detail部分记得选中 "Contact all updates sites.." , 由于它会检查全部当前安装所须要的插件并能够被Eclipse下载.

6) 安装完之后，点击新建工程new->Other…打开面板，若是看到下图内容：

说明安装成功了。
4.3.2：安装方式二
在没有网络的状况下，安装流程设计器步骤以下：
1) 解压老师发给你们的
2) 把压缩包中的内容放入eclipse根目录的dropins文件夹下
3) 重启eclipse，点击新建工程new->Other…打开面板，若是看到下图内容：

说明安装成功了
4.4：对流程设计器的使用说明
打开菜单Windows->Preferences->Activiti->Save下流程流程图片的生成方式:

虽然流程引擎在单独部署bpmn文件时会自动生成图片，但在实际开发过程当中，自动生成的图片会致使和BPMN中的坐标有出入，在实际项目中展现流程当前位置图会有问题。
所在完成以上配置后，会由咱们本身来管理流程图片。在发布流程时把流程规则文件和流程图片一块儿上传就好了。
4.5：准备Activiti5开发环境
4.5.1：添加Activiti5的jar包
在activiti-5.13->wars目录下是一些示例项目，解压activiti-rest项目，导入activiti-rest目录中WEB-INF\lib下全部包。添加到classpath中。
因为咱们使用的是Mysql数据库，Mysql数据库的连接驱动Activiti官方包中并无提供，须要咱们本身导入。手动导入mysql-connector-java.jar，添加到classpath下。
4.5.2：初始化数据库

在Activiti中，在建立核心的流程引擎对象时会自动建表。若是程序正常执行，mysql会自动建库，而后建立23张表。
4.5.3：添加并制定配置文件
在Actiiti5中定制流程一定会操做到数据库，若是都像上面那样写一大段代码会很是麻烦，因此咱们能够把数据库链接配置写入配置文件。
在Activiti5的官方示例中并无现成的配置文件，因此先得找到activiti-rest\WEB-INF\classes下有：

4.5.3.1：activiti-context.xml ：
一个相似spring结构的配置文件，清空内容后更名为activiti.cfg.xml，用来作流程引擎的相关配置。
按照上面代码配置ProcessEngineConfiguration对象，主要定义数据库的链接配置和建表策略，配置文件代码以下：

Java代码以下：

createProcessEngineConfigurationFromResource的参数值为咱们添加的配置文件activiti.cfg.xml的名称，执行java代码，流程引擎对象建立成功运行后数据库会自动建表。
4.5.3.2：log4j.properties 日志配置文件
把两个文件放入resource目录下便可。

5：核心API
5.1：ProcessEngine
说明：
1) 在Activiti中最核心的类，其余的类都是由他而来。
2) 产生方式：

在前面看到了两种建立ProcessEngine（流程引擎）的方式，而这里要简化不少，调用ProcessEngines的getDefaultProceeEngine方法时会自动加载classpath下名为activiti.cfg.xml文件。
3) 能够产生RepositoryService

4) 能够产生RuntimeService

5) 能够产生TaskService

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

5.2：RepositoryService
是Activiti的仓库服务类。所谓的仓库指流程定义文档的两个文件：bpmn文件和流程图片。
1) 产生方式

2) 能够产生DeploymentBuilder，用来定义流程部署的相关参数

3) 删除流程定义

5.3：RuntimeService
是activiti的流程执行服务类。能够从这个服务类中获取不少关于流程执行相关的信息。
5.4：TaskService
是activiti的任务服务类。能够从这个类中获取任务的信息。
5.5：HistoryService
是activiti的查询历史信息的类。在一个流程执行完成后，这个对象为咱们提供查询历史信息。
5.6：ProcessDefinition
流程定义类。能够从这里得到资源文件等。
5.7：ProcessInstance
表明流程定义的执行实例。如范冰冰请了一天的假，她就必须发出一个流程实例的申请。一个流程实例包括了全部的运行节点。咱们能够利用这个对象来了解当前流程实例的进度等信息。流程实例就表示一个流程从开始到结束的最大的流程分支，即一个流程中流程实例只有一个。
5.8：Execution
Activiti用这个对象去描述流程执行的每个节点。在没有并发的状况下，Execution就是同ProcessInstance。流程按照流程定义的规则执行一次的过程，就能够表示执行对象Execution。
如图为ProcessInstance的源代码：

从源代码中能够看出ProcessInstance就是Execution。但在现实意义上有所区别：

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

这个例子有一个特色：wire money(汇钱)和archive(存档)是并发执行的。这个时候，总线路表明ProcessInstance，而分线路中每一个活动表明Execution。
总结：
* 一个流程中，执行对象能够存在多个，可是流程实例只能有一个。
* 当流程按照规则只执行一次的时候，那么流程实例就是执行对象。

6：HelloWorld程序（模拟流程的执行）
6.1：流程图：

6.2：部署流程定义

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

这里使用RuntimeService启动流程实例
6.4：查看个人我的任务

这里使用TaskService完成任务的查询
6.5：完成个人我的任务

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

7：管理流程定义
7.1：设计流程定义文档
7.1.1：流程图

7.1.2：bpmn文件
BPMN 2.0根节点是definitions节点。这个元素中，能够定义多个流程定义（不过咱们建议每一个文件只包含一个流程定义，能够简化开发过程当中的维护难度）。一个空的流程定义看起来像下面这样。注意，definitions元素最少也要包含xmlns 和 targetNamespace的声明。 targetNamespace能够是任意值，它用来对流程实例进行分类。

说明：流程定义文档有两部分组成：
1) bpmn文件
流程规则文件。在部署后，每次系统启动时都会被解析，把内容封装成流程定义放入项目缓存中。Activiti框架结合这个xml文件自动管理流程，流程的执行就是按照bpmn文件定义的规则执行的，bpmn文件是给计算机执行用的。
2) 展现流程图的图片
在系统里须要展现流程的进展图片，图片是给用户看的。

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

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

2) 首先得到默认的流程引擎，经过流程引擎获取了一个RepositoryService对象（仓库对象）
3) 由仓库的服务对象产生一个部署对象配置对象，用来封装部署操做的相关配置。
4) 这是一个链式编程，在部署配置对象中设置显示名，上传流程定义规则文件
5) 向数据库表中存放流程定义的规则信息。
6) 这一步在数据库中将操做三张表：
a) act_re_deployment（部署对象表）
存放流程定义的显示名和部署时间，每部署一次增长一条记录
b) act_re_procdef（流程定义表）
存放流程定义的属性信息，部署每一个新的流程定义都会在这张表中增长一条记录。
注意：当流程定义的key相同的状况下，使用的是版本升级
c) act_ge_bytearray（资源文件表）
存储流程定义相关的部署信息。即流程定义文档的存放地。每部署一次就会增长两条记录，一条是关于bpmn规则文件的，一条是图片的（若是部署时只指定了bpmn一个文件，activiti会在部署时解析bpmn文件内容自动生成流程图）。两个文件不是很大，都是以二进制形式存储在数据库中。
7.3：部署流程定义（zip格式文件）

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

7.4：查看流程定义
查询流程定义的信息

结果：

再部署一次运行结果为：

能够看到流程定义的key值相同的状况下，版本是从1开始逐次升级的
流程定义的Id是【key：版本：生成ID】
说明：
1) 流程定义和部署对象相关的Service都是RepositoryService。
2) 建立流程定义查询对象，能够在ProcessDefinitionQuery上设置查询的相关参数
3) 调用ProcessDefinitionQuery对象的list方法，执行查询，得到符合条件的流程定义列表
4) 由运行结果能够看出：
Key和Name的值为：bpmn文件process节点的id和name的属性值

5) key属性被用来区别不一样的流程定义。
6) 带有特定key的流程定义第一次部署时，version为1。以后每次部署都会在当前最高版本号上加1
7) Id的值的生成规则为:{processDefinitionKey}:{processDefinitionVersion}:{generated-id}, 这里的generated-id是一个自动生成的惟一的数字
8) 重复部署一次，deploymentId的值以必定的形式变化
规则act_ge_property表生成
7.5：删除流程定义
删除部署到activiti中的流程定义。

说明：
1) 由于删除的是流程定义，而流程定义的部署是属于仓库服务的，因此应该先获得RepositoryService
2) 若是该流程定义下没有正在运行的流程，则能够用普通删除。若是是有关联的信息，用级联删除。项目开发中使用级联删除的状况比较多，删除操做通常只开放给超级管理员使用。
7.6：获取流程定义文档的资源（查看流程图附件）
查询出流程定义文档。主要查的是图片，用于显示流程用。

说明：
1) deploymentId为流程部署ID
2) resourceName为act_ge_bytearray表中NAME_列的值
3) 使用repositoryService的getDeploymentResourceNames方法能够获取指定部署下得全部文件的名称
4) 使用repositoryService的getResourceAsStream方法传入部署ID和资源图片名称能够获取部署下指定名称文件的输入流
5) 最后的有关IO流的操做，使用FileUtils工具的copyInputStreamToFile方法完成流程流程到文件的拷贝，将资源文件以流的形式输出到指定文件夹下
7.7：附加功能：查询最新版本的流程定义

7.8：附加功能：删除流程定义（删除key相同的全部不一样版本的流程定义）

7.9：总结
Deployment 部署对象
一、一次部署的多个文件的信息。对于不须要的流程能够删除和修改。
二、对应的表：
act_re_deployment：部署对象表
act_re_procdef：流程定义表
act_ge_bytearray：资源文件表
act_ge_property：主键生成策略表

ProcessDefinition 流程定义
一、解析.bpmn后获得的流程定义规则的信息，工做流系统就是按照流程定义的规则执行的。

8：流程实例、任务的执行
8.1：流程图

8.2：部署流程定义

8.3：启动流程实例

说明：
1) 操做数据库的act_ru_execution表,若是是用户任务节点，同时也会在act_ru_task添加一条记录

8.4：查询个人我的任务

说明：
1) 由于是任务查询，因此从processEngine中应该获得TaskService
2) 使用TaskService获取到任务查询对象TaskQuery
3) 为查询对象添加查询过滤条件，使用taskAssignee指定任务的办理者（即查询指定用户的代办任务），同时能够添加分页排序等过滤条件
4) 调用list方法执行查询，返回办理者为指定用户的任务列表
5) 任务ID、名称、办理人、建立时间能够从act_ru_task表中查到。
6) Execution与ProcessInstance见5.6和5.7章节的介绍。在这种状况下，ProcessInstance至关于Execution
7) 若是assignee属性为部门经理，结果为空。由于如今流程只到了”填写请假申请”阶段，后面的任务尚未执行，即在数据库中没有部门经理能够办理的任务，因此查询不到。
8) 一个Task节点和Execution节点是1对1的状况，在task对象中使用Execution_来表示他们之间的关系
9) 任务ID在数据库表act_ru_task中对应“ID_”列

附加：
在activiti任务中，主要分为两大类查询任务（我的任务和组任务）：
1.确切指定了办理者的任务，这个任务将成为指定者的私有任务，即我的任务。
2.没法指定具体的某一我的来办理的任务，能够把任务分配给几我的或者一到多个小组，让这个范围内的用户能够选择性（若有空余时间时）来办理这类任务，即组任务。
先知道我的任务的查询和办理，组任务的操做后面讲

8.5：办理任务

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

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

在流程执行的过程当中，建立的流程实例ID在整个过程当中都不会变，当流程结束后，流程实例将会在正在执行的执行对象表中（act_ru_execution）被删除
说明：
1) 由于是查询流程实例，因此先获取runtimeService
2) 建立流程实例查询对象，设置实例ID过滤参数
3) 因为一个流程实例ID只对应一个实例，使用singleResult执行查询返回一个惟一的结果，若是结果数量大于1，则抛出异常
4) 判断指定ID的实例是否存在，若是结果为空，则表明流程结束，实例在正在执行的执行对象表中已被删除，转换成历史数据。
8.7：附加功能：查询历史任务（后面讲）

8.8：附加功能：查询历史流程实例（后面讲）

8.9：总结
Execution 执行对象
按流程定义的规则执行一次的过程.
对应的表：
act_ru_execution：正在执行的信息
act_hi_procinst：已经执行完的历史流程实例信息
act_hi_actinst：存放历史全部完成的活动
ProcessInstance 流程实例
特指流程从开始到结束的那个最大的执行分支，一个执行的流程中，流程实例只有1个。

注意
（1）若是是单例流程，执行对象ID就是流程实例ID
（2）若是一个流程有分支和聚合，那么执行对象ID和流程实例ID就不相同
（3）一个流程中，流程实例只有1个，执行对象能够存在多个。

Task 任务
执行到某任务环节时生成的任务信息。
对应的表：
act_ru_task：正在执行的任务信息
act_hi_taskinst：已经执行完的历史任务信息

9：流程变量
9.1：流程图

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

即：

9.2：部署流程定义

说明：
• 输入流加载资源文件的3种方式

9.3：启动流程实例

9.4：设置流程变量

说明：
1) 流程变量的做用域就是流程实例，因此只要设置就好了，不用管在哪一个阶段设置
2) 基本类型设置流程变量，在taskService中使用任务ID，定义流程变量的名称，设置流程变量的值。
3) Javabean类型设置流程变量，须要这个javabean实现了Serializable接口
4) 设置流程变量的时候，向act_ru_variable这个表添加数据

9.5：获取流程变量

说明：
1）流程变量的获取针对流程实例（即1个流程），每一个流程实例获取的流程变量时不一样的
2）使用基本类型获取流程变量，在taskService中使用任务ID，流程变量的名称，获取流程变量的值。
3） Javabean类型设置获取流程变量，除了须要这个javabean实现了Serializable接口外，还要求流程变量对象的属性不能发生变化，不然抛出异常。解决方案，固定序列化ID
9.6：模拟流程变量的设置和获取的场景

说明：
1） RuntimeService对象能够设置流程变量和获取流程变量
2） TaskService对象能够设置流程变量和获取流程变量
3）流程实例启动的时候能够设置流程变量
4）任务办理完成的时候能够设置流程变量
5）流程变量能够经过名称/值的形式设置单个流程变量
6）流程变量能够经过Map集合，同时设置多个流程变量
Map集合的key表示流程变量的名称
Map集合的value表示流程变量的值

9.7：查询历史的流程变量

说明：
1）历史的流程变量查询，指定流程变量的名称，查询act_hi_varinst表（也能够针对，流程实例ID，执行对象ID，任务ID查询）

9.8：流程变量的支持的类型
如图是从官网列出来的流程变量的类型：

从图中能够看出包括了大部分封装类型和Date、String和实现了Serializable接口的类的类型。
9.9：总结
• 1：流程变量
在流程执行或者任务执行的过程当中，用于设置和获取变量，使用流程变量在流程传递的过程当中传递业务参数。
对应的表：
act_ru_variable：正在执行的流程变量表
act_hi_varinst：流程变量历史表

• 2：扩展知识：setVariable和setVariableLocal的区别
setVariable：设置流程变量的时候，流程变量名称相同的时候，后一次的值替换前一次的值，并且能够看到TASK_ID的字段不会存听任务ID的值
setVariableLocal：
1：设置流程变量的时候，针对当前活动的节点设置流程变量，若是一个流程中存在2个活动节点，对每一个活动节点都设置流程变量，即便流程变量的名称相同，后一次的版本的值也不会替换前一次版本的值，它会使用不一样的任务ID做为标识，存放2个流程变量值，并且能够看到TASK_ID的字段会存听任务ID的值
例如act_hi_varinst 表的数据：不一样的任务节点，即便流程变量名称相同，存放的值也是不一样的。
如图：

2：还有，使用setVariableLocal说明流程变量绑定了当前的任务，当流程继续执行时，下个任务获取不到这个流程变量（由于正在执行的流程变量中没有这个数据），全部查询正在执行的任务时不能查询到咱们须要的数据，此时须要查询历史的流程变量。

10：流程执行历史记录
10.1：查询历史流程实例
查找按照某个流程定义的规则一共执行了多少次流程

10.2：查询历史活动
某一次流程的执行一共经历了多少个活动

10.3：查询历史任务
某一次流程的执行一共经历了多少个任务

10.4：查询历史流程变量
某一次流程的执行一共设置的流程变量

10.5：总结
因为数据库中保存着历史信息以及正在运行的流程实例信息，在实际项目中对已完成任务的查看频率远不及对代办和可接任务的查看，因此在activiti采用分开管理，把正在运行的交给RuntimeService、TaskService管理，而历史数据交给HistoryService来管理。
这样作的好处在于，加快流程执行的速度，由于正在执行的流程的表中数据不会很大。

二：Activiti次日
11:连线
11.1：流程图

注意：若是将流程图放置在和java类相同的路径，须要配置：

11.2：部署流程定义+启动流程实例

11.3：查询个人我的任务

11.4：完成任务

说明：
1）使用流程变量，设置连线须要的流程变量的名称message，并设置流程变量的值
对应：

流程会按照指定的连线完成任务。
11.5：总结
一、一个活动中能够指定一个或多个SequenceFlow（Start中有一个，End中没有）。
* 开始活动中有一个SequenceFlow 。
* 结束活动中没有SequenceFlow 。
* 其余活动中有1条或多条SequenceFlow
二、若是只有一个，则能够不使用流程变量设置codition的名称；

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

12：排他网关（ExclusiveGateWay）
12.1：流程图

12.2：部署流程定义+启动流程实例

12.3：查询个人我的任务

12.4：完成个人我的任务

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

则执行连线：

若是使用流程变量设置

则执行连线：

13：并行网关(parallelGateWay)
13.1：流程图

13.2：部署流程定义+启动流程实例

13.3：查询个人我的任务

13.4：完成个人我的任务

说明：
1）一个流程中流程实例只有1个，执行对象有多个
2）并行网关的功能是基于进入和外出的顺序流的：
分支(fork)：并行后的全部外出顺序流，为每一个顺序流都建立一个并发分支。
汇聚(join)：全部到达并行网关，在此等待的进入分支，直到全部进入顺序流的分支都到达之后，流程就会经过汇聚网关。
3）并行网关的进入和外出都是使用相同节点标识
4）若是同一个并行网关有多个进入和多个外出顺序流，它就同时具备分支和汇聚功能。这时，网关会先汇聚全部进入的顺序流，而后再切分红多个并行分支。
5）并行网关不会解析条件。即便顺序流中定义了条件，也会被忽略。
6）并行网关不须要是“平衡的”（好比，对应并行网关的进入和外出节点数目不必定相等）。如图中标示是合法的：
14：开始活动节点
14.1：流程图

14.2：部署流程定义+启动流程实例+查询流程实例+查询历史流程实例

14.3：总结
1）：结束节点没有出口
2）：其余节点有一个或多个出口。
若是有一个出口，则表明是一个单线流程；
若是有多个出口，则表明是开启并发流程。

15：接收活动（receiveTask，即等待活动）
接收任务是一个简单任务，它会等待对应消息的到达。当前，官方只实现了这个任务的java语义。当流程达到接收任务，流程状态会保存到数据库中。
在任务建立后，意味着流程会进入等待状态，直到引擎接收了一个特定的消息，这会触发流程穿过接收任务继续执行。
15.1：流程图

15.2：部署流程定义+启动流程实例
/**
* 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("流程正常执行！！！，已经结束了");
}
}

说明：
1）当前任务（通常指机器自动完成，但须要耗费必定时间的工做）完成后，向后推移流程，能够调用runtimeService.signal(executionId)，传递接收执行对象的id。

16：用户任务（userTask，即用户操做的任务）
16.1：我的任务
16.1.1：流程图

16.1.2:：分配我的任务方式一（直接指定办理人）
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("完成任务");
}
说明：
1）张三丰是我的任务的办理人
2）可是这样分配任务的办理人不够灵活，由于项目开发中任务的办理人不要放置XML文件中。

16.1.3:：分配我的任务方式二（使用流程变量）
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）张翠山是我的任务的办理人
2）在开发中，能够在页面中指定下一个任务的办理人，经过流程变量设置下一个任务的办理人

16.1.4:：分配我的任务方式三（使用类）
1：流程图中任务节点的配置

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

2：TaskListenerImpl类，用来设置任务的办理人
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);
}

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

16.1.5：总结
我的任务及三种分配方式：
1：在taskProcess.bpmn中直接写 assignee=“张三丰"
2：在taskProcess.bpmn中写 assignee=“#{userID}”，变量的值要是String的。
使用流程变量指定办理人
3，使用TaskListener接口，要使类实现该接口，在类中定义：
delegateTask.setAssignee(assignee);// 指定我的任务的办理人

使用任务ID和办理人从新指定办理人：
processEngine.getTaskService()//
.setAssignee(taskId, userId);

16.2：组任务
16.2.1：流程图

16.2.2:：分配组任务方式一（直接指定办理人）
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("完成任务");
}

/**将组任务分配给我的任务，拾取任务*/
//由1我的去完成任务
@Test
public void claim(){
//任务ID
String taskId = "5908";
//分配的办理人
String userId = "小B";
processEngine.getTaskService()//
.claim(taskId, userId);
}
说明：
1）小A，小B，小C，小D是组任务的办理人
2）可是这样分配组任务的办理人不够灵活，由于项目开发中任务的办理人不要放置XML文件中。
3） act_ru_identitylink表存听任务的办理人，包括我的任务和组任务，表示正在执行的任务
4） act_hi_identitylink表存听任务的办理人，包括我的任务和组任务，表示历史任务
区别在于：若是是我的任务TYPE的类型表示participant（参与者）
若是是组任务TYPE的类型表示candidate（候选者）和participant（参与者）

16.2.3:：分配我的任务方式二（使用流程变量）
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）大大，中中，小小是组任务的办理人
2）在开发中，能够在页面中指定下一个组任务的办理人，经过流程变量设置下一个任务的办理人
16.2.4:：分配我的任务方式三（使用类）
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);
}
说明：
1）在类中使用delegateTask.addCandidateUser (userId);的方式分配组任务的办理人，此时孙悟空和猪八戒是下一个任务的办理人。
2）经过processEngine.getTaskService().claim (taskId, userId);将组任务分配给我的任务，也叫认领任务，即指定某我的去办理这个任务，此时由如来去办理任务。
注意：认领任务的时候，能够是组任务成员中的人，也能够不是组任务成员的人，此时经过Type的类型为participant来指定任务的办理人
3） addCandidateUser()即向组任务添加成员，deleteCandidateUser()即删除组任务的成员。
4）在开发中，能够将每个任务的办理人规定好，例如张三的领导是李四和王五，这样张三提交任务，由李四或者王五去查询组任务，能够看到对应张三的申请，李四或王五再经过认领任务（claim）的方式，由某我的去完成这个任务。
16.2.5：总结
组任务及三种分配方式：
1：在taskProcess.bpmn中直接写 candidate-users=“小A,小B,小C,小D"
2：在taskProcess.bpmn中写 candidate-users =“#{userIDs}”，变量的值要是String的。
使用流程变量指定办理人
Map<String, Object> variables = new HashMap<String, Object>();
variables.put("userIDs", "大大,小小,中中");
3，使用TaskListener接口，使用类实现该接口，在类中定义：
//添加组任务的用户
delegateTask.addCandidateUser(userId1);
delegateTask.addCandidateUser(userId2);
组任务分配给我的任务（认领任务）：
processEngine.getTaskService().claim(taskId, userId);
我的任务分配给组任务：
processEngine.getTaskService(). setAssignee(taskId, null);
向组任务添加人员：
processEngine.getTaskService().addCandidateUser(taskId, userId);
向组任务删除人员：
processEngine.getTaskService().deleteCandidateUser(taskId, userId);
我的任务和组任务存放办理人对应的表：
act_ru_identitylink表存听任务的办理人，包括我的任务和组任务，表示正在执行的任务
act_hi_identitylink表存听任务的办理人，包括我的任务和组任务，表示历史任务
区别在于：若是是我的任务TYPE的类型表示participant（参与者）
若是是组任务TYPE的类型表示candidate（候选者）和participant（参与者）

16.3:工做流定义的角色组（了解）
16.3.1：流程图

流程图中任务节点的配置：

分配任务负责的组
使用 candidate groups 属性指定任务负责组
代码：
<userTask id=“usertask1” name=“审批” activiti:candidateGroups=“部门经理”>
</userTask>

其中部门经理表示一个用户组的角色

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

/**在部署流程定义和启动流程实例的中间，设置组任务的办理人，向Activity表中存放组和用户的信息*/
IdentityService identityService = processEngine.getIdentityService();//认证：保存组和用户信息
identityService.saveGroup(new GroupEntity("部门经理"));//创建组
identityService.saveGroup(new GroupEntity("总经理"));//创建组
identityService.saveUser(new UserEntity("小张"));
identityService.saveUser(new UserEntity("小李"));
identityService.saveUser(new UserEntity("小王"));
identityService.createMembership("小张", "部门经理");//创建组和用户关系
identityService.createMembership("小李", "部门经理");//创建组和用户关系
identityService.createMembership("小王", "总经理");//创建组和用户关系

// 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 = "4408";
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 completeTask(){
String taskId = "5108";
processEngine.getTaskService()//
.complete(taskId);//
System.out.println("完成任务");
}
}
16.3.3：分配任务负责的组(IdentityService)
/**在部署流程定义和启动流程实例的中间，设置组任务的办理人，向Activiti表中存放组和用户的信息*/
IdentityService identityService = processEngine.getIdentityService();//认证：保存组和用户信息
identityService.saveGroup(new GroupEntity("部门经理"));//创建组
identityService.saveGroup(new GroupEntity("总经理"));//创建组
identityService.saveUser(new UserEntity(“小张”));//创建用户
identityService.saveUser(new UserEntity("小李")); //创建用户
identityService.saveUser(new UserEntity("小王")); //创建用户
identityService.createMembership("小张", "部门经理");//创建组和用户关系
identityService.createMembership("小李", "部门经理");//创建组和用户关系
identityService.createMembership(“小王”, “总经理”);//创建组和用户关系
表结构介绍
act_id_group：角色组表
act_id_user：用户表：
act_id_membership：用户角色表
指定组任务的办理人，查询组任务
String userId = “小张”;//小张，小李能够查询结果，小王不能够，由于他不是部门经理角色
List<Task> list = processEngine.getTaskService()//
.createTaskQuery()//
.taskCandidateUser(userId)//指定组任务查询
.list();

Activiti总结：