flowable已发起流程管理 1.新增节点、2.修改流程节点路径、3.移动某个节点（自由跳转，当前节点自动完成）

最新推荐文章于 2024-05-30 11:11:21 发布
最新推荐文章于 2024-05-30 11:11:21 发布
阅读量545 收藏 4
点赞数 15
分类专栏： flowable 文章标签： java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39501624/article/details/139249629
版权

flowable已发起流程变更节点、修改节点路径、移动节点

flowable已发起流程变更节点、修改节点路径、移动节点

1.引入包：为了后面自适应排版

implementation "org.flowable:flowable-bpmn-layout:6.4.1"

2.模版类：UserTaskDTO

@Data
public class UserTaskDTO {
    /**
     * type：0新增节点；1：修改流程节点路径
     */
    @NotNull(message = "type不能为空")
    private Integer type;
    /**
     * taskId:节点ID
     */
    private String taskId;
    /**
     * processInstanceId:流程ID
     */
    @NotBlank(message = "processInstanceId不能为空")
    private String processInstanceId;
    /**
     * 自定义ID或者是传入ID（为空是自动生成）
     */
    private String id;
    /**
     * 名称
     */
    private String name;
    /**
     * 人员变量
     */
    private String assignee;
    /**
     * 表单标识
     */
    private String formKey;
    /**
     * 多实例问题
     */
    private MultiInstanceLoopCharacteristicsDTO multiInstanceLoopCharacteristicsDTO;
    /**
     * 任务监听器列表
     */
    private List<TaskListenerDTO> taskListenerList;
    /**
     * 执行监听器列表
     */
    private List<ExecutionListenerDTO> executionListenerList;
    /**
     * 出线规律（不配置默认拿到当前节点的出线规则）
     */
    private List<SequenceFlowDTO> sequenceFlowList;
}

3.模版类：MultiInstanceLoopCharacteristicsDTO

 @Data
public class MultiInstanceLoopCharacteristicsDTO {

    /**完成条件
     1.${nrOfInstances == nrOfCompletedInstances}：表示所有人都需要完成任务会签才结束；
     2.${nrOfCompletedInstances == 1}：表示一个人完成任务，会签结束
     3.可自定义
    **/
    private String completionCondition;

    /**
     * 多实例类型（是否是顺序的）
     */
    private Boolean sequential;
    /**
     * //集合
     */
    private  String inputDataItem;

    /**
     * 元素变量
     */
    private  String elementVariable;

}

4.模版类：TaskListenerDTO

@Data
public class TaskListenerDTO {
    /**
     * 事件
     */
    private String event;
    /**
     * 类型 ：class
     */
    private String implementationType ="class";
    /**
     * 类名称
     */
    private String implementation;
}

5.模版类：ExecutionListenerDTO

@Data
public class ExecutionListenerDTO {

    /**
     * 事件
     */
    private String event;
    /**
     * 类型 ：class
     */
    private String implementationType ="class";
    /**
     * 类名称
     */
    private String implementation;
}

6.模版类：SequenceFlowDTO

@Data
public class SequenceFlowDTO {
    /**
     * 名称
     */
    private String name;
    /**
     * 描述
     */
    private String documentation;
    /**
     * 表达式
     */
    private String conditionExpression;
    /**
     * 进入的node节点id
     */
    private String sourceRef;
    /**
     * 转换的node节点id
     */
    private String targetRef;
    /**
     * 跳过表达式
     */
    private String skipExpression;

}

7.实现方法

@Slf4j
public class CustomInjectUserTaskInProcessInstanceCmd extends AbstractDynamicInjectionCmd implements Command<Void> {

    protected UserTaskDTO userTaskDTO;
    protected DynamicUserTaskBuilder dynamicUserTaskBuilder;

    private final FlowElement currentFlowElemet;

    public CustomInjectUserTaskInProcessInstanceCmd(UserTaskDTO userTaskDTO, DynamicUserTaskBuilder dynamicUserTaskBuilder, FlowElement currentFlowElemet) {
        this.userTaskDTO = userTaskDTO;
        this.dynamicUserTaskBuilder = dynamicUserTaskBuilder;
        this.currentFlowElemet = currentFlowElemet;
    }

    @Override
    public Void execute(CommandContext commandContext) {
        createDerivedProcessDefinitionForProcessInstance(commandContext, userTaskDTO.getProcessInstanceId());
        return null;
    }

    @Override
    protected void updateBpmnProcess(CommandContext commandContext, Process process,
                                     BpmnModel bpmnModel, ProcessDefinitionEntity originalProcessDefinitionEntity, DeploymentEntity newDeploymentEntity){

        //type：0新增节点；1：修改流程节点路径
        if(userTaskDTO.getType().equals(0)){
            List<StartEvent> startEvents = process.findFlowElementsOfType(StartEvent.class);
            StartEvent initialStartEvent = null;
            for (StartEvent startEvent : startEvents) {
                if (startEvent.getEventDefinitions().isEmpty()) {
                    initialStartEvent = startEvent;
                    break;
                } else if (initialStartEvent == null) {
                    initialStartEvent = startEvent;
                }
            }
            
                UserTask userTask = new UserTask();
                userTask.setId(userTaskDTO.getId());
                userTask.setName(userTaskDTO.getName());
                userTask.setAssignee(userTaskDTO.getAssignee());

                // 设置任务监听器
                if(CollectionUtil.isNotEmpty(userTaskDTO.getTaskListenerList())){
                    List<FlowableListener>flowableListenerList=new ArrayList<>();
                    userTaskDTO.getTaskListenerList().forEach(task->{
                        FlowableListener flowableListener=new FlowableListener();
                        flowableListener.setEvent(task.getEvent());
                        flowableListener.setImplementationType(task.getImplementationType());
                        flowableListener.setImplementation(task.getImplementation());
                        flowableListenerList.add(flowableListener);
                    });
                    userTask.setTaskListeners(flowableListenerList);
                }
                // 设置执行监听器
                if(CollectionUtil.isNotEmpty(userTaskDTO.getExecutionListenerList())){
                    List<FlowableListener>flowableListenerList=new ArrayList<>();
                    userTaskDTO.getExecutionListenerList().forEach(execution->{
                        FlowableListener flowableListener=new FlowableListener();
                        flowableListener.setEvent(execution.getEvent());
                        flowableListener.setImplementationType(execution.getImplementationType());
                        flowableListener.setImplementation(execution.getImplementation());
                        flowableListenerList.add(flowableListener);
                    });
                    userTask.setExecutionListeners(flowableListenerList);
                }

                //formKey
                if(StrUtil.isNotBlank(userTaskDTO.getFormKey())){
                    userTask.setFormKey(userTaskDTO.getFormKey());
                }


                //多实例问题
                MultiInstanceLoopCharacteristicsDTO multiInstanceLoopCharacteristicsDtos = userTaskDTO.getMultiInstanceLoopCharacteristicsDTO();
                if(multiInstanceLoopCharacteristicsDtos!=null){
                    MultiInstanceLoopCharacteristics multiInstanceLoopCharacteristics=new MultiInstanceLoopCharacteristics();
                    multiInstanceLoopCharacteristics.setCompletionCondition(multiInstanceLoopCharacteristicsDtos.getCompletionCondition());
                    multiInstanceLoopCharacteristics.setSequential(multiInstanceLoopCharacteristicsDtos.getSequential());
                    multiInstanceLoopCharacteristics.setInputDataItem(multiInstanceLoopCharacteristicsDtos.getInputDataItem());
                    multiInstanceLoopCharacteristics.setElementVariable(multiInstanceLoopCharacteristicsDtos.getElementVariable());
                    userTask.setLoopCharacteristics(multiInstanceLoopCharacteristics);
                }

                UserTask currentFlowElemet = (UserTask) this.currentFlowElemet;
                SequenceFlow sequenceFlow;

                List<SequenceFlow> outgoingFlows = new ArrayList<>();
                if(CollectionUtil.isNotEmpty(userTaskDTO.getSequenceFlowList())){
                    for (SequenceFlow sequenceFlow1 : currentFlowElemet.getOutgoingFlows()) {
                        //删除原先节点的出线
                        process.removeFlowElement(sequenceFlow1.getId());
                    }
                    //增加新的线段
                    for (SequenceFlowDTO sequenceFlowNew :userTaskDTO.getSequenceFlowList()){
                        sequenceFlow = new SequenceFlow(StrUtil.isBlank(sequenceFlowNew.getSourceRef())?userTask.getId():sequenceFlowNew.getSourceRef(),sequenceFlowNew.getTargetRef());
                        sequenceFlow.setSkipExpression(sequenceFlowNew.getSkipExpression());
                        sequenceFlow.setConditionExpression(sequenceFlowNew.getConditionExpression());
                        sequenceFlow.setName(sequenceFlowNew.getName());
                        sequenceFlow.setId("seq_"+ UUID.randomUUID().toString().replaceAll("-","" ));
                        outgoingFlows.add(sequenceFlow);
                        process.addFlowElement(sequenceFlow);
                    }

                }else{
                    for (SequenceFlow sequenceFlow1 : currentFlowElemet.getOutgoingFlows()) {
                        sequenceFlow = new SequenceFlow(userTask.getId(),sequenceFlow1.getTargetRef());
                        sequenceFlow.setSkipExpression(sequenceFlow1.getSkipExpression());
                        sequenceFlow.setConditionExpression(sequenceFlow1.getConditionExpression());
                        sequenceFlow.setExtensionElements(sequenceFlow1.getExtensionElements());
                        sequenceFlow.setExecutionListeners(sequenceFlow1.getExecutionListeners());
                        sequenceFlow.setName(sequenceFlow1.getName());
                        sequenceFlow.setId("seq_"+ UUID.randomUUID().toString().replaceAll("-","" ));
                        outgoingFlows.add(sequenceFlow);
                        //删除原先节点的出线
                        process.removeFlowElement(sequenceFlow1.getId());
                        process.addFlowElement(sequenceFlow);
                    }
                }


                List<SequenceFlow> incomingFlows = new ArrayList<>();
                SequenceFlow incomingFlow = new  SequenceFlow(currentFlowElemet.getId(),userTask.getId());
                // 可以设置唯一编号，这里通过雪花算法设置
                incomingFlow.setId("seq_"+ UUID.randomUUID().toString().replaceAll("-","" ));
                incomingFlows.add(incomingFlow);

                process.addFlowElement(incomingFlow);
                userTask.setOutgoingFlows(outgoingFlows);
                userTask.setIncomingFlows(incomingFlows);
                process.addFlowElement(userTask);

                //新增坐标 点
                GraphicInfo elementGraphicInfo = bpmnModel.getGraphicInfo(currentFlowElemet.getId());
                if (elementGraphicInfo != null) {
                    double yDiff = 0;
                    double xDiff = 80;
                    if (elementGraphicInfo.getY() < 173) {
                        yDiff = 173 - elementGraphicInfo.getY();
                        elementGraphicInfo.setY(173);
                    }

                    Map<String, GraphicInfo> locationMap = bpmnModel.getLocationMap();
                    for (String locationId : locationMap.keySet()) {
                        if (initialStartEvent != null && initialStartEvent.getId().equals(locationId)) {
                            continue;
                        }
                        GraphicInfo locationGraphicInfo = locationMap.get(locationId);
                        locationGraphicInfo.setX(locationGraphicInfo.getX() + xDiff);
                        locationGraphicInfo.setY(locationGraphicInfo.getY() + yDiff);
                    }

                    Map<String, List<GraphicInfo>> flowLocationMap = bpmnModel.getFlowLocationMap();
                    for (String flowId : flowLocationMap.keySet()) {
                        List<GraphicInfo> flowGraphicInfoList = flowLocationMap.get(flowId);
                        for (GraphicInfo flowGraphicInfo : flowGraphicInfoList) {
                            flowGraphicInfo.setX(flowGraphicInfo.getX() + xDiff);
                            flowGraphicInfo.setY(flowGraphicInfo.getY() + yDiff);
                        }
                    }
                    new BpmnAutoLayout(bpmnModel).execute();
                }
            }

        }else if(userTaskDTO.getType().equals(1)){
            UserTask currentFlowElemet = (UserTask) this.currentFlowElemet;
            SequenceFlow sequenceFlow;
            List<SequenceFlow> outgoingFlows = new ArrayList<>();

            if(CollectionUtil.isNotEmpty(userTaskDTO.getSequenceFlowList())){
                process.removeFlowElement(currentFlowElemet.getId());
                for (SequenceFlow sequenceFlow1 : currentFlowElemet.getOutgoingFlows()) {
                    //删除原先节点的出线
                    process.removeFlowElement(sequenceFlow1.getId());
                }
                //增加新的线段
                for (SequenceFlowDTO sequenceFlowNew :userTaskDTO.getSequenceFlowList()){
                    sequenceFlow = new SequenceFlow(currentFlowElemet.getId(),sequenceFlowNew.getTargetRef());
                    sequenceFlow.setSkipExpression(sequenceFlowNew.getSkipExpression());
                    sequenceFlow.setConditionExpression(sequenceFlowNew.getConditionExpression());
                    sequenceFlow.setName(sequenceFlowNew.getName());
                    sequenceFlow.setId("seq_"+ UUID.randomUUID().toString().replaceAll("-","" ));
                    outgoingFlows.add(sequenceFlow);
                    process.addFlowElement(sequenceFlow);
                }

            }
            currentFlowElemet.setOutgoingFlows(outgoingFlows);
            process.addFlowElement(currentFlowElemet);
            GraphicInfo elementGraphicInfo = bpmnModel.getGraphicInfo(currentFlowElemet.getId());
            if (elementGraphicInfo != null) {
                new BpmnAutoLayout(bpmnModel).execute();
            }
        }

        BaseDynamicSubProcessInjectUtil.processFlowElements(commandContext, process, bpmnModel, originalProcessDefinitionEntity, newDeploymentEntity);
    }
    
    @Override
    protected void updateExecutions(CommandContext commandContext, ProcessDefinitionEntity processDefinitionEntity,
                                    ExecutionEntity processInstance, List<ExecutionEntity> childExecutions) {
        BpmnModel bpmnModel = ProcessDefinitionUtil.getBpmnModel(processDefinitionEntity.getId());
        try {
            BpmnXMLConverter bpmnXMLConverter = new BpmnXMLConverter();
            byte[] bpmnBytes = bpmnXMLConverter.convertToXML(bpmnModel);
            String bpmnXml = new String(bpmnBytes, StandardCharsets.UTF_8);
            // 打印XML
            System.out.println(bpmnXml);
        }catch (Exception e){
            log.error(e.getMessage());
        }
    }

8.调用方法

@Component
@RequiredArgsConstructor
@Slf4j
public class UpdateBpmnUtil {

    private final ProcessEngine processEngine;

    public void updateBpmn(UserTaskDTO userTaskDTO) {
        if(userTaskDTO.getType().equals(1)){
            if (StrUtil.isBlank(userTaskDTO.getId())){
                throw new CustomException("9999", "移动节点NodeID不存在！");
            }
        }

        if (CollectionUtil.isNotEmpty(userTaskDTO.getExecutionListenerList())) {
            userTaskDTO.getExecutionListenerList().forEach(execution -> {
                if (!execution.getEvent().equals("start") && !execution.getEvent().equals("end") && !execution.getEvent().equals("task")) {
                    throw new CustomException("9999", "执行监听器不存在此类型！");
                }
                if (classIsExist(execution.getImplementation())) {
                    throw new CustomException("9999", "此类：" + execution.getImplementation() + "不存在");
                }
            });
        }

        if (CollectionUtil.isNotEmpty(userTaskDTO.getTaskListenerList())) {
            userTaskDTO.getTaskListenerList().forEach(task -> {
                if (!task.getEvent().equals("create") && !task.getEvent().equals("assignment") && !task.getEvent().equals("complete") && !task.getEvent().equals("delete")) {
                    throw new CustomException("9999", "任务监听器不存在");
                }
                if (classIsExist(task.getImplementation())) {
                    throw new CustomException("9999", "此类：" + task.getImplementation() + "不存在");
                }
            });
        }

        if (CollectionUtil.isNotEmpty(userTaskDTO.getSequenceFlowList())) {
            Set<String> sequenceKey=new HashSet<>();
            userTaskDTO.getSequenceFlowList().forEach(sequence -> {
               if(!sequenceKey.contains(sequence.getConditionExpression())){
                   sequenceKey.add(sequence.getConditionExpression());
               }else{
                   throw new CustomException("9999", "此：" +sequence.getConditionExpression()  + "表达式重复！");
               }
            });
        }

        DynamicUserTaskBuilder dynamicUserTaskBuilder = new DynamicUserTaskBuilder();
        if (StrUtil.isBlank(userTaskDTO.getId())) {
            userTaskDTO.setId("sid-" + UUID.randomUUID());
        } else {
            userTaskDTO.setId("sid-" + userTaskDTO.getId());
        }
        List<Task> list = processEngine.getTaskService().createTaskQuery().active().taskId(userTaskDTO.getTaskId()).list();
        if (CollectionUtil.isEmpty(list)) {
            list = processEngine.getTaskService().createTaskQuery().active().processInstanceId(userTaskDTO.getProcessInstanceId()).list();
        }
        if (CollectionUtil.isNotEmpty(list)) {
            Task task = list.get(0);
            BpmnModel bpmnModel = processEngine.getRepositoryService().getBpmnModel(task.getProcessDefinitionId());
            dynamicUserTaskBuilder.setId(userTaskDTO.getId());
            dynamicUserTaskBuilder.setAssignee(userTaskDTO.getAssignee());
            dynamicUserTaskBuilder.setName(userTaskDTO.getName());

            Process process = bpmnModel.getProcesses().get(0);
            try {
                processEngine.getManagementService().executeCommand(new CustomInjectUserTaskInProcessInstanceCmd(userTaskDTO, dynamicUserTaskBuilder, process.getFlowElement(task.getTaskDefinitionKey())));
            } catch (Exception e) {
                throw new CustomException("999999", e.getMessage());
            }
        }
    }

    /**
     * 检验类是否存在
     *
     * @param className className路径
     * @return boolean
     */
    public boolean classIsExist(String className) {
        try {
            String path = ResourceUtils.getURL("classpath:").getPath();
            File file = new File(path + className.replace(".", "/") + ".class");
            return !file.exists();
        } catch (Exception e) {
            // 类不存在
            return true;
        }
    }

    /**
     * 移动某个节点（自由跳转，当前节点自动完成）
     *
     * @param moveNodeDTO moveNodeDTO
     */
    public void moveNode(MoveNodeDTO moveNodeDTO) {
        processEngine.getRuntimeService().createChangeActivityStateBuilder()
                .processInstanceId(moveNodeDTO.getProcessInstanceId())
                .moveActivityIdTo(moveNodeDTO.getNodeId(), moveNodeDTO.getToNodeId())
                .changeState();
    }

    /**
     * 查看流程引擎xml文件
     *
     * @param bpmnGetMyTaskDTO bpmnGetMyTaskDTO
     */
    public String lookXmlForFlowable(BpmnGetMyTaskDTO bpmnGetMyTaskDTO) {
        String bpmnXml = "";
        List<HistoricTaskInstance> list = processEngine.getHistoryService().createHistoricTaskInstanceQuery().processInstanceId(bpmnGetMyTaskDTO.getProcessInstanceId()).list();
        if (CollectionUtil.isNotEmpty(list)) {
            BpmnModel bpmnModel =  processEngine.getRepositoryService().getBpmnModel(list.get(0).getProcessDefinitionId());
            BpmnXMLConverter bpmnXMLConverter = new BpmnXMLConverter();
            byte[] bpmnBytes = bpmnXMLConverter.convertToXML(bpmnModel);
            bpmnXml = new String(bpmnBytes, StandardCharsets.UTF_8);
            System.out.println(bpmnXml);
        }

        return bpmnXml;
    }

9.入参JSON

  1. 新增节点 (所有的操作仅在流程流转到当前节点。配置下一节点有效)
{
	"type":0,
	"processInstanceId": "??????",
	"taskId": "??????",
	"id": "??????",
	"formKey": "",
	"name": "新增节点40",
	"assignee": "${user}",
	"multiInstanceLoopCharacteristicsDTO": {
		"completionCondition": "??????",
		"sequential": false,
		"inputDataItem": "${UserList}",
		"elementVariable": "user"
	},
	"taskListenerList": [
		{
			"event": "create",
			"implementationType": "class",
			"implementation": "*.listener.TestTaskListener"
		},
		{
			"event": "complete",
			"implementationType": "class",
			"implementation": "*.listener.TestTaskListener"
		}
	],
	"executionListenerList": [
		{
			"event": "start",
			"implementationType": "class",
			"implementation": "*.listener.TestListener"
		},
		{
			"event": "end",
			"implementationType": "class",
			"implementation": "*.listener.TestListener"
		}
	]
	,
	"sequenceFlowList": [
		 {
		 	"name": "3333",
		 	"documentation": "55555555",
			"conditionExpression": "${ok == 0}",
		 	"sourceRef": "",
		 	"targetRef": "??????",
		 	"skipExpression": ""
		 }
		, {
			"name": "44444",
		 	"documentation": "66666",
		 	"conditionExpression": "${ok == 1}",
		 	"sourceRef": "",
		 	"targetRef": "??????",
		 	"skipExpression": ""
		 },
		 {
		 	"name": "77777",
		 	"documentation": "88888",
		 	"conditionExpression": "${ok == 2}",
		 	"sourceRef": "",
		 	"targetRef": "??????",
		 	"skipExpression": ""
		 }
	]
}
  1. 查看流程引擎xml文件
{
	"processInstanceId": "??????"
}
  1. 修改流程节点路径 (所有的操作仅在流程流转到当前节点。配置下一节点有效)
{
	"type": 1,
	"processInstanceId": "??????",
	"taskId": "??????",
	"id":"??????",
	"sequenceFlowList": [
		{
			"name": "3333",
			"documentation": "55555555",
			"conditionExpression": "${ok == 1}",
			"targetRef": "??????",
			"skipExpression": ""
		}
		, {
			"name": "44444",
			"documentation": "66666",
			"conditionExpression": "${ok == 0}",
			"sourceRef": "",
			"targetRef": "??????",
			"skipExpression": ""
		}
	]
}
爱写代码的搬运工
关注
  • 15
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
flowable工作流看这一篇就够了（高级篇 上）
qq_38196449的博客
12-16 1731
TestBPMN 2.0是业务流程建模符号2.0的缩写。它由Business Process Management Initiative这个非营利协会创建并不断发展。作为一种标识，BPMN 2.0是使用一些符号来明确业务流程设计流程图的一整套符号规范，它能增进业务建模时的沟通效率。目前BPMN2.0是最新的版本，它用于在BPM上下文中进行布局和可视化的沟通。接下来我们先来了解在流程设计中常见的符号。BPMN2.0的基本符合。
流程定义更新版本(插入节点、删除节点、修改节点、删除节点恢复)
05-15
在上一个版本的基础上做了优化： 1、可以在选中的节点前或者节点后插入新节点；上一个版本是只能在最后插入新节点； 2、对插入节点的图标增加了气泡提示。
flwoable如何实现后加签（动态添加节点）
nixzmdi1的专栏
05-28 9202
flowable的功能基本都是基于命令模式实现的，flowalble提供了一个方法，可以调用我们自己编写的命令。 ManagementService managementService;这个service里有个executeCommand方法 入参为Command，今天就是基于这个方法来实现后加签的。有兴趣的同学还可以看下这个service的其它方法。 AbstractDynamicInjectionCmd 由flowable提供的基础命令，修改流程的基类。 下面是实现后加签的命令源码 自定义后加签c
Flowable动态修改在途流程
u014596024的博客
01-21 3821
背景 之前在生产上部署了一个节点加多文件大小较大的流程图，在用eclipse改图的时候图是正常的，然后部署上去的时候发现有两条线进和出的节点错乱了，导致流程走乱； 例子： 原先正确的流程图： 部署上去之后有问题的流程图： 有问题的流程图出现的情况： 如果是走userTask3的情况，在userTask2执行完之后，会生产一个userTask3和一个userTask5的任务数据； 因为flowbale每部署一次流程，流程的版本就加一，不同版本互相不影响，问题就来，我已经在途的流程怎么修改呢，我应该如何才能
Flowable 修改运行中的流程参数
zhuiguhenman的博客
12-08 1155
Flowable 修改运行中的流程参数 在ACT_RE_DEPLOYMENT中根据key查询部署信息 再根据 ACT_RE_DEPLOYMENT的“DEPLOYMENT_ID_”在ACT_GE_BYTEARRAY中查找出对应的模板信息。 更新BYTES_属性，重启系统就ok了。 详细的表的信息可以看这个：https://www.cnblogs.com/Fooo/p/12668368.html ...
flowable修改流程添加节点并修改样式
qq_40602449的博客
12-10 3913
在网上查了许久,并没有找到答案,只好自己一点点尝试 想着 flowable 应该会有自动生成 流程图片 的 方法, 在网上寻找许久,无奈没有找见, 只好自己动手了 下边就是 本人亲身经历 并辛辛苦苦写的代码 1.给流程添加节点代码: Process process = bpmnModel.getMainProcess(); //添加提交人节点 方便驳回 UserTask applytask = new UserTask(); applytask.setId("applytask"); apply
flowable的动态增加流程节点
Alon的博客
04-30 1936
今天项目中有一个需求，在一个流程中的某个节点是不确定度，人员审核也是不确定的，一开始考虑使用会签节点，但是有一点无法满足就是该节点已经人员都是不固定了，当任务进行到该节点时，还能进行人员分配.后面就考虑将这个节点任务从流程上分离开，意思是当流程到了该节点时，不触发流程，通过业务代码来实现动态的分配人员和任务。但是这么做也有一个弊端，就是流程不能通用，只能用于当前。
flowable工作流添加节点执行人四种方式
tao441033618的博客
03-20 4450
flowable工作流
基于若依ruoyi-nbcio支持flowable流程角色，同时修改流转用户为username，流程启动做大调整（一）
宁波阿成的博客
09-27 471
基于若依ruoyi-nbcio支持flowable流程角色，同时修改流转用户为username，流程启动做大调整（一）
工作流程flowable（二）发起流程、跟踪
nalanxiaoxiao2011的博客
12-12 1377
flowable 流程节点
flowable高亮流程已执行节点及连线.txt
06-17
flowable高亮流程已执行节点及连线，包含6.4.1版本以及6.4.1之前版本的不同处理方法
vue使用flowable绘制流程图.docx
12-11
Flowable 是一个开源的工作流和业务自动化引擎，支持BPMN（Business Process Model and Notation）标准。在Vue项目中使用Flowable来绘制流程图，可以借助`workflow-bpmn-modeler`这个库，它基于Vue和bpmn.io，为...
flowable-7.0.0.M
08-10
Flowable是一款先进的业务流程管理（BPM）和工作流引擎，专为现代应用程序设计。Flowable 7.0.0.M版本是该引擎的一个里程碑，它包含了一系列的更新、改进和新特性，以提升性能、稳定性和用户体验。下面将详细讨论...
基于RuoYi-VUE版本开发开源OA协同办公系统源码 集成Flowable流程引擎 可自由选择提交的流程.zip
11-27
在实际应用中，Flowable的流程引擎使得系统能够根据企业的具体需求，自由定义和调整工作流程。例如，用户可以根据任务性质选择不同的审批流程，使得流程更加灵活，满足不同部门和岗位的需求。 在源码层面，开发者...
flowable工作流定制化修改
最新发布
youxiaxiaomage的博客
05-30 585
自定义用户任务拦截器@Slf4j@Override@Override源码中...@Override......= null) {......= null) {......// 这边去定制化各种验证校验器简单检查流程是否存在开始、结束节点@OverrideaddError(errors, "流程必须存在开始或结束节点", mainProcess, "流程必须存在开始或结束节点");
flowable 流程退回 驳回 任意跳转 任务复活 历史节点脏数据删除
qq_31237581的博客
01-11 2590
flowable流程任务退回（驳回）(任务跳转) 流程任务复活（重新触发）任务节点 Cmd调用 上面的方法大多和代码相似，还可以继续简化。 上面的Cmd中，有个, 这里主要是通过业务key来定位的, 也可以直接传参 进来，这样更简单。直接调用 方式时会报错：The task cannot be deleted because is part of a running process通过ExecutionEntityManager.deleteExecutionAndRelatedData实现删除则没可以。
Flowable简单介绍
心流时间的博客
08-15 316
flowable、替代activiti、工作流
flowable框架与流程操作
zzzzzheike的博客
04-27 615
已存放至庄金明项目文件夹。参考源码为庄金明项目。
flowable 根据流程实例id 查询当前多实例节点的完成数
06-01
可以使用Flowable的API来查询当前多实例节点的完成数，具体步骤如下： 1. 首先根据流程实例id获取当前的流程实例对象： ``` ProcessInstance processInstance = runtimeService.createProcessInstanceQuery() .processInstanceId(processInstanceId) .singleResult(); ``` 2. 然后根据流程实例对象获取当前正在执行的任务： ``` List<Task> tasks = taskService.createTaskQuery() .processInstanceId(processInstance.getId()) .list(); ``` 3. 遍历任务列表，获取每个任务节点的多实例信息： ``` for (Task task : tasks) { MultiInstanceLoopCharacteristics multiInstance = (MultiInstanceLoopCharacteristics) ((ExecutionEntity) runtimeService.createExecutionQuery() .executionId(task.getExecutionId()) .singleResult()).getActivity().getProperty("multiInstanceLoopCharacteristics"); if (multiInstance != null) { int completedInstances = multiInstance.getCompletedCount(); int nrOfInstances = multiInstance.getLoopCardinality(); // completedInstances 即为当前多实例节点的完成数 // nrOfInstances 即为多实例节点的总数 } } ``` 通过以上步骤，即可查询到当前多实例节点的完成数。注意，如果当前节点不是多实例节点，则会返回null。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值