在项目开发中，复杂业务流程开发繁琐，可使用工作流程框架。Activiti5是常用开源框架，能简化开发。本文介绍了Activiti5的相关概念、核心类、服务组件，还说明了其与业务逻辑配合使用的方法，包括安装插件、测试、流程启动、任务处理等。
工作流程框架Activiti5
在我们实际的项目开发中，有时业务流程很复杂，类似的业务也很多。这样我们开发起来就会很复杂。像我们练习的众筹网项目中的资质认证模块，开发时的功能不过就是简单的增删改查，可是业务流程很繁琐，同时又有很多种情况。如果我们不使用工具自己来开发的话就会很麻烦！这时我们就需要使用工作流程框架啦！Activiti5正是工作流程框架中一个比较常用的开源框架。他可以使我们在开发复杂业务流程时非常简单。
那我们这就先来简单了解一下Activiti5如何使用吧！
工作流：
几个概念：
定义（一种）：
Person{
String name;
int age;
}
流程定义就是流程图；
实例;（无数个）
new Person()；
流程实例（多个）-启动了某个流程；
流程定义 ProcessDefinition：定义某些流程的顺序结构；定义一个流程；
流程实例 ProcessInstance：实例化一个流程，（启动一次流程）；
流程变量 Process variable：流程运行期间的一些数据
任务 Task：流程执行到的需要具体的执行一个任务（某个任务）；
起始、结束（Start、End）：流程的开始和结束；
网关（ Gateway）：控制流程的流转方向；
ProcessEngine这个类是Activiti5的核心，所有的服务都需要通过ProcessEngine来创建，该类是线程安全的
Activiti5的持久化层采用的是Mybatis，这样移植性好
Activiti5主要包括7个Service（7个服务组件），这些Service都是通过ProcessEngine创建
- repositoryService（持久化服务）：操作数据库完成流程部署，流程定义保存等工作；
- runtimeService（运行时服务）：在流程运行期间可以获取到流程的所有信息，控制流程启动停止等。
- formService（表单服务）：是一个可选的；实际开发也是不用的；就是流程运行时需要的数据利用表单提交过来；用自己的业务控制表单：html
- The FormService is an optional service. Meaning that Activiti can perfectly be used without it, without sacrificing any functionality.
- identityService（身份信息）：来管理流程框架中的用户，分组信息等；
- The IdentityService is pretty simple. It allows the management (creation, update, deletion, querying, …) of groups and users
- taskService（任务服务）：负责流程期间任务的签收处理，以及完成任务等工作；
-
Everything around tasks is grouped in the TaskService, such as
-
Querying tasks assigned to users or groups
-
Creating new standalone tasks. These are tasks that are not related to a process instances.
-
Manipulating to which user a task is assigned or which users are in some way involved with the task.
-
Claiming and completing a task. Claiming means that someone decided to be the assignee for the task, meaning that this user will complete the task. Completing means doing the work of the tasks. Typically this is filling in a form of sorts.
-
- historyService（历史信息）：流程运行的历史信息；
- managementService（管理定时任务）：
- The ManagementService is typically not needed when coding custom application using Activiti.
activiti5：
运行时表和流程结束的表进行分开处理；
运行期间经常进行一些CRUD；运行期间这些表中的数据总是很少，CRUD非常快；
流程运行期间数据以及信息存储的表：
流程运行完成后的一些表：
activiti5如何和我们业务逻辑配合使用；
概念我了解的差不多啦！接下来我们看看如何使用。
1，安装流程设计框架activiti5的插件。先解压插件压缩包，将压缩包中的两个文件夹拷贝到eclipse的安装目录下，然后重启eclipse就可以啦！很简单！
重启eclipse后在新建中看看是否可以创建activiti项目？如果可以表示安装成功！
2，测试。新建或者随便找一个maven工程来测试activiti。
①，导包，在maven工程的pom文件中添加依赖。这里也添加了mysql的依赖，因为activiti也是需要数据库保存数据的，我们要自定义activiti的数据保存在mysql中。
<!--测试activiti -->
<dependencies>
<dependency>
<groupId>org.activiti</groupId>
<artifactId>activiti-engine</artifactId>
<version>5.22.0</version>
</dependency>
<!-- 导入mysql驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.42</version>
</dependency>
</dependencies>②写配置。在maven项目中创建spring的配置文件，拷贝相关配置信息并修改。创建源码包，用于保存之后创建的流程设计文件。
上图中mysql的配置，是为了指定activiti将数据保存在mysql中，单独新创建的activiti_db数据库。
③，测试。
package com.atguigu.activiti.test;
import static org.junit.Assert.*;
import org.activiti.engine.FormService;
import org.activiti.engine.HistoryService;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ManagementService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.junit.Before;
import org.junit.Test;
public class ActivitiTest {
// 引擎只有一个即可
// 在类路径下找一个activiti.cfg.xml的配置文件来初始化流程引擎
//服务组件和流程引擎都是接口；
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
TaskService taskService;
RuntimeService runtimeService;
RepositoryService repositoryService;
ManagementService managementService;
IdentityService identityService;
HistoryService historyService;
FormService formService;
@Before
public void serviceInit() {
// 任务服务组件：完成任务，签收任务等...
taskService = processEngine.getTaskService();
// 运行时服务组件：查询流程运行期间一些信息，控制流程等
runtimeService = processEngine.getRuntimeService();
// 持久化服务组件:负责保存流程定义信息等
repositoryService = processEngine.getRepositoryService();
// 管理组件，监听流程、定时任务等...
managementService = processEngine.getManagementService();
// 用户模块组件，CRUD一些用户以及用户分组等信息
identityService = processEngine.getIdentityService();
// 查询流程历史记录等信息；历史组件
historyService = processEngine.getHistoryService();
// 表单组件：没用
formService = processEngine.getFormService();
}
@Test
public void test() {
System.out.println("流程引擎："+processEngine);
System.out.println("其他组件：");
}
}
1、流程框架第一次给数据库中建表，这个表有数据；（存储当前activiti版本信息等）
2、创建一个流程定义文件
3、在文件的空白处点一下；去properties标签中可以填写当前流程的一些定义（介绍）信息
5、画流程图：在流程定义文件中画流程图。
6、部署流程
@Test
public void testProcessDefinetionDeployee() {
// 1、如何定义一个流程；（画流程图）；
// 2、部署这个定义好的流程；
// 3、部署：去数据库保存这个流程定义的信息
Deployment deploy = repositoryService.createDeployment()
.addClasspathResource("process/请假流程.bpmn")
.deploy();
System.out.println("部署的流程deploy对象"+deploy);
}
一些通用信息；
保存了流程的文件、流程图等信息
部署（流程部署信息的保存）；部署的信息：某一天部署了什么东西
procdef：Procecss Definetion：流程定义；
真正的id：
；流程key:版本号:部署id
1、流程的启动；
使用runtimeService；
任务表中就有任务；ru_task；
流程定义：ProcessDefinetion；流程信息保存；
流程实例：启动某个流程就是为这个流程创建一个流程实例；运行期间的数据都在ru表中
event_ 流程期间的事件处理；
execution_：流程的运行信息
identitylink：和用户有关
ru_job：其他任务；
ru_task：用户要完成的任务；
ru_variable：流程变量；流程运行期间要用的数据；
2、任务的签收和完成；
taskService.claim(task.getId(), "zhangsan");签收
taskService.complete(task.getId());完成
3、流程框架只是一个流程管理工具；
4、流程变量：流程运行期间的数据；
使用${}取出某些变量的值，用来做判断，做任务派发等....
流程变量如果使用form表单申明的方式：变量的类型必须是以下几种；
{date, boolean, string, double, long}
1）、员工申请：指派人：动态取得传入的变量。
2）、网关；判断走分支；
①，排他网关
相当于if()...else if()；只会有一个分支到达。
选中网关与任务之间的连线后，可以填写判断条件。
这个规定数据不靠谱，我们一般也不用；以后都是跟业务逻辑走；
②，并行网关
必须等待所有的分支都完成，汇聚任务才能完成，自动进行下一步；（注意要有起始和汇聚成对出现）
/**
* 并行网关，必须所有汇聚点的分支都完成才可以
* @Description (TODO这里用一句话描述这个方法的作用)
*/
@Test
// gov-process:1:87504
public void test04() {
List<Task> list = taskService.createTaskQuery().processDefinitionId("gov-process:1:87504").list();
int i = 0;
for (Task task : list) {
System.out.println("任务信息：" + task.getId() + "；任务名：" + task.getName());
// 完成任务
taskService.complete(task.getId());
//if ((i++) % 2 == 0) {
// System.out.println("当前要完成的任务。"+task.getId() + "；任务名：" + task.getName());
// taskService.complete(task.getId());
//}
}
// List<HistoricProcessInstance> list2 = historyService.createHistoricProcessInstanceQuery().finished().list();
// for (HistoricProcessInstance historicProcessInstance : list2) {
// System.out.println(historicProcessInstance);
// }
//看这个流程是否完成了；
long count = historyService.createHistoricProcessInstanceQuery().processDefinitionId("gov-process:1:87504").finished().count();
System.out.println(count);
}③，包含网关；（并行+排他）；
并行：满足并行条件的分支走；
包含：
满足走的就走；并行
还可以排他
这里是所有联系的代码：
import static org.junit.Assert.*;
import java.util.List;
import org.activiti.engine.FormService;
import org.activiti.engine.HistoryService;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ManagementService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.repository.DeploymentQuery;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.repository.ProcessDefinitionQuery;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskQuery;
import org.junit.Before;
import org.junit.Test;
public class ActivitiTest {
// 引擎只有一个即可
// 在类路径下找一个activiti.cfg.xml的配置文件来初始化流程引擎
// 服务组件和流程引擎都是接口；
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
TaskService taskService;
RuntimeService runtimeService;
// 部署流程，查询部署信息等...
RepositoryService repositoryService;
ManagementService managementService;
IdentityService identityService;
HistoryService historyService;
FormService formService;
@Before
public void serviceInit() {
// 任务服务组件：完成任务，签收任务等...
taskService = processEngine.getTaskService();
// 运行时服务组件：查询流程运行期间一些信息，控制流程等
runtimeService = processEngine.getRuntimeService();
// 持久化服务组件:负责保存流程定义信息等
repositoryService = processEngine.getRepositoryService();
// 管理组件，监听流程、定时任务等...
managementService = processEngine.getManagementService();
// 用户模块组件，CRUD一些用户以及用户分组等信息
identityService = processEngine.getIdentityService();
// 查询流程历史记录等信息；历史组件
historyService = processEngine.getHistoryService();
// 表单组件：没用
formService = processEngine.getFormService();
}
@Test
public void test() {
System.out.println("流程引擎：" + processEngine);
System.out.println("其他组件：");
}
/**
* 测试来定义一个流程，并把流程的定义信息保存在数据库中 1、每次流程图有修改以后，我们都需要重新部署，流程引擎才能用到新的流程 2、以前旧的流程都是存储在数据库中，新的流程也要存在数据库中
* 3、每次部署都会保存一个新的流程定义；act_re_procdef 4、同一个流程多次部署相当于只是版本叠加； 5、流程定义的key是用来识别版本是否叠加的；
*
* @Description (TODO这里用一句话描述这个方法的作用)
*/
@Test
public void testProcessDefinetionDeployee() {
// 1、如何定义一个流程；（画流程图）；
// 2、部署这个定义好的流程；
// 3、部署：去数据库保存这个流程定义的信息
Deployment deploy = repositoryService.createDeployment().addClasspathResource("process/请假流程新的.bpmn").deploy();
System.out.println("部署的流程deploy对象" + deploy.getId());
}
/**
* 查询所有的流程信息repositoryService
*
* @Description (TODO这里用一句话描述这个方法的作用)
*/
@Test
public void testQueryProcessDefinetion() {
// 查部署信息；
// DeploymentQuery query = repositoryService.createDeploymentQuery();
// 查流程定义；
// 每次部署都有一个部署id：id=12501
// 也可以用流程的唯一标示：id=myProcess01
ProcessDefinitionQuery definitionQuery = repositoryService.createProcessDefinitionQuery();
// 拿到所有数据库中的流程定义信息
long count = definitionQuery.count();
System.out.println("流程数量：" + count);
List<ProcessDefinition> list = definitionQuery.list();
for (ProcessDefinition processDefinition : list) {
System.out.println("流程id（流程框架生成的）：" + processDefinition.getId());
System.out.println("流程name（画流程时的流程名）：" + processDefinition.getName());
System.out.println("流程的key（画流程时的id）：" + processDefinition.getKey());
System.out.println("流程的资源信息：" + processDefinition.getResourceName() + "==>"
+ processDefinition.getDiagramResourceName());
System.out.println("流程的版本号：" + processDefinition.getVersion());
System.out.println("=====================");
}
System.out.println("精确查询......");
// //按照流程的id；按照流程的key；按照流程的版本
// ProcessDefinitionQuery d = definitionQuery.deploymentId("2501");
// System.out.println(d);
//
long count2 = definitionQuery.processDefinitionKeyLike("myProcess").count();
System.out.println(count2);
// System.out.println("版本："+definition.getVersion()+"==>"+definition.getKey()+"==>"+definition.getName());
}
/**
* 一个流程定义可以创建多个流程实例；
*
* processInstance.getProcessDefinitionId()：
* myProcess:4:7504
* myProcess:4:7504
*
* @Description (TODO这里用一句话描述这个方法的作用)
*/
@Test
public void test04() {
// 1、启动一个请假流程；
// 2、查出我们要启动的流程的信息；
ProcessDefinition definition = repositoryService.createProcessDefinitionQuery()
.processDefinitionKey("myProcess")
.latestVersion().singleResult();
System.out.println("流程的信息："+definition.getId()+"==>"+definition.getName()+"===>"+definition.getKey());
//3、启动这个流程；返回流程实例
ProcessInstance processInstance = runtimeService.startProcessInstanceById(definition.getId());
System.out.println("流程启动成功！"+processInstance.getActivityId());
System.out.println(""+processInstance.getProcessDefinitionId());
}
/**
* 测试任务
* @Description (TODO这里用一句话描述这个方法的作用)
* 1、查询所有任务；
* 2、将任务签收；（领任务完成任务）
*/
@Test
public void testTask(){
//1、查出当前系统有哪些任务；
//可以查某个流程当前走在了哪个任务：createTaskQuery().processDefinitionId("");
//可以查某个人现在需要做哪些任务；任务分配给了这些人；
//某个流程对应的所有任务
List<Task> list = taskService.createTaskQuery()
.processDefinitionId("myProcess:4:7504")
.list();
for (Task task : list) {
System.out.println("当前的任务信息：id:"+task.getId());
System.out.println("任务分給哪个人（由哪个人来处理）："+task.getAssignee());
System.out.println("任务名："+task.getName());
String assignee = "zhangsan";
System.out.println("任务签收；"+assignee+"签收了："+task.getId()+"");
taskService.claim(task.getId(), "zhangsan");
System.out.println("===================");
}
System.out.println("张三所要执行的任务...");
List<Task> list2 = taskService.createTaskQuery().taskAssignee("zhangsan").list();
for (Task task : list2) {
System.out.println("当前的任务信息：id:"+task.getId());
System.out.println("任务分給哪个人（由哪个人来处理）："+task.getAssignee());
System.out.println("任务名："+task.getName());
}
}
/**
* 1、任务相关操作都是使用taskService；
* 2、claim、complete；签收和完成
* 测试完成任务
* @Description (TODO这里用一句话描述这个方法的作用)
*/
@Test
public void testTaskComplete(){
//1、查出张三拥有的任务；
long count1 = taskService.createTaskQuery().taskAssignee("zhangsan").count();
System.out.println("任务数量："+count1);
System.out.println("=====================================");
List<Task> list = taskService.createTaskQuery().taskAssignee("zhangsan").list();
for (Task task : list) {
//完成任务；
System.out.println("当前的任务信息：id:"+task.getId());
System.out.println("任务名："+task.getName());
System.out.println("张三：完成任务"+task.getId());
taskService.complete(task.getId());
}
System.out.println("=====================================");
long count = taskService.createTaskQuery().taskAssignee("zhangsan").count();
System.out.println("任务数量："+count);
}
@Test
public void testProceTask(){
//看当前流程执行到哪个任务了；
List<Task> list = taskService.createTaskQuery().processDefinitionId("myProcess:4:7504").list();
for (Task task : list) {
System.out.println("当前的任务信息：id:"+task.getId());
System.out.println("任务名："+task.getName());
taskService.complete(task.getId());
}
System.out.println("==================");
List<Task> list2 = taskService.createTaskQuery().processDefinitionId("myProcess:4:7504").list();
for (Task task : list2) {
System.out.println("当前的任务信息：id:"+task.getId());
System.out.println("任务名："+task.getName());
taskService.complete(task.getId());
}
System.out.println("==================");
List<Task> list3 = taskService.createTaskQuery().processDefinitionId("myProcess:4:7504").list();
for (Task task : list3) {
System.out.println("当前的任务信息：id:"+task.getId());
System.out.println("任务名："+task.getName());
//dsadsadsadsadsa
taskService.complete(task.getId());
}
}
}
import static org.junit.Assert.*;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.activiti.engine.FormService;
import org.activiti.engine.HistoryService;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ManagementService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Before;
import org.junit.Test;
public class ActivitiTest02 {
// 引擎只有一个即可
// 在类路径下找一个activiti.cfg.xml的配置文件来初始化流程引擎
// 服务组件和流程引擎都是接口；
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
TaskService taskService;
RuntimeService runtimeService;
// 部署流程，查询部署信息等...
RepositoryService repositoryService;
ManagementService managementService;
IdentityService identityService;
HistoryService historyService;
FormService formService;
@Before
public void serviceInit() {
// 任务服务组件：完成任务，签收任务等...
taskService = processEngine.getTaskService();
// 运行时服务组件：查询流程运行期间一些信息，控制流程等
runtimeService = processEngine.getRuntimeService();
// 持久化服务组件:负责保存流程定义信息等
repositoryService = processEngine.getRepositoryService();
// 管理组件，监听流程、定时任务等...
managementService = processEngine.getManagementService();
// 用户模块组件，CRUD一些用户以及用户分组等信息
identityService = processEngine.getIdentityService();
// 查询流程历史记录等信息；历史组件
historyService = processEngine.getHistoryService();
// 表单组件：没用
formService = processEngine.getFormService();
}
/**
* 部署的信息：57501
* 部署的信息：65001
*
* @Description (TODO这里用一句话描述这个方法的作用)
*/
@Test
public void test() {
// 1、部署这个流程；
Deployment deploy = repositoryService.createDeployment().addClasspathResource("process/01请假的带变量版.bpmn")
.name("带变量的流程部署").deploy();
System.out.println("部署的信息：" + deploy.getId());
System.out.println("" + deploy.getName());
}
/**
* 流程启动完成：ProcessInstance[77501]
* @Description (TODO这里用一句话描述这个方法的作用)
*/
@Test
public void testStart() {
// 1、启动新版的请假流程；myprocess001:1:57504
//myprocess001:2:65004
// 启动时设置一些流程变量；方便下个任务可以获取;60001
Map<String, Object> map = new HashMap<String, Object>();
map.put("assigneer", "lisi");
ProcessInstance processInstance = runtimeService.startProcessInstanceById("myprocess001:2:65004", map);
System.out.println("流程启动完成："+processInstance);
}
@Test
public void testTask01(){
//1、使用lisi获取到它要执行的任务
// List<Task> list = taskService.createTaskQuery().taskAssignee("lisi").list();
// for (Task task : list) {
// System.out.println("任务名："+task.getName()+"==>"+task.getId());
//
// }
Task task = taskService.createTaskQuery().processDefinitionId("myprocess001:2:65004").taskAssignee("lisi").singleResult();
System.out.println("任务");
//任务有指定人去处理就不用签收；
//强制签收
// taskService.unclaim(task.getId());
// taskService.claim(taskId, userId);
System.out.println("任务名："+task.getName()+"==>"+task.getId());
Map<String, Object> map = new HashMap<String, Object>();
map.put("days", 2);
// map.put("reasons", "我病了");
//map.put("requester", "lisi");
taskService.complete(task.getId(), map);
System.out.println("完成任务。。。");
}
@Test
public void test01(){
List<Task> list = taskService.createTaskQuery().processDefinitionId("myprocess001:2:65004").list();
for (Task task : list) {
System.out.println("任务名："+task.getName()+"==>"+task.getId());
}
List<Task> list2 = taskService.createTaskQuery().taskAssignee("wangwu").list();
for (Task task : list2) {
System.out.println("任务名："+task.getName()+"==>"+task.getId());
taskService.complete(task.getId());
}
List<Task> list1 = taskService.createTaskQuery().processDefinitionId("myprocess001:2:65004").list();
System.out.println("还有任务？"+list1);
}
}import static org.junit.Assert.*;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.activiti.engine.FormService;
import org.activiti.engine.HistoryService;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ManagementService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.history.HistoricProcessInstanceQuery;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Before;
import org.junit.Test;
public class ActivitiTest03 {
// 引擎只有一个即可
// 在类路径下找一个activiti.cfg.xml的配置文件来初始化流程引擎
// 服务组件和流程引擎都是接口；
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
TaskService taskService;
RuntimeService runtimeService;
// 部署流程，查询部署信息等...
RepositoryService repositoryService;
ManagementService managementService;
IdentityService identityService;
HistoryService historyService;
FormService formService;
@Before
public void serviceInit() {
// 任务服务组件：完成任务，签收任务等...
taskService = processEngine.getTaskService();
// 运行时服务组件：查询流程运行期间一些信息，控制流程等
runtimeService = processEngine.getRuntimeService();
// 持久化服务组件:负责保存流程定义信息等
repositoryService = processEngine.getRepositoryService();
// 管理组件，监听流程、定时任务等...
managementService = processEngine.getManagementService();
// 用户模块组件，CRUD一些用户以及用户分组等信息
identityService = processEngine.getIdentityService();
// 查询流程历史记录等信息；历史组件
historyService = processEngine.getHistoryService();
// 表单组件：没用
formService = processEngine.getFormService();
}
/**
* 部署流程：部署的id：87501 流程定义的key：gov-process:1:87504
*
* @Description (TODO这里用一句话描述这个方法的作用)
*/
@Test
public void testDeploy() {
Deployment deploy = repositoryService.createDeployment().addClasspathResource("process/02政府审核.bpmn").deploy();
System.out.println("本次的部署信息" + deploy);
}
/**
* 启动流程实例
*
* @Description (TODO这里用一句话描述这个方法的作用)
*/
@Test
public void testStartProcessInstance() {
// 1、查出所有流程，看哪一个是要启动
ProcessInstance processInstance = runtimeService.startProcessInstanceById("gov-process:1:87504");
System.out.println("流程启动成功！" + processInstance);
}
@Test
public void testTaskAssignee() {
List<Task> list = taskService.createTaskQuery().taskAssignee("leifengyang").list();
for (Task task : list) {
System.out.println("任务信息：" + task.getId() + "；任务名：" + task.getName());
// 完成任务
// ${isFoodCompany == true}
// ${money>1000000}
// ${isCurrent == true}
Map<String, Object> variables = new HashMap<String, Object>();
variables.put("isFoodCompany", true);
variables.put("money", 1000001);
variables.put("isCurrent", true);
taskService.complete(task.getId(), variables);
}
}
/**
* 并行网关，必须所有汇聚点的分支都完成才可以
* @Description (TODO这里用一句话描述这个方法的作用)
*/
@Test
// gov-process:1:87504
public void test04() {
List<Task> list = taskService.createTaskQuery().processDefinitionId("gov-process:1:87504").list();
int i = 0;
for (Task task : list) {
System.out.println("任务信息：" + task.getId() + "；任务名：" + task.getName());
// 完成任务
taskService.complete(task.getId());
//if ((i++) % 2 == 0) {
// System.out.println("当前要完成的任务。"+task.getId() + "；任务名：" + task.getName());
// taskService.complete(task.getId());
//}
}
// List<HistoricProcessInstance> list2 = historyService.createHistoricProcessInstanceQuery().finished().list();
// for (HistoricProcessInstance historicProcessInstance : list2) {
// System.out.println(historicProcessInstance);
// }
//看这个流程是否完成了；
long count = historyService.createHistoricProcessInstanceQuery().processDefinitionId("gov-process:1:87504").finished().count();
System.out.println(count);
}
}import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.activiti.engine.FormService;
import org.activiti.engine.HistoryService;
import org.activiti.engine.IdentityService;
import org.activiti.engine.ManagementService;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Before;
import org.junit.Test;
public class ActivitiTest04 {
// 引擎只有一个即可
// 在类路径下找一个activiti.cfg.xml的配置文件来初始化流程引擎
// 服务组件和流程引擎都是接口；
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
TaskService taskService;
RuntimeService runtimeService;
// 部署流程，查询部署信息等...
RepositoryService repositoryService;
ManagementService managementService;
IdentityService identityService;
HistoryService historyService;
FormService formService;
@Before
public void serviceInit() {
// 任务服务组件：完成任务，签收任务等...
taskService = processEngine.getTaskService();
// 运行时服务组件：查询流程运行期间一些信息，控制流程等
runtimeService = processEngine.getRuntimeService();
// 持久化服务组件:负责保存流程定义信息等
repositoryService = processEngine.getRepositoryService();
// 管理组件，监听流程、定时任务等...
managementService = processEngine.getManagementService();
// 用户模块组件，CRUD一些用户以及用户分组等信息
identityService = processEngine.getIdentityService();
// 查询流程历史记录等信息；历史组件
historyService = processEngine.getHistoryService();
// 表单组件：没用
formService = processEngine.getFormService();
}
/**
* pd:gov-process:2:100004 pd:gov-process:3:105004
*
* @Description (TODO这里用一句话描述这个方法的作用)
*/
@Test
public void testDeploy() {
Deployment deploy = repositoryService.createDeployment().addClasspathResource("process/03政府审核.bpmn").deploy();
System.out.println(deploy + "部署完成");
}
// 流程启动：ProcessInstance[102501]
@Test
public void startProcess() {
ProcessInstance instance = runtimeService.startProcessInstanceById("gov-process:3:105004");
System.out.println("流程启动：" + instance);
}
@Test
public void testTask() {
// 1、查询流程有哪些任务
List<Task> pdTaskList = taskService.createTaskQuery().processDefinitionId("gov-process:3:105004").list();
System.out.println("流程任务：" + pdTaskList);
// 2、查询你有哪些任务
List<Task> perTaskList = taskService.createTaskQuery().taskAssignee("admin").list();
System.out.println("admin我的任务");
for (Task task : perTaskList) {
System.out.println(task);
// 完成任务；
if (task.getId().equals("107504")) {
Map<String, Object> variables = new HashMap<String, Object>();
variables.put("money", 10001);
variables.put("mone", 10001);
// taskService.complete(task.getId(), variables);
System.out.println("完成任务：" + task);
}
}
}
@Test
public void testCompletion() {
List<Task> pdTaskList = taskService.createTaskQuery().processDefinitionId("gov-process:3:105004").list();
System.out.println("流程任务：" + pdTaskList);
for (Task task : pdTaskList) {
System.out.println("完成任务："+task);
// if(task.getId().equals("115007")){
taskService.complete(task.getId());
// }
}
//查询这个流程是否执行完成了
long count = historyService.createHistoricProcessInstanceQuery().processDefinitionId("gov-process:3:105004").finished().count();
System.out.println("完成了？"+count);
}
}
这里还有activiti5的插件和用户手册的压缩包地址：https://download.youkuaiyun.com/download/qq_25106373/11246793
供大家方便下载。
扫一扫
1353
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
