Flowable常用API

已于 2022-08-14 11:05:46 修改
阅读量4k 收藏 16
点赞数 2
CC 4.0 BY-SA版权
分类专栏： flowable 文章标签： java 开发语言
于 2022-06-16 16:32:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/llwhlee/article/details/125317328
该博客详细介绍了如何使用工作流引擎创建和管理业务流程。首先，创建BpmnModel，包括设置用户任务、序列流和事件。接着，发布流程到仓库服务，并启动流程实例。流程中的签核操作，如通过和驳回，都有对应的处理逻辑。此外，还提供了查询签核历史记录、检查流程是否结束、获取流程签核节点以及分页查询待办和已办任务的方法。整个流程管理实现覆盖了流程的创建、执行和监控等关键环节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  1. 创建BpmnModel
private final String USERTASKID="UserTaskId";

	public BpmnModel createBpmnModel(CustomsFlowDefinition customsFlowDefinition) {
		BpmnModel bpmnModel = new BpmnModel();
		Process process = new Process();
		process.setId(customsFlowDefinition.getFlowName());
		createSequenceFlow(process,customsFlowDefinition);
		createUserTask(process,customsFlowDefinition);
		bpmnModel.addProcess(process);
		return bpmnModel;
	}

	private Process createEvent(Process process, String flowName, LinkedList<SequenceFlow> linkedList) {
		StartEvent startEvent = new StartEvent();
		startEvent.setName("StartEventName");
		startEvent.setId("StartEventId");
		startEvent.setOutgoingFlows(Arrays.asList(linkedList.getFirst()));
		process.addFlowElement(startEvent);
		EndEvent endEvent = new EndEvent();
		endEvent.setName( "EndEventName");
		endEvent.setId("EndEventId");
		endEvent.setOutgoingFlows(Arrays
			.asList(linkedList.getLast()));
		process.addFlowElement(endEvent);
		return process;

	}


	private Process createSequenceFlow(Process process, CustomsFlowDefinition customsFlowDefinition) {
		LinkedList<SequenceFlow> linkedList = new LinkedList<>();
		for (int i = 0; i < customsFlowDefinition.getNodes().size() + 1; i++) {
			SequenceFlow sequenceFlow = new SequenceFlow();
			sequenceFlow.setId("SeqId" + i);
			sequenceFlow.setName("SeqName" + i);
			if (i == 0) {
				sequenceFlow.setSourceRef("StartEventId");
				sequenceFlow.setTargetRef(customsFlowDefinition.getNodes().get(0).getNodeKey());
			}else if (i == customsFlowDefinition.getNodes().size()) {
				sequenceFlow.setSourceRef(customsFlowDefinition.getNodes().get(customsFlowDefinition.getNodes().size()-1).getNodeKey());
				sequenceFlow.setTargetRef("EndEventId");
			}else {
				sequenceFlow.setSourceRef(customsFlowDefinition.getNodes().get((i-1)).getNodeKey());
				sequenceFlow.setTargetRef(customsFlowDefinition.getNodes().get((i)).getNodeKey());
			}
			sequenceFlow.setConditionExpression("${outcome=='agree'}");
			process.addFlowElement(sequenceFlow);
			linkedList.add(sequenceFlow);
		}
		createEvent(process,customsFlowDefinition.getFlowName(),linkedList);
		return process;
	}


	private UserTask createUserTask(String taskId, String taskName,
	                                SequenceFlow inSequenceFlow, SequenceFlow outSequenceFlow,
	                                String userId) {
		UserTask userTask = new UserTask();
		userTask.setAssignee(userId);
		userTask.setName(taskName);
		userTask.setId(taskId);
		return userTask;
	}


	private Process createUserTask(Process process, CustomsFlowDefinition customsFlowDefinition) {
		for (int i = 0; i < customsFlowDefinition.getNodes().size(); i++) {
			List<String> users = new ArrayList<String>();
			users.add("${userIds}");
			UserTask userTask = new UserTask();
			String userTaskName=customsFlowDefinition.getNodes().get(i).getNodeName();
			String userTaskId=customsFlowDefinition.getNodes().get(i).getNodeKey();
			Assert.state(!StringUtils.isEmpty(userTaskId),"节点key不能为空");
			userTask.setName(userTaskName==null?("UserTaskName"+i):userTaskName);
			userTask.setId(userTaskId);
			userTask.setCandidateUsers(users);
			process.addFlowElement(userTask);
		}
		return process;
	}
  1. 发布流程
RepositoryService repositoryService = processEngine
				.getRepositoryService();
			Deployment deployment = repositoryService.createDeployment()
				.addBpmnModel(businessKey + ".bpmn", bpmnModel)
				.name(flowName).deploy();
			ProcessDefinition processDefinition = repositoryService
				.createProcessDefinitionQuery().deploymentId(deployment.getId())
				.singleResult();
			String id = processDefinition.getId();
  1. 开始一个流程实例
ProcessInstance processInstance = processEngine.getRuntimeService()
			.startProcessInstanceById(flowId, businessKey, variables);
  1. 签核通过
Task task = taskService
			.createTaskQuery()
			.processInstanceId(processId).active().singleResult();
		Map<String, Object> variables = new HashMap<String, Object>();
		variables.put("outcome", "agree");
		variables.put("userIds", users);
		taskService.addComment(task.getId(), processId, remarks);
		taskService.setAssignee(task.getId(), userId);
		taskService.complete(task.getId(), variables);
  1. 签核驳回

 TaskService taskService = processEngine.getTaskService();
		Task task = taskService.createTaskQuery()
		.processInstanceId(processInstanceId).active().singleResult();
		List<CustomsFlowHistory> list = queryHistoryData(processInstanceId);
		if (null == targetNodeId) {
			targetNodeId = list.get(0).getNodeId();
		}
		List<String> key = new ArrayList<String>();
		key.add(task.getTaskDefinitionKey());
		taskService.setAssignee(task.getId(), currentOptUserId);
		taskService.addComment(task.getId(), task.getProcessInstanceId(),
			rejectionReason);
RuntimeService runtimeService = processEngine.getRuntimeService();
		runtimeService.setVariable(processInstanceId, "userIds", targetUserid);
		runtimeService.createChangeActivityStateBuilder()
			.processInstanceId(processInstanceId)
	.moveActivityIdsToSingleActivityId(currentActivityId,
				newActivityId)
			.changeState();

6.查询签核历史记录

 HistoryService historyService = processEngine.getHistoryService();
		TaskService taskService = processEngine.getTaskService();
		List<HistoricActivityInstance> activities = historyService
			.createHistoricActivityInstanceQuery()
			.processInstanceId(processInstanceId).activityType("userTask")
			.orderByHistoricActivityInstanceEndTime().asc().list();

7.查询流程是否结束

public boolean isFlowEnd(String processInstanceId) {

		// TODO Auto-generated method stub
		boolean result = false;
		TaskService taskService = processEngine.getTaskService();
		RepositoryService repositoryService = processEngine.getRepositoryService();
		Task task = taskService.createTaskQuery()
			.processInstanceId(processInstanceId).singleResult();
		if(task==null){
			return true;
		}
		String definitionId = processEngine.getHistoryService()
			.createProcessInstanceHistoryLogQuery(processInstanceId).singleResult()
			.getProcessDefinitionId();
		BpmnModel bpmnModel = repositoryService.getBpmnModel(definitionId);
		FlowNode flowNode = (FlowNode) bpmnModel
			.getFlowElement(task.getTaskDefinitionKey());
		List<SequenceFlow> outgoingFlows = flowNode.getOutgoingFlows();
		for (SequenceFlow outgoingFlow : outgoingFlows) {
			FlowElement targetFlowElement = outgoingFlow.getTargetFlowElement();
			if (targetFlowElement instanceof EndEvent) {
				result = true;
				break;
			}
		}
		return result;
	}

8.查询流程签核节点

public List<CustomsFlowNode> queryFlowNode(String processId) {
				ProcessInstance processInstance = processEngine.getRuntimeService()
					.createProcessInstanceQuery().processInstanceId(processId).singleResult();
				List<UserTask> list = allFlowNode(processInstance.getProcessDefinitionId());
				if (list != null) {
					return list.stream().map(userTask -> {
						CustomsFlowNode customsFlowNode = new CustomsFlowNode();
						customsFlowNode.setNodeName(userTask.getName());
						return customsFlowNode;
					}).collect(Collectors.toList());
				}
				return null;
			}
public List<UserTask> allFlowNode(String flowId) {
		RepositoryService repositoryService = processEngine.getRepositoryService();
		StringBuffer buffer = new StringBuffer();
		BpmnModel bpmnModel = repositoryService.getBpmnModel(flowId);
		Process process = bpmnModel.getProcesses().get(0);
		Collection<FlowElement> flowElements = process.getFlowElements();
		return flowElements.stream().filter(element -> element instanceof UserTask).map(e -> (UserTask) e).collect(Collectors.toList());
	}

9.查询所有的流程

 List<ProcessDefinition> list = processEngine.getRepositoryService()
			.createProcessDefinitionQuery()
			.orderByProcessDefinitionVersion().asc()
			.list();

10.删除流程

processEngine.getRuntimeService().deleteProcessInstance(processId, reason);

11.分页查询代办任务

List<Task> list = processEngine.getTaskService()
			.createTaskQuery()
			.taskCandidateOrAssigned(userId).orderByTaskDueDate().desc().includeProcessVariables()
			.active().orderByProcessInstanceId().desc()
			.listPage((firstResult-1)*maxResults, firstResult*maxResults-1);

12.分页查询已办任务

HistoryService historyService = processEngine.getHistoryService();
historyService.createHistoricTaskInstanceQuery()
				.processVariableValueEquals(BUSINESSTYPE, documentType)
				.taskAssignee(userId).includeProcessVariables().orderByProcessInstanceId().desc()
				.finished()
				.listPage((firstResult-1)*maxResults, firstResult*maxResults-1);

13.获取当前流程实例在整个流程图片

public InputStream getImageoutputStream(String processInstanceId,
	                                        String flowId) {
		RuntimeService runtimeService = processEngine.getRuntimeService();
		HistoryService historyService = processEngine.getHistoryService();
		RepositoryService repositoryService = processEngine.getRepositoryService();
		List<String> highLightedActivities = runtimeService
			.getActiveActivityIds(processInstanceId);
		if (highLightedActivities != null) {
			ProcessDiagramGenerator defaultProcessDiagramGenerator = new DefaultProcessDiagramGenerator();
			List<String> highLightedFlows = new ArrayList<String>();
			HistoricProcessInstance his = historyService
				.createHistoricProcessInstanceQuery()
				.processInstanceId(processInstanceId).singleResult();
			BpmnModel model = repositoryService.getBpmnModel(flowId);
			InputStream ips = defaultProcessDiagramGenerator.generateDiagram(
				model, "png", highLightedActivities, highLightedFlows, "宋体",
				"宋体", "宋体", null, 1.0);
			return ips;
		}
		return null;
	}
Flowable基础API小结
摸魚散人的博客
01-05 1274
flowable流程部署、启动、挂起、暂停、service等api学习小结和图标介绍
Flowable 6.6.0 BPMN用户指南 - (3) The Flowable API - 3.3 查询API（Query API）
月满闲庭的博客
12-29 771
3.3 查询API（Query API） There are two ways of querying data from the engine: the query API and native queries. The Query API allows you to program completely typesafe queries with a fluent API. You can add various conditions to your queries (all of which are
flowable_rest_api接口详细介绍
11-20
切记不要自动换行！ 全是我自己对它的理解和查看源码来进行中文注解的，如果注解有错请联系我进行修改。
flowable基本服务
limonero
12-24 950
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine(); RuntimeService runtimeService = processEngine.getRuntimeService(); RepositoryService repositoryService = processEngine. getRepositoryService(); TaskService taskService = processEngine.
Flowable 脚本 API 深度详解
最新发布
csdn_tom_168的博客
07-13 593
Flowable脚本API技术解析 摘要：Flowable脚本API提供了一套完整的流程控制接口，主要包括： Execution对象支持流程实例控制，包括获取流程信息、触发事件、终止流程等操作 DelegateTask对象提供任务管理功能，可设置处理人、截止时间、完成任务等 变量操作API支持多种数据类型处理，包括JSON、日期和序列化对象 引擎服务API涵盖RuntimeService（流程实例管理）、TaskService（任务操作）、IdentityService（用户管理）等核心服务 高级特性包括异
Flowable主要API介绍
zp的博客
09-17 3063
负责与各个服务进行交互和管理流程的整个生命周期。
Flowable API
Dowjone梦工厂
02-01 4226
Flowable API   流程引擎API与服务 引擎API是与Flowable交互的最常用手段。总入口点是ProcessEngine。可以使用多种方式创建。使用ProcessEngine，可以获得各种提供工作流/BPMN方法的服务。它是线程安全的，可以在服务器中保存并共用一个引用。   ProcessEngine processEngine = ProcessEngine...
flowable常用api
03-08
### Flowable 常用 API 及其使用方法 #### ProcessEngine 的获取与初始化 ProcessEngine 是与 Flowable 交互的主要入口点。可以通过多种方式创建 `ProcessEngine` 实例，具体取决于应用程序的需求和环境设置[^1]。 ...
flowable 流程引擎API与服务
03-23 1709
引擎API是与Flowable交互的最常用手段。总入口点是ProcessEngine。 1、RepositoryService很可能是使用Flowable引擎要用的第一个服务。这个服务提供了管理与控制部署(deployments)与流程定义(process definitions)的操作。管理静态信息， 2、RuntimeService用于启动流程定义的新流程实例。 3、IdentityService很简单。它用于管理（创建，更新，删除，查询……）组与用户。 4、FormService是可选服务。也
Flowable中文文档（v 6.4.2）
01-06
工作流程设计平台 Flowable 的 Word 版中文文档（v 6.4.2），本人自己从英语原版翻译而来，收获很多！
工作流Flowable 入门API
fouling的博客
07-12 1090
工作流Flowable 常用service对象，以及常用PAI
【工作流引擎】Flowable快速入门（一） 基础API使用
Vincent Vic
04-23 2614
【工作流引擎】Flowable快速入门（一） 基础API使用 获取ProcessEngine、原生构建、ProcessEngine API、 服务说明、Spring 依赖注入、流程部署、 部署流程定义、流程部署、xml文件和String 部署、BpmnModel 部署、 流程部署查询、流程图片查询、 流程XML查询、 流程删除、流程启动、无参启动、带参数启动、设置流程发起人、运行实例查询、激活或挂起；任务查询、完成，任务评论，任务附件，历史任务查询
[3]工作流框架：Flowable Restful API 一览
超越梦想，一起飞！！！
01-15 3171
在前面的两个章节中《[1]工作流框架：Flowable基本安装》和《[2]工作流框架：支持MySQL的Flowable安装》两个章节中，笔者介绍了如何安装和配置工作流引擎；配置完成后，我们就能看到Flowable的API的Swagger文档了，这个章节笔者就带大家一起领略一下Flowable工作的流暴露出来的restful API。 Flowable Restful API 总览 Flowable API总共分为下面几大类： Process[流程] IDM[Identity Management]
Flowable入门系列文章13 - Flowable API 03
分享牛
10-03 886
flowable入门、flowable现状、flowable开源产品、flwoable入门系列、flowable课程、flowable与activiti区别 Flowable是用Java编写的轻量级业务流程引擎。Flowable流程引擎允许您部署BPMN 2.0流程定义（用于定义流程的行业XML标准），创建 流程定义的流程实例，运行查询，访问活动或历史流程实例以及相关数据等等。本节将逐步介绍各种概念和API，通过您可以在自己的开发 机器上进行的实例进行实现。
Flowable 学习 (Ⅲ) ----API学习
故小曲啊
06-14 1143
流程引擎API与服务 关系图： 可以通过ProcessEngine来获取相对的Service： ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine(); RuntimeService runtimeService = processEngine.getRuntimeService(); RepositoryS...
Flowable从零单排（四）Flowable API
江黎
03-02 2283
1. 流程引擎API与服务 引擎API是与Flowable交互的最常用手段。总入口点是ProcessEngine。像配置章节中介绍的一样，ProcessEngine可以使用多种方式创建。使用ProcessEngine，可以获得各种提供工作流/BPM方法的服务。ProcessEngine与服务对象都是线程安全的，因此可以在服务器中保存并共用同一个引用。 @Test void processEngineAPI() { ProcessEngine processEngin
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值