Flowable源码注释（二十五）BPMN部署器（下）

最新推荐文章于 2023-04-06 15:21:10 发布
翻译 最新推荐文章于 2023-04-06 15:21:10 发布 · 373 阅读 · 2 ·
CC 4.0 BY-SA版权
原文链接：https://github.com/flowable/flowable-engine
文章标签：

#flowable #源码注释

本文详细解析了Flowable中的BpmnDeployer类，主要关注流程定义的版本管理和事件调度。通过getPreviousDerivedFromVersionsOfProcessDefinitions方法获取新旧流程定义的映射，setProcessDefinitionVersionsAndIds方法设置版本和标识，以及事件调度。此外，还涉及到持久化、定时器和事件更新，以及流程定义的初始化事件。这些操作确保了流程定义在不同版本间的正确管理和流程实例的有序执行。

Flowable源码地址：https://github.com/flowable/flowable-engine

Flowable-6.7.2 源码注释地址：https://github.com/solojin/flowable-6.7.2-annotated

BpmnDeployer BPMN部署器（下）

public class BpmnDeployer implements EngineDeployer {
    
    ...
        
	/**
     * 构造一个映射从新的流程定义实体到根据主键和租户从版本派生的上一个流程定义实体。
     * 如果不存在以前的版本，则不会创建映射条目。
     */
    protected Map<ProcessDefinitionEntity, ProcessDefinitionEntity> getPreviousDerivedFromVersionsOfProcessDefinitions(
            ParsedDeployment parsedDeployment) {

        Map<ProcessDefinitionEntity, ProcessDefinitionEntity> result = new LinkedHashMap<>();

        for (ProcessDefinitionEntity newDefinition : parsedDeployment.getAllProcessDefinitions()) {
            ProcessDefinitionEntity existingDefinition = bpmnDeploymentHelper.getMostRecentDerivedVersionOfProcessDefinition(newDefinition);

            if (existingDefinition != null) {
                result.put(newDefinition, existingDefinition);
            }
        }

        return result;
    }

    /**
     * 设置每个流程定义实体的版本和标识符。
     * 如果映射包含流程定义的旧版本，则该版本将设置为该旧实体的版本加一；否则设置为1.
     * 还调度实体创建 ENTITY_CREATED 事件。
     */
    protected void setProcessDefinitionVersionsAndIds(ParsedDeployment parsedDeployment,
            Map<ProcessDefinitionEntity, ProcessDefinitionEntity> mapNewToOldProcessDefinitions) {
        
        CommandContext commandContext = Context.getCommandContext();

        for (ProcessDefinitionEntity processDefinition : parsedDeployment.getAllProcessDefinitions()) {
            int version = 1;

            ProcessDefinitionEntity latest = mapNewToOldProcessDefinitions.get(processDefinition);
            if (latest != null) {
                version = latest.getVersion() + 1;
            }

            processDefinition.setVersion(version);
            processDefinition.setId(getIdForNewProcessDefinition(processDefinition));
            Process process = parsedDeployment.getProcessModelForProcessDefinition(processDefinition);
            FlowElement initialElement = process.getInitialFlowElement();
            if (initialElement instanceof StartEvent) {
                StartEvent startEvent = (StartEvent) initialElement;
                if (startEvent.getFormKey() != null) {
                    processDefinition.setHasStartFormKey(true);
                }
            }

            cachingAndArtifactsManager.updateProcessDefinitionCache(parsedDeployment);

            ProcessEngineConfigurationImpl processEngineConfiguration = CommandContextUtil.getProcessEngineConfiguration(commandContext);
            FlowableEventDispatcher eventDispatcher = processEngineConfiguration.getEventDispatcher();
            if (eventDispatcher != null && eventDispatcher.isEnabled()) {
                eventDispatcher.dispatchEvent(FlowableEventBuilder.createEntityEvent(FlowableEngineEventType.ENTITY_CREATED, processDefinition),
                        processEngineConfiguration.getEngineCfgKey());
            }
        }
    }
    
    protected void setDerivedProcessDefinitionVersionsAndIds(ParsedDeployment parsedDeployment, 
            Map<ProcessDefinitionEntity, ProcessDefinitionEntity> mapNewToOldProcessDefinitions, Map<String, Object> deploymentSettings) {
        
        CommandContext commandContext = Context.getCommandContext();
        
        for (ProcessDefinitionEntity processDefinition : parsedDeployment.getAllProcessDefinitions()) {
            int derivedVersion = 1;
            
            ProcessDefinitionEntity latest = mapNewToOldProcessDefinitions.get(processDefinition);
            if (latest != null) {
                derivedVersion = latest.getDerivedVersion() + 1;
            }
            
            processDefinition.setVersion(0);
            processDefinition.setDerivedVersion(derivedVersion);
            if (usePrefixId) {
                processDefinition.setId(processDefinition.getIdPrefix() + idGenerator.getNextId());
            } else {
                processDefinition.setId(idGenerator.getNextId());
            }
            
            processDefinition.setDerivedFrom((String) deploymentSettings.get(DeploymentSettings.DERIVED_PROCESS_DEFINITION_ID));
            processDefinition.setDerivedFromRoot((String) deploymentSettings.get(DeploymentSettings.DERIVED_PROCESS_DEFINITION_ROOT_ID));

            Process process = parsedDeployment.getProcessModelForProcessDefinition(processDefinition);
            FlowElement initialElement = process.getInitialFlowElement();
            if (initialElement instanceof StartEvent) {
                StartEvent startEvent = (StartEvent) initialElement;
                if (startEvent.getFormKey() != null) {
                    processDefinition.setHasStartFormKey(true);
                }
            }
            
            cachingAndArtifactsManager.updateProcessDefinitionCache(parsedDeployment);

            ProcessEngineConfigurationImpl processEngineConfiguration = CommandContextUtil.getProcessEngineConfiguration(commandContext);
            FlowableEventDispatcher eventDispatcher = processEngineConfiguration.getEventDispatcher();
            if (eventDispatcher != null && eventDispatcher.isEnabled()) {
                eventDispatcher.dispatchEvent(FlowableEventBuilder.createEntityEvent(FlowableEngineEventType.ENTITY_CREATED, processDefinition),
                        processEngineConfiguration.getEngineCfgKey());
            }
        }
    }

    /**
     * 保存每个进程定义。假设部署是新的，之前从未保存过定义，并且它们的所有值都已正确设置.
     */
    protected void persistProcessDefinitionsAndAuthorizations(ParsedDeployment parsedDeployment) {
        CommandContext commandContext = Context.getCommandContext();
        ProcessEngineConfigurationImpl processEngineConfiguration = CommandContextUtil.getProcessEngineConfiguration(commandContext);
        ProcessDefinitionEntityManager processDefinitionManager = processEngineConfiguration.getProcessDefinitionEntityManager();

        for (ProcessDefinitionEntity processDefinition : parsedDeployment.getAllProcessDefinitions()) {
            processDefinitionManager.insert(processDefinition, false);
            bpmnDeploymentHelper.addAuthorizationsForNewProcessDefinition(parsedDeployment.getProcessModelForProcessDefinition(processDefinition), processDefinition);
        }
    }

    protected void updateTimersAndEvents(ParsedDeployment parsedDeployment,
            Map<ProcessDefinitionEntity, ProcessDefinitionEntity> mapNewToOldProcessDefinitions) {

        for (ProcessDefinitionEntity processDefinition : parsedDeployment.getAllProcessDefinitions()) {
            bpmnDeploymentHelper.updateTimersAndEvents(processDefinition,
                    mapNewToOldProcessDefinitions.get(processDefinition),
                    parsedDeployment);
        }
    }

    protected void dispatchProcessDefinitionEntityInitializedEvent(ParsedDeployment parsedDeployment) {
        CommandContext commandContext = Context.getCommandContext();
        ProcessEngineConfigurationImpl processEngineConfiguration = CommandContextUtil.getProcessEngineConfiguration(commandContext);
        for (ProcessDefinitionEntity processDefinitionEntity : parsedDeployment.getAllProcessDefinitions()) {
            FlowableEventDispatcher eventDispatcher = processEngineConfiguration.getEventDispatcher();
            if (eventDispatcher != null && eventDispatcher.isEnabled()) {
                eventDispatcher.dispatchEvent(FlowableEventBuilder.createEntityEvent(FlowableEngineEventType.ENTITY_INITIALIZED, processDefinitionEntity),
                        processEngineConfiguration.getEngineCfgKey());
            }
        }
    }

    /**
     * 返回用于新进程定义的ID;
     * 子类可以覆盖此项以提供自己的标识方案。
     * 整个引擎中的流程定义ID必须是唯一的！
     */
    protected String getIdForNewProcessDefinition(ProcessDefinitionEntity processDefinition) {
        String prefixId = "";
        if (usePrefixId) {
            prefixId = processDefinition.getIdPrefix();
        } 
        
        String nextId = idGenerator.getNextId();

        String result = prefixId + processDefinition.getKey() + ":" + processDefinition.getVersion() + ":" + nextId; // ACT-505
        // ACT-115: id的最大长度为64个字符
        if (result.length() > 64) {
            // 由于长度超出了长进程定义键
            result = prefixId + nextId;
        }

        return result;
    }

    /**
     * 加载每个进程定义的持久化版本，并将内存版本上的值设置为一致。
     */
    protected void makeProcessDefinitionsConsistentWithPersistedVersions(ParsedDeployment parsedDeployment) {
        for (ProcessDefinitionEntity processDefinition : parsedDeployment.getAllProcessDefinitions()) {
            ProcessDefinitionEntity persistedProcessDefinition = bpmnDeploymentHelper.getPersistedInstanceOfProcessDefinition(processDefinition);

            if (persistedProcessDefinition != null) {
                processDefinition.setId(persistedProcessDefinition.getId());
                processDefinition.setVersion(persistedProcessDefinition.getVersion());
                processDefinition.setSuspensionState(persistedProcessDefinition.getSuspensionState());
                processDefinition.setHasStartFormKey(persistedProcessDefinition.hasStartFormKey());
                processDefinition.setGraphicalNotationDefined(persistedProcessDefinition.isGraphicalNotationDefined());
            }
        }
    }

    protected void createLocalizationValues(String processDefinitionId, Process process) {
        if (process == null) {
            return;
        }

        CommandContext commandContext = Context.getCommandContext();
        DynamicBpmnService dynamicBpmnService = CommandContextUtil.getProcessEngineConfiguration(commandContext).getDynamicBpmnService();
        ObjectNode infoNode = dynamicBpmnService.getProcessDefinitionInfo(processDefinitionId);

        boolean localizationValuesChanged = false;
        List<ExtensionElement> localizationElements = process.getExtensionElements().get("localization");
        if (localizationElements != null) {
            for (ExtensionElement localizationElement : localizationElements) {
                if (BpmnXMLConstants.FLOWABLE_EXTENSIONS_PREFIX.equals(localizationElement.getNamespacePrefix()) ||
                        BpmnXMLConstants.ACTIVITI_EXTENSIONS_PREFIX.equals(localizationElement.getNamespacePrefix())) {

                    String locale = localizationElement.getAttributeValue(null, "locale");
                    String name = localizationElement.getAttributeValue(null, "name");
                    String documentation = null;
                    List<ExtensionElement> documentationElements = localizationElement.getChildElements().get("documentation");
                    if (documentationElements != null) {
                        for (ExtensionElement documentationElement : documentationElements) {
                            documentation = StringUtils.trimToNull(documentationElement.getElementText());
                            break;
                        }
                    }

                    String processId = process.getId();
                    if (!isEqualToCurrentLocalizationValue(locale, processId, "name", name, infoNode)) {
                        dynamicBpmnService.changeLocalizationName(locale, processId, name, infoNode);
                        localizationValuesChanged = true;
                    }

                    if (documentation != null && !isEqualToCurrentLocalizationValue(locale, processId, "description", documentation, infoNode)) {
                        dynamicBpmnService.changeLocalizationDescription(locale, processId, documentation, infoNode);
                        localizationValuesChanged = true;
                    }
                }
            }
        }

        boolean isFlowElementLocalizationChanged = localizeFlowElements(process.getFlowElements(), infoNode);
        boolean isDataObjectLocalizationChanged = localizeDataObjectElements(process.getDataObjects(), infoNode);
        if (isFlowElementLocalizationChanged || isDataObjectLocalizationChanged) {
            localizationValuesChanged = true;
        }

        if (localizationValuesChanged) {
            dynamicBpmnService.saveProcessDefinitionInfo(processDefinitionId, infoNode);
        }
    }

    protected boolean localizeFlowElements(Collection<FlowElement> flowElements, ObjectNode infoNode) {
        boolean localizationValuesChanged = false;

        if (flowElements == null) {
            return localizationValuesChanged;
        }

        CommandContext commandContext = Context.getCommandContext();
        DynamicBpmnService dynamicBpmnService = CommandContextUtil.getProcessEngineConfiguration(commandContext).getDynamicBpmnService();

        for (FlowElement flowElement : flowElements) {
            if (flowElement instanceof UserTask || flowElement instanceof SubProcess) {
                List<ExtensionElement> localizationElements = flowElement.getExtensionElements().get("localization");
                if (localizationElements != null) {
                    for (ExtensionElement localizationElement : localizationElements) {
                        if (BpmnXMLConstants.FLOWABLE_EXTENSIONS_PREFIX.equals(localizationElement.getNamespacePrefix()) ||
                                BpmnXMLConstants.ACTIVITI_EXTENSIONS_PREFIX.equals(localizationElement.getNamespacePrefix())) {

                            String locale = localizationElement.getAttributeValue(null, "locale");
                            String name = localizationElement.getAttributeValue(null, "name");
                            String documentation = null;
                            List<ExtensionElement> documentationElements = localizationElement.getChildElements().get("documentation");
                            if (documentationElements != null) {
                                for (ExtensionElement documentationElement : documentationElements) {
                                    documentation = StringUtils.trimToNull(documentationElement.getElementText());
                                    break;
                                }
                            }

                            String flowElementId = flowElement.getId();
                            if (!isEqualToCurrentLocalizationValue(locale, flowElementId, "name", name, infoNode)) {
                                dynamicBpmnService.changeLocalizationName(locale, flowElementId, name, infoNode);
                                localizationValuesChanged = true;
                            }

                            if (documentation != null && !isEqualToCurrentLocalizationValue(locale, flowElementId, "description", documentation, infoNode)) {
                                dynamicBpmnService.changeLocalizationDescription(locale, flowElementId, documentation, infoNode);
                                localizationValuesChanged = true;
                            }
                        }
                    }
                }

                if (flowElement instanceof SubProcess) {
                    SubProcess subprocess = (SubProcess) flowElement;
                    boolean isFlowElementLocalizationChanged = localizeFlowElements(subprocess.getFlowElements(), infoNode);
                    boolean isDataObjectLocalizationChanged = localizeDataObjectElements(subprocess.getDataObjects(), infoNode);
                    if (isFlowElementLocalizationChanged || isDataObjectLocalizationChanged) {
                        localizationValuesChanged = true;
                    }
                }
            }
        }

        return localizationValuesChanged;
    }

    protected boolean isEqualToCurrentLocalizationValue(String language, String id, String propertyName, String propertyValue, ObjectNode infoNode) {
        boolean isEqual = false;
        JsonNode localizationNode = infoNode.path("localization").path(language).path(id).path(propertyName);
        if (!localizationNode.isMissingNode() && !localizationNode.isNull() && localizationNode.asText().equals(propertyValue)) {
            isEqual = true;
        }
        return isEqual;
    }

    protected boolean localizeDataObjectElements(List<ValuedDataObject> dataObjects, ObjectNode infoNode) {
        boolean localizationValuesChanged = false;
        CommandContext commandContext = Context.getCommandContext();
        DynamicBpmnService dynamicBpmnService = CommandContextUtil.getProcessEngineConfiguration(commandContext).getDynamicBpmnService();

        for (ValuedDataObject dataObject : dataObjects) {
            List<ExtensionElement> localizationElements = dataObject.getExtensionElements().get("localization");
            if (localizationElements != null) {
                for (ExtensionElement localizationElement : localizationElements) {
                    if (BpmnXMLConstants.FLOWABLE_EXTENSIONS_PREFIX.equals(localizationElement.getNamespacePrefix()) ||
                            BpmnXMLConstants.ACTIVITI_EXTENSIONS_PREFIX.equals(localizationElement.getNamespacePrefix())) {

                        String locale = localizationElement.getAttributeValue(null, "locale");
                        String name = localizationElement.getAttributeValue(null, "name");
                        String documentation = null;

                        List<ExtensionElement> documentationElements = localizationElement.getChildElements().get("documentation");
                        if (documentationElements != null) {
                            for (ExtensionElement documentationElement : documentationElements) {
                                documentation = StringUtils.trimToNull(documentationElement.getElementText());
                                break;
                            }
                        }

                        if (name != null && !isEqualToCurrentLocalizationValue(locale, dataObject.getId(), DynamicBpmnConstants.LOCALIZATION_NAME, name, infoNode)) {
                            dynamicBpmnService.changeLocalizationName(locale, dataObject.getId(), name, infoNode);
                            localizationValuesChanged = true;
                        }

                        if (documentation != null && !isEqualToCurrentLocalizationValue(locale, dataObject.getId(),
                                DynamicBpmnConstants.LOCALIZATION_DESCRIPTION, documentation, infoNode)) {

                            dynamicBpmnService.changeLocalizationDescription(locale, dataObject.getId(), documentation, infoNode);
                            localizationValuesChanged = true;
                        }
                    }
                }
            }
        }

        return localizationValuesChanged;
    }

    public IdGenerator getIdGenerator() {
        return idGenerator;
    }

    public void setIdGenerator(IdGenerator idGenerator) {
        this.idGenerator = idGenerator;
    }

    public ParsedDeploymentBuilderFactory getExParsedDeploymentBuilderFactory() {
        return parsedDeploymentBuilderFactory;
    }

    public void setParsedDeploymentBuilderFactory(ParsedDeploymentBuilderFactory parsedDeploymentBuilderFactory) {
        this.parsedDeploymentBuilderFactory = parsedDeploymentBuilderFactory;
    }

    public BpmnDeploymentHelper getBpmnDeploymentHelper() {
        return bpmnDeploymentHelper;
    }

    public void setBpmnDeploymentHelper(BpmnDeploymentHelper bpmnDeploymentHelper) {
        this.bpmnDeploymentHelper = bpmnDeploymentHelper;
    }

    public CachingAndArtifactsManager getCachingAndArtifcatsManager() {
        return cachingAndArtifactsManager;
    }

    public void setCachingAndArtifactsManager(CachingAndArtifactsManager manager) {
        this.cachingAndArtifactsManager = manager;
    }

    public ProcessDefinitionDiagramHelper getProcessDefinitionDiagramHelper() {
        return processDefinitionDiagramHelper;
    }

    public void setProcessDefinitionDiagramHelper(ProcessDefinitionDiagramHelper processDefinitionDiagramHelper) {
        this.processDefinitionDiagramHelper = processDefinitionDiagramHelper;
    }

    public boolean isUsePrefixId() {
        return usePrefixId;
    }

    public void setUsePrefixId(boolean usePrefixId) {
        this.usePrefixId = usePrefixId;
    }
}
Flowable源码解析之流程模型解析
Sombie Fate的专栏
08-25 921
将 bpmn20.xml 文件转换为相应的 BpmnModel 对象是一个复杂的过程，本篇文章将分析并解析该过程。
SpringBoot整合Flowable最新教程（一）Flowable介绍
最新发布
陆漫漫的博客
02-04 4396
官网地址：https://www.flowable.org/中文教程地址可以在官网下载对应的jar包在本地部署运行，官方提供了下面的五个应用程序：Flowable Modeler：流程定义管理Flowable Task：用户任务管理Flowable IDM：用户组权限管理Flowable REST API：流程引擎对外提供的API接口Flowable Admin：后台管理。
activiti源码解析系列6 - bpmn部署器BpmnDeployer源码解析
牛分享的专栏
04-16 1501
流程的部署主要通过DeployCmd类进行： 查看部分核心代码： public Deployment execute(CommandContext commandContext) { // Backwards compatibility with Activiti v5 //activiti5兼容开启 if (commandContext.getProcessEngineConfiguration().isActiviti5CompatibilityEnabled()
Flowable 6.6.0 BPMN用户指南 - 17 高级用例 - 17.6 采用ProcessEngineConfigurator 进行高级的流程引擎配置
月满闲庭的博客
01-05 646
17.6 采用ProcessEngineConfigurator 进行高级的流程引擎配置（Advanced Process Engine configuration with a ProcessEngineConfigurator） An advanced way of hooking into the process engine configuration is through the use of a ProcessEngineConfigurator. The idea is that an imp
flowable实现办结取回功能
翻越山峰
09-08 2186
package com.wisedu.flow.service; import com.google.common.collect.Lists; import com.wisedu.common.utils.SpringContextUtils; import com.wisedu.common.utils.StringUtils; import com.wisedu.flow.api.FlowService; import com.wisedu.flow.config.EnumProcessDefin.
flowable部署和启动源码解析
MieMieFly的专栏
06-14 3385
flowable的部署有好几种.现在举例常用的方式: Deployment deployment = repositoryService.createDeployment().name(bpmName).addInputStream(fileName, fileInputStream).deploy(); 这里分两步先创建Deployment.然后再deploy.createDeployment()源码如下: @Override public DeploymentBuilder createDep
Flowable源码注释（二十四）引擎部署器和BPMN部署器（上）
jinyangjie的博客
02-07 354
Flowable源码地址：https://github.com/flowable/flowable-engine Flowable-6.7.2 源码注释地址：https://github.com/solojin/flowable-6.7.2-annotated 包路径 org.flowable.common.engine.impl EngineDeployer 引擎部署器 /** * 引擎部署器，实现类有BPMN部署器BpmnDeployer，DMN部署器DmnDeployer，CMMN部署器CmmnDe
Flowable源码注释（六十六）边界注册、取消、条件、变量事件活动行为类
jinyangjie的博客
03-18 841
Flowable-6.7.2 源码注释地址：https://github.com/solojin/flowable-6.7.2-annotated BoundaryEventRegistryEventActivityBehavior 边界事件注册事件活动行为类 /** * 边界事件注册事件活动行为类 * * @author Tijs Rademakers */ public class BoundaryEventRegistryEventActivityBehavior extends Bound
Flowable源码注释（六十二）网关活动行为类（上）
jinyangjie的博客
03-09 825
Flowable-6.7.2 源码注释地址：https://github.com/solojin/flowable-6.7.2-annotated ExclusiveGatewayActivityBehavior 独占网关活动行为类 package org.flowable.engine.impl.bpmn.behavior; import java.util.Iterator; import org.flowable.bpmn.model.ExclusiveGateway; import org.fl
Flowable源码注释（六十八）流节点、抽象BPMN活动行为
jinyangjie的博客
03-23 1349
Flowable-6.7.2 源码注释地址：https://github.com/solojin/flowable-6.7.2-annotated FlowNodeActivityBehavior 流节点活动行为类 是网关、边界、任务等活动行为类继承的抽象类 /** * 流节点活动行为类 * * 所有“可连接”BPMN 2.0流程元素的超类：任务、网关和事件。这意味着任何子类都可以是sequenceflow的源或目标。 * 与BPMN 2.0中的“流节点”（flownode）概念相对应。 *
Flowable源码注释（六十三）网关活动行为类（下）
jinyangjie的博客
03-10 710
Flowable-6.7.2 源码注释地址：https://github.com/solojin/flowable-6.7.2-annotated InclusiveGatewayActivityBehavior 包容网关活动行为类 /** * 包容网关活动行为类 * Implementation of the Inclusive Gateway/OR gateway/inclusive data-based gateway as defined in the BPMN specification.
Flowable源码注释（六十一）默认活动行为工厂类
jinyangjie的博客
03-03 832
Flowable-6.7.2 源码注释地址：https://github.com/solojin/flowable-6.7.2-annotated DefaultActivityBehaviorFactory 默认活动行为工厂类 /** * 默认活动行为工厂类 * 活动行为工厂{@link ActivityBehaviorFactory}的默认实现。 * 在流程引擎配置类{@link ProcessEngineConfigurationImpl}上没有注入自定义{@link ActivityBehav
flowable官方文档中文版.zip
06-24
flowable官方文档中文版.pdf
flowable6.5解析(9)----CommandContextUtil对象
Thubier
09-11 1814
CommonContext，命令上下文对象，在整个系统中起支撑作用
Flowable流程启动源码分析
CH_PaulFrank的专栏
05-14 3324
流程启动过程 1.源码执行过程 runtimeService.createProcessInstanceBuilder() .processDefinitionKey(instanceTrigger.getProcessDefinitionKey().trim()) .name(instanceTrigger.getFormName() == null ? "" : instanceTrigger.getFormName().trim())
（1）Flowable基础操作-部署、创建、查询、完成
bluede2015的博客
04-06 6661
Flowable是一个使用Java编写的轻量级业务流程引擎。Flowable流程引擎可用于部署BPMN 2.0流程定义（用于定义流程的行业XML标准）， 创建这些流程定义的流程实例，进行查询，访问运行中或历史的流程实例与相关数据，等等。
flowable启动流程实例源码分析
weixin_42310146的博客
04-22 4710
1 流程实例助手类初始化源码 public void initHelpers() { if (processInstanceHelper == null) { processInstanceHelper = new ProcessInstanceHelper(); } if (listenerNotificationHel...
Flowable源码注释（二十九）作业处理器、定时启动事件作业处理器
jinyangjie的博客
02-10 661
Flowable源码地址：https://github.com/flowable/flowable-engine Flowable-6.7.2 源码注释地址：https://github.com/solojin/flowable-6.7.2-annotated 包路径：org.activiti.engine.impl.jobexecutor JobHandler 作业处理器接口类 package org.activiti.engine.impl.jobexecutor; import org.activi
flwoable如何实现后加签（动态添加节点）
热门推荐
nixzmdi1的专栏
05-28 1万+
flowable的功能基本都是基于命令模式实现的，flowalble提供了一个方法，可以调用我们自己编写的命令。 ManagementService managementService;这个service里有个executeCommand方法 入参为Command，今天就是基于这个方法来实现后加签的。有兴趣的同学还可以看下这个service的其它方法。 AbstractDynamicInjectionCmd 由flowable提供的基础命令，修改流程的基类。 下面是实现后加签的命令源码 自定义后加签c
探索Flowable 6.4.0源码：深入学习BPMN底层机制
Flowable 是一个强大的、开源的、支持 BPMN 2.0 规范的工作流和业务流程管理系统（BPMS），它是基于 Java 开发，可以运行在任何 Java 虚拟机（JVM）上。Flowable 6.4.0 作为其中一个版本，提供了一套完整的业务流程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值