Actiiti(进阶)

最新推荐文章于 2024-04-10 01:02:47 发布

DragonnAi

最新推荐文章于 2024-04-10 01:02:47 发布

阅读量281

点赞数

分类专栏： Spring java Activiti 文章标签： spring actiiti java

本文链接：https://blog.csdn.net/qq_43207259/article/details/84311269

版权

Spring 同时被 3 个专栏收录

10 篇文章 0 订阅

订阅专栏

java

10 篇文章 0 订阅

订阅专栏

Activiti

2 篇文章 0 订阅

订阅专栏

Activiti 进阶

一流程变量操作

1 流程变量操作

1.1流程变量概念

使用流程变量进行业务数据的传递，例如请假原因、天数等信息。

在这里插入图片描述

1.2设置流程变量

1.2.1 在启动流程实例时设置

在启动流程实例时，可以添加流程变量。这是添加流程变量的一种时机。

设置流程变量方式一：在启动流程实例时设置

@Test
public void test1() {
	String processDefinitionKey = "HelloWorldKsy";
	Map<String, Object> variables = new HashMap<String, Object>();
	variables.put("key1", "value1");
	variables.put("key2", 200);
	ProcessInstance pi = pe.getRuntimeService().startProcessInstanceByKey(processDefinitionKey, variables);
	System.out.println(pi.getId());
}

说明：

在启动流程实例时，通过重载startProcessInstanceByKey的方法可以加载流程变量。
第二个参数要求是Map<String ,Object>类型，意味着可以添加多个流程变量。
当这段代码执行完以后，会在数据库表act_ru_variable中添加两行记录。

1.2.2 在办理任务时设置

在办理任务时，有时候任务办理完成以后，要传递一些信息到系统中。这个时候可以利用TaskService这个类来添加流程实例。

	/**
	 * 设置流程变量方式二：在办理任务时设置
	 */
	@Test
	public void test3() {
		String taskId = "50006";
		Map<String, Object> variables = new HashMap<String, Object>();
		variables.put("user", new User(1,"小王"));
		pe.getTaskService().complete(taskId, variables);
	}

1.2.5 流程变量支持的类型

Jdk中提供的数据类型（String、Integer、List 、Map…）

自定义的实体类（要求实现序列化接口 Serializable）

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

在这里插入图片描述

从图中可以看出包括了大部分封装类型和Date、String和实现了Serializable接口的类的类型。

1.3获取流程变量

1.3.1使用RuntimeService的方法获取

可以通过runTimeService的方法来获取流程变量。说明：这些流程变量是从act_ru_variable这个表中读出来的，executionId可以通过Task对象来获取

/**
	 * 获取流程变量方式一：使用RuntimeService的方法获取
	 */
	@Test
	public void test6() {
		String executionId = "2501";
		Map<String, Object> variables = pe.getRuntimeService().getVariables(executionId);
		// System.out.println(variables);
		Set<String> set = variables.keySet();// key2 key1 user
		for (String key : set) {
			Object value = variables.get(key);
			System.out.println(key + " = " + value);
		}

		Object value = pe.getRuntimeService().getVariable(executionId, "user");
		System.out.println(value);
	}

二. 任务的类型

3.1个人任务

由某一个负责办理，在任务表中通过assignee字段记录

3.2公共任务（组任务）

当前的任务可以由多个人办理， 可以在设计流程图时指定多个办理人

在这里插入图片描述

/*
 * 公共任务测试
 */
public class PublicTask {
	
	ProcessEngine pe=null;

	@Before
	public void init(){
		pe = ProcessEngines.getDefaultProcessEngine();
	}
	
	/**
	 * 01-部署流程定义
	 */
	@Test
	public void test1(){
		DeploymentBuilder deploymentBuilder = pe.getRepositoryService().createDeployment();
		deploymentBuilder.addClasspathResource("Demo.bpmn");
		deploymentBuilder.addClasspathResource("Demo.png");
		Deployment deployment = deploymentBuilder.deploy();
		System.out.println("流程定义部署成功...");
	}
	
	/**
	 * 02-查询流程定义列表
	 */
	@Test
	public void test2() {
		// 流程定义查询对象,用于查询表act_re_procdef
		ProcessDefinitionQuery query = pe.getRepositoryService().createProcessDefinitionQuery();
		// 添加排序条件
		query.orderByProcessDefinitionVersion().desc();
		// 添加分页查询
		query.listPage(0, 10);
		List<ProcessDefinition> list = query.list();
		for (ProcessDefinition pd : list) {
			System.out.println(pd.getId() + "--" + pd.getName()+"--key:"+pd.getKey());
		}
	}
	
	/**
	 * 03-启动流程实例
	 */
	@Test
	public void test3(){
		String processDefinitionId="myProcess:1:60004";
		pe.getRuntimeService().startProcessInstanceById(processDefinitionId);
		System.out.println("流程实例定义成功.....");
	}
	
	/**
	 * 04-办理个人任务
	 */
	@Test
	public void test4(){
		String taskId="62504";
		pe.getTaskService().complete(taskId);
		System.out.println("任务办理成功....");
	}
	
	/**
	 * 05-查询公共任务列表
	 */
	@Test
	public void test5(){
		TaskQuery query = pe.getTaskService().createTaskQuery();
		//根据候选人过滤
		String candidateUser="小黑";
		query.taskCandidateUser(candidateUser);
		List<Task> list = query.list();
		for (Task task : list) {
			System.out.println(task.getName()+"----"+task.getId());
		}
	}
	
	/**
	 * 06-拾取任务(将公共任务变为个人任务)
	 */
	@Test
	public void test6(){
		String userId="小黑";
		String taskId="65002";
		pe.getTaskService().claim(taskId, userId);
		System.out.println("任务拾取成功..");
	}
	
	/**
	 * 07-查询个人任务列表
	 */
	@Test
	public void test7() {
		TaskQuery query = pe.getTaskService().createTaskQuery();
		String assignee = "小黑";
		query.taskAssignee(assignee);
		List<Task> list = query.list();
		for (Task task : list) {
			System.out.println("待办任务ID:"+task.getId());
			System.out.println("待办任务名称:"+task.getName());
			System.out.println("任务创建时间:"+task.getCreateTime());
			System.out.println("任务办理人:"+task.getAssignee());
			System.out.println("流程实例ID:"+task.getProcessInstanceId());
			System.out.println("执行对象ID:"+task.getExecutionId());
			System.out.println("流程定义ID:"+task.getProcessDefinitionId());
		}
	}
		
	/**
	 * 08-办理任务
	 */
	@Test
	public void test9(){
		String taskId= "65002";
		pe.getTaskService().complete(taskId);
		System.out.println("办理完成,任务ID是:"+taskId);
	}
}

3.3 接收任务

接收任务不是由某个人负责办理，通过signal方法让流程执行的

1542703950131

/**
 * 接受任务测试
 */
public class ReceiveTaskTest {

	ProcessEngine pe=null;

	@Before
	public void init(){
		pe = ProcessEngines.getDefaultProcessEngine();
	}
	
	/**
	 * 01-部署流程定义
	 */
	@Test
	public void test1(){
		DeploymentBuilder deploymentBuilder = pe.getRepositoryService().createDeployment();
		deploymentBuilder.addClasspathResource("Demo1.bpmn");
		deploymentBuilder.addClasspathResource("Demo1.png");
		Deployment deployment = deploymentBuilder.deploy();
		System.out.println("流程定义部署成功...");
	}
	
	/**
	 * 02-查询流程定义列表
	 */
	@Test
	public void test2() {
		// 流程定义查询对象,用于查询表act_re_procdef
		ProcessDefinitionQuery query = pe.getRepositoryService().createProcessDefinitionQuery();
		// 添加排序条件
		query.orderByProcessDefinitionVersion().desc();
		// 添加分页查询
		query.listPage(0, 10);
		List<ProcessDefinition> list = query.list();
		for (ProcessDefinition pd : list) {
			System.out.println(pd.getId() + "--" + pd.getName()+"--key:"+pd.getKey());
		}
	}
	
	/**
	 * 03-启动流程实例
	 */
	@Test
	public void test3(){
		String processDefinitionId="myProcess:2:75004";
		pe.getRuntimeService().startProcessInstanceById(processDefinitionId);
		System.out.println("流程实例定义成功.....");
	}
	
	/**
	 * 04-办理任务
	 */
	@Test
	public void test4(){
		String taskId = "77504";
		pe.getTaskService().complete(taskId );
	}
	
	/**
	 * 05-查询流程实例列表,查询act_ru_execution表
	 */
	@Test
	public void test9() {
		// 流程实例查询对象，查询act_ru_execution表
		ProcessInstanceQuery query = pe.getRuntimeService().createProcessInstanceQuery();
		query.processDefinitionKey("myProcess");
		query.orderByProcessInstanceId().desc();
		query.listPage(0, 2);
		List<ProcessInstance> list = query.list();
		for (ProcessInstance pi : list) {
			System.out.println(pi.getId() + " " + pi.getActivityId());
		}
	}
	
	/**
	 * 06-处理接收任务
	 */
	@Test
	public void test5(){
		String executionId = "77501";
		pe.getRuntimeService().signal(executionId);
	}
}

四.监听器(listener)

在流程中我们有时会对整个流程或者一个节点的某种状态做出相应的处理。这时就会用到监听器。

在Activiti中流程的监听主要分为两大类，执行监听器和任务监听器。

4.1执行监听器(ExecutionListener)

执行监听器可以执行外部java代码或执行表达式，当流程定义中发生了某个事件。可以出触发监听流程实例的事件

第一步：按照框架的规则编写监听器类

在这里插入图片描述

配置监听器，XML代码如下：

在这里插入图片描述

说明：

1.任务监听器支持以下属性：

event（必选）：任务监听器会被调用的任务类型。可能的类型为：
start：流程节点创建后触发。
end：当任务完成，并尚未从运行数据中删除时触发。

创建监听器类

class：必须调用的代理类。这个类必须实现org.activiti.engine.delegate. ExecutionListener接口。实现类代码如下：

/**
 * 自定义一个执行监听器
 */
public class MyExecutionListener1 implements ExecutionListener {

	/**
	 * 当监听的事件发送时，会自动触发该方法
	 */
	@Override
	public void notify(DelegateExecution execution) throws Exception {
		System.out.println("MyExecutionListener1-自定义的监听器执行了~");
	}
	
}

/**
 * 自定义一个执行监听器
 */
public class MyExecutionListener2 implements ExecutionListener {

	/**
	 * 当监听的事件发送时，会自动触发该方法
	 */
	@Override
	public void notify(DelegateExecution execution) throws Exception {
		System.out.println("MyExecutionListener2-自定义的监听器执行了~");
	}

}

测试执行监听器

/**
 * 执行监听器测试
 */
public class ExecutionListenerTest {

	ProcessEngine pe = null;

	@Before
	public void init() {
		pe = ProcessEngines.getDefaultProcessEngine();
	}

	/**
	 * 01-部署流程定义
	 */
	@Test
	public void test1() {
		DeploymentBuilder deploymentBuilder = pe.getRepositoryService().createDeployment();
		deploymentBuilder.addClasspathResource("com/activiti/listenner/ExecutionListenner.bpmn");
		deploymentBuilder.addClasspathResource("com/activiti/listenner/ExecutionListenner.png");
		Deployment deployment = deploymentBuilder.deploy();
		System.out.println("流程定义部署成功...");
	}

	/**
	 * 02-查询流程定义列表
	 */
	@Test
	public void test2() {
		// 流程定义查询对象,用于查询表act_re_procdef
		ProcessDefinitionQuery query = pe.getRepositoryService().createProcessDefinitionQuery();
		// 添加排序条件
		query.orderByProcessDefinitionVersion().desc();
		// 添加分页查询
		query.listPage(0, 10);
		List<ProcessDefinition> list = query.list();
		for (ProcessDefinition pd : list) {
			System.out.println(pd.getId() + "--" + pd.getName() + "--key:" + pd.getKey());
		}
	}

	/**
	 * 03-启动流程实例
	 */
	@Test
	public void test3() {
		String processDefinitionId = "myProcess:3:85004";
		pe.getRuntimeService().startProcessInstanceById(processDefinitionId);
		System.out.println("流程实例定义启动成功.....");
	}
	
	/**
	 * 04-查询个人任务列表
	 */
	@Test
	public void test7() {
		TaskQuery query = pe.getTaskService().createTaskQuery();
		String assignee = "Mary";
		query.taskAssignee(assignee);
		List<Task> list = query.list();
		for (Task task : list) {
			System.out.println("待办任务ID:"+task.getId());
			System.out.println("待办任务名称:"+task.getName());
			System.out.println("任务创建时间:"+task.getCreateTime());
			System.out.println("任务办理人:"+task.getAssignee());
			System.out.println("流程实例ID:"+task.getProcessInstanceId());
			System.out.println("执行对象ID:"+task.getExecutionId());
			System.out.println("流程定义ID:"+task.getProcessDefinitionId());
			Map<String, Object> map = task.getProcessVariables();
			Set<Entry<String, Object>> entrySet = map.entrySet();
			for (Entry<String, Object> entry : entrySet) {
				System.out.println(entry.getKey());
				System.out.println(entry.getValue());
			}
		}
	}

	/**
	 * 04-办理个人任务
	 */
	@Test
	public void test4() {
		String taskId = "90002";
		pe.getTaskService().complete(taskId);
		System.out.println("任务办理成功....");
	}
}

4.2任务监听器(TaskListener)

任务监听器可以在发生对应的任务相关事件时执行自定义java逻辑或表达式。

任务监听器只能添加到流程定义中的用户任务中。在之前任务节点上添加任务监听:

监听任务事件

第一步：按照activiti框架的规则编写一个任务监听器类

/**
 * 自定义任务监听器
 */
public class MyTaskListener1 implements TaskListener {

	@Override
	public void notify(DelegateTask delegateTask) {
		String assignee = delegateTask.getAssignee();
		String eventName = delegateTask.getEventName();
		System.out.println("事件名称:"+eventName);
		String name = delegateTask.getName();
		String processInstanceId = delegateTask.getProcessInstanceId();
		System.out.println("进程实例ID:"+processInstanceId);
		Set<String> variableNames = delegateTask.getVariableNames();
		for (String key : variableNames) {
			Object value = delegateTask.getVariable(key);
			System.out.println(key + " = " + value);
		}
		System.out.println("MyTaskListener1:一个任务[" + name + "]被创建了，由[" + assignee + "]负责办理");
	}
}

/**
 * 自定义任务监听器
 */
public class MyTaskListener2 implements TaskListener {

	@Override
	public void notify(DelegateTask delegateTask) {
		String assignee = delegateTask.getAssignee();
		String eventName = delegateTask.getEventName();
		System.out.println("事件名称:"+eventName);
		String name = delegateTask.getName();
		String processInstanceId = delegateTask.getProcessInstanceId();
		System.out.println("进程实例ID:"+processInstanceId);
		Set<String> variableNames = delegateTask.getVariableNames();
		for (String key : variableNames) {
			Object value = delegateTask.getVariable(key);
			System.out.println(key + " = " + value);
		}
		System.out.println("MyTaskListener2:一个任务[" + name + "]被创建了，由[" + assignee + "]负责办理");
	}
}

第二步：注册监听类

在这里插入图片描述

说明：

1.任务监听器支持以下属性：

event（必选）：任务监听器会被调用的任务类型。可能的类型为：
create：任务创建并设置所有属性后触发。
assignment：任务分配给一些人时触发。当流程到达userTask，assignment事件会在create事件之前发生。
complete：当任务完成，并尚未从运行数据中删除时触发。

新添加的任务监听包裹在executionListener监听的内部，顺序为：execution Start–> task Assignment–>task Create–>task Complete–>execution End

第三步：办理任务，由框架通过反射调用监听器类

/**
 * 任务监听器测试
 */
public class TaskListenerTest {

	ProcessEngine pe = null;

	@Before
	public void init() {
		pe = ProcessEngines.getDefaultProcessEngine();
	}
	
	/**
	 * 01-部署流程定义
	 */
	@Test
	public void test1() {
		DeploymentBuilder deploymentBuilder = pe.getRepositoryService().createDeployment();
		deploymentBuilder.addClasspathResource("com/activiti/listenner/task/TaskListenner.bpmn");
		deploymentBuilder.addClasspathResource("com/activiti/listenner/task/TaskListenner.png");
		Deployment deployment = deploymentBuilder.deploy();
		System.out.println("流程定义部署成功...");
	}
	

	/**
	 * 02-查询流程定义列表
	 */
	@Test
	public void test2() {
		// 流程定义查询对象,用于查询表act_re_procdef
		ProcessDefinitionQuery query = pe.getRepositoryService().createProcessDefinitionQuery();
		// 添加排序条件
		query.orderByProcessDefinitionVersion().desc();
		// 添加分页查询
		query.listPage(0, 10);
		List<ProcessDefinition> list = query.list();
		for (ProcessDefinition pd : list) {
			System.out.println(pd.getId() + "--" + pd.getName() + "--key:" + pd.getKey());
		}
	}
	
	/**
	 * 03-启动流程实例
	 */
	@Test
	public void test3(){
		String processDefinitionId = "TaskListennerTest:1:95004";
		Map<String, Object> variables = new HashMap<String, Object>();
		variables.put("key1", "v1");
		variables.put("k2", 300);
		pe.getRuntimeService().startProcessInstanceById(processDefinitionId , variables);
		System.out.println("流程实例启动成功.....");
	}
	
	/**
	 * 04-查询个人任务列表
	 */
	@Test
	public void test7() {
		TaskQuery query = pe.getTaskService().createTaskQuery();
		String assignee = "小李";
		query.taskAssignee(assignee);
		List<Task> list = query.list();
		for (Task task : list) {
			System.out.println("待办任务ID:"+task.getId());
			System.out.println("待办任务名称:"+task.getName());
			System.out.println("任务创建时间:"+task.getCreateTime());
			System.out.println("任务办理人:"+task.getAssignee());
			System.out.println("流程实例ID:"+task.getProcessInstanceId());
			System.out.println("执行对象ID:"+task.getExecutionId());
			System.out.println("流程定义ID:"+task.getProcessDefinitionId());
			Map<String, Object> map = task.getProcessVariables();
			Set<Entry<String, Object>> entrySet = map.entrySet();
			for (Entry<String, Object> entry : entrySet) {
				System.out.println(entry.getKey());
				System.out.println(entry.getValue());
			}
		}
	}
	
	/**
	 * 办理任务
	 */
	@Test
	public void test8(){
		String taskId = "97506";
		pe.getTaskService().complete(taskId );
	}
}

五.网关(gateWay)

网关用来控制流程的流向。

网关显示成菱形图形，内部有有一个小图标。图标表示网关的类型。

在这里插入图片描述

5.1排他网关(ExclusiveGateWay)

排他网关（也叫异或（XOR）网关，或更技术性的叫法基于数据的排他网关），用来在流程中实现决策。

图形标记

排他网关显示成一个普通网关（比如，菱形图形），内部是一个“X”图标，表示异或（XOR）语义。注意，没有内部图标的网关，默认为排他网关。 BPMN 2.0规范不允许在同一个流程定义中同时使用没有X和有X的菱形图形。

在这里插入图片描述

XML内容

排他网关的XML内容是很直接的：用一行定义了网关，条件表达式定义在外出顺序流中。参考条件顺序流获得这些表达式的可用配置。

在这里插入图片描述

它对应的XML内容如下：

<exclusiveGatewayid="exclusiveGw"name="Exclusive Gateway"/>
<sequenceFlowid="flow2"sourceRef="exclusiveGw"targetRef="theTask1">  
        <conditionExpressionxsi:type="tFormalExpression">${input == 1}</conditionExpression> 
</sequenceFlow>	
<sequenceFlowid="flow3"sourceRef="exclusiveGw"targetRef="theTask2">    
        <conditionExpressionxsi:type="tFormalExpression">${input == 2}</conditionExpression> 
</sequenceFlow>
<sequenceFlowid="flow4"sourceRef="exclusiveGw"targetRef="theTask3">  
        <conditionExpressionxsi:type="tFormalExpression">${input == 3}</conditionExpression> 
</sequenceFlow>

说明：

1.一个排他网关对应一个以上的顺序流

2.由排他网关流出的顺序流都有个conditionExpression元素，在内部维护返回boolean类型的决策结果。

3.决策网关只会返回一条结果。当流程执行到排他网关时，流程引擎会自动检索网关出口，从上到下检索如果发现第一条决策结果为true或者没有设置条件的(默认为成立)，则流出。

4.如果没有任何一个出口符合条件则抛出异常。

第一步：设计流程图，使用排他网关

在这里插入图片描述

第二步：执行流程，由框架根据设置的流程变量选择执行其中的一个分支

/**
 * 排他网关测试
 */
public class ExclusiveGateWayTest {

	ProcessEngine pe = null;

	@Before
	public void init() {
		pe = ProcessEngines.getDefaultProcessEngine();
	}
	
	/**
	 * 01-部署流程定义
	 */
	@Test
	public void test1() {
		DeploymentBuilder deploymentBuilder = pe.getRepositoryService().createDeployment();
		deploymentBuilder.addClasspathResource("com/activiti/ExclusiveGateWay/ExclusiveGateWay.bpmn");
		deploymentBuilder.addClasspathResource("com/activiti/ExclusiveGateWay/ExclusiveGateWay.png");
		Deployment deployment = deploymentBuilder.deploy();
		System.out.println("流程定义部署成功...");
	}
	

	/**
	 * 02-查询流程定义列表
	 */
	@Test
	public void test2() {
		// 流程定义查询对象,用于查询表act_re_procdef
		ProcessDefinitionQuery query = pe.getRepositoryService().createProcessDefinitionQuery();
		// 添加排序条件
		query.orderByProcessDefinitionVersion().desc();
		// 添加分页查询
		query.listPage(0, 10);
		List<ProcessDefinition> list = query.list();
		for (ProcessDefinition pd : list) {
			System.out.println(pd.getId() + "--" + pd.getName() + "--key:" + pd.getKey());
		}
	}
	
	/**
	 * 03-启动流程实例
	 */
	@Test
	public void test3(){
		String processDefinitionId = "ExclusiveGateWayTest:1:102504";
		pe.getRuntimeService().startProcessInstanceById(processDefinitionId);
		System.out.println("流程实例启动成功.....");
	}
	
	/**
	 * 04-查询个人任务列表
	 */
	@Test
	public void test4() {
		TaskQuery query = pe.getTaskService().createTaskQuery();
		String assignee = "小B";
		query.taskAssignee(assignee);
		List<Task> list = query.list();
		for (Task task : list) {
			System.out.println("待办任务ID:"+task.getId());
			System.out.println("待办任务名称:"+task.getName());
			System.out.println("任务创建时间:"+task.getCreateTime());
			System.out.println("任务办理人:"+task.getAssignee());
			System.out.println("流程实例ID:"+task.getProcessInstanceId());
			System.out.println("执行对象ID:"+task.getExecutionId());
			System.out.println("流程定义ID:"+task.getProcessDefinitionId());
			Map<String, Object> map = task.getProcessVariables();
			Set<Entry<String, Object>> entrySet = map.entrySet();
			for (Entry<String, Object> entry : entrySet) {
				System.out.println(entry.getKey());
				System.out.println(entry.getValue());
			}
		}
	}
	
	/**
	 * 05-办理任务，设置流程变量
	 */
	@Test
	public void test5(){
		String taskId = "107504";
		Map<String, Object> variables = new HashMap<String, Object>();
		variables.put("money", 800);
		pe.getTaskService().complete(taskId, variables);
		System.out.println("办理任务完成....");
	}
}

5.2并行网关(parallelGateWay)

网关也可以表示流程中的并行情况。最简单的并行网关是parallelGateWay，它允许将流程 分成多条分支，也可以把多条分支 汇聚到一起。

图形标记

并行网关显示成一个普通网关（菱形）内部是一个“加号”图标，表示“与（AND）”语义。

在这里插入图片描述

当两个任务都完成时，第二个并行网关会汇聚两个分支，因为它只有一条外出连线，不会创建并行分支，只会创建归档订单任务。

说明：

1.并行网关的功能是基于进入和外出的顺序流的：

分支(fork)：并行后的所有外出顺序流，为每个顺序流都创建一个并发分支。

汇聚(join)：所有到达并行网关，在此等待的进入分支，直到所有进入顺序流的分支都到达以后，流程就会通过汇聚网关。

2.并行网关的进入和外出都是使用相同节点标示

3.如果同一个并行网关有多个进入和多个外出顺序流，它就同时具有分支和汇聚功能。这时，网关会先汇聚所有进入的顺序流，然后再切分成多个并行分支。

4.并行网关不会解析条件。即使顺序流中定义了条件，也会被忽略。

并行网关不需要是“平衡的”（比如，

对应并行网关的进入和外出节点数目相等）。如图中标示是合法的：

在这里插入图片描述

第一步：设计流程图，使用并行网关

在这里插入图片描述

第二步：测试并行网关

/**
 * 并行网关测试
 */
public class ParallelGateWayTest {

	ProcessEngine pe = null;

	@Before
	public void init() {
		pe = ProcessEngines.getDefaultProcessEngine();
	}
	
	/**
	 * 01-部署流程定义
	 */
	@Test
	public void test1() {
		DeploymentBuilder deploymentBuilder = pe.getRepositoryService().createDeployment();
		deploymentBuilder.addClasspathResource("com/activiti/parallelGateWay/ParallelGateWay.bpmn");
		deploymentBuilder.addClasspathResource("com/activiti/parallelGateWay/ParallelGateWay.png");
		Deployment deployment = deploymentBuilder.deploy();
		System.out.println("流程定义部署成功...");
	}
	

	/**
	 * 02-查询流程定义列表
	 */
	@Test
	public void test2() {
		// 流程定义查询对象,用于查询表act_re_procdef
		ProcessDefinitionQuery query = pe.getRepositoryService().createProcessDefinitionQuery();
		// 添加排序条件
		query.orderByProcessDefinitionVersion().desc();
		// 添加分页查询
		query.listPage(0, 10);
		List<ProcessDefinition> list = query.list();
		for (ProcessDefinition pd : list) {
			System.out.println(pd.getId() + "--" + pd.getName() + "--key:" + pd.getKey());
		}
	}
	
	/**
	 * 03-启动流程实例
	 */
	@Test
	public void test3(){
		String processDefinitionId = "parallelGateWayTest:1:112504";
		pe.getRuntimeService().startProcessInstanceById(processDefinitionId);
		System.out.println("流程实例启动成功.....");
	}
	
	/**
	 * 04-查询个人任务列表
	 */
	@Test
	public void test4() {
		TaskQuery query = pe.getTaskService().createTaskQuery();
		String assignee = "卖家A";
		query.taskAssignee(assignee);
		List<Task> list = query.list();
		for (Task task : list) {
			System.out.println("待办任务ID:"+task.getId());
			System.out.println("待办任务名称:"+task.getName());
			System.out.println("任务创建时间:"+task.getCreateTime());
			System.out.println("任务办理人:"+task.getAssignee());
			System.out.println("流程实例ID:"+task.getProcessInstanceId());
			System.out.println("执行对象ID:"+task.getExecutionId());
			System.out.println("流程定义ID:"+task.getProcessDefinitionId());
			Map<String, Object> map = task.getProcessVariables();
			Set<Entry<String, Object>> entrySet = map.entrySet();
			for (Entry<String, Object> entry : entrySet) {
				System.out.println(entry.getKey());
				System.out.println(entry.getValue());
			}
		}
	}
	
	/**
	 * 05-办理任务
	 */
	@Test
	public void test5(){
		String taskId = "120002";
		pe.getTaskService().complete(taskId);
		System.out.println("办理任务完成....");
	}
}

六.整合Spring

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
      http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
      http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">


	<!-- 1.加载jdbc属性文件 -->
	<context:property-placeholder location="classpath:db.properties" />
	
	<!-- 2.数据源 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="jdbcUrl" value="${jdbcUrl}" />
		<property name="driverClass" value="${driverClass}" />
		<property name="user" value="${user}" />
		<property name="password" value="${password}" />
		<property name="initialPoolSize" value="${initialPoolSize}" />
		<property name="maxPoolSize" value="${maxPoolSize}" />
	</bean>

	<!-- 事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 配置一个spring提供的对象，用于创建一个流程引擎配置对象 -->
	<bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
		<property name="transactionManager" ref="transactionManager" />
		<property name="dataSource" ref="dataSource" />
		<property name="databaseSchemaUpdate" value="true" />
	</bean>

	<!-- 创建流程引擎对象 -->
	<bean id="pe" class="org.activiti.spring.ProcessEngineFactoryBean">
		<property name="processEngineConfiguration" ref="processEngineConfiguration" />
	</bean>

</beans>

		<!-- c3p0数据源 -->
		<dependency>
			<groupId>com.mchange</groupId>
			<artifactId>c3p0</artifactId>
			<version>0.9.5-pre10</version>
		</dependency>

测试

public class TestSpring {

	@Test
	public void test1() {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		ProcessEngine pe = (ProcessEngine) ctx.getBean("pe");
		System.out.println(pe);
	}
}

DragonnAi

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Actiiti(进阶)

Activiti 进阶一流程变量操作1 流程变量操作1.1流程变量概念使用流程变量进行业务数据的传递，例如请假原因、天数等信息。1.2设置流程变量1.2.1 在启动流程实例时设置在启动流程实例时，可以添加流程变量。这是添加流程变量的一种时机。设置流程变量方式一：在启动流程实例时设置@Testpublic void test1() { String processDef...
复制链接

扫一扫