Flowable流程启动源码分析

最新推荐文章于 2024-08-30 07:00:00 发布
最新推荐文章于 2024-08-30 07:00:00 发布
阅读量2.9k 收藏 7
点赞数
分类专栏： Flowable 文章标签： java 业务流程测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CH_PaulFrank/article/details/116800070
版权

流程启动过程

1.源码执行过程

runtimeService.createProcessInstanceBuilder()
                .processDefinitionKey(instanceTrigger.getProcessDefinitionKey().trim())
                .name(instanceTrigger.getFormName() == null ? "" : instanceTrigger.getFormName().trim())
                .businessKey(instanceTrigger.getFormKey() == null ? "" : instanceTrigger.getFormKey().trim())
                .variables(instanceTrigger.getVariables())
                .tenantId(instanceTrigger.getTenantId())
                .start();

1.1. 启动流程

--> runtimeService.startProcessInstance(this)

1.2. 执行命令

        --> org.flowable.common.engine.impl.cfg.CommandExecutorImpl.execute(new StartProcessInstanceCmd<ProcessInstance>(processInstanceBuilder))
            --> CommandInterceptor first.execute(CommandConfig config, Command<T> command)

1.3. 拦截命令

                //命令拦截器 LogInterceptor -> SpringTransactionInterceptor -> CommandContextInterceptor -> TransactionContextInterceptor -> CommandInvoker
                //org.flowable.common.engine.impl.AbstractEngineConfiguration protected List<CommandInterceptor> customPostCommandInterceptors;
                --> org.flowable.common.engine.impl.interceptor.LogInterceptor.execute(CommandConfig config, Command<T> command)
                    --> org.flowable.common.spring.SpringTransactionInterceptor.execute(final CommandConfig config, final Command<T> command)
                        --> int transactionPropagation = getPropagation(config); //获取事务传播方式：
                        //1.NOT_SUPPORTED 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
                        //2.REQUIRED 支持当前事务，如果当前没有事务，就新建一个事务 (默认)
                        //3.REQUIRES_NEW 新建事务，如果当前存在事务，把当前事务挂起
                            --> org.flowable.common.engine.impl.interceptor.CommandContextInterceptor.execute(CommandConfig config, Command<T> command)
                                --> commandContext = commandContextFactory.createCommandContext(command);
                                --> commandContext.setEngineConfigurations(engineConfigurations);
                                --> org.flowable.common.engine.impl.interceptor.TransactionContextInterceptor.execute(CommandConfig config, Command<T> command)
                                    --> org.flowable.engine.impl.interceptor.BpmnOverrideContextInterceptor.execute(CommandConfig config, Command<T> command)
                                        --> org.flowable.engine.impl.interceptor.CommandInvoker.execute(final CommandConfig config, final Command<T> command)
                                            --> FlowableEngineAgenda agenda = CommandContextUtil.getAgenda(commandContext);

1.4. 计划流程的操作

                                            --> agenda.planOperation(new Runnable() {
                                                    @Override
                                                    public void run() {
                                                        commandContext.setResult(command.execute(commandContext));
                                                    }
                                                });
                                            --> executeOperations(commandContext)
                                                --> StartProcessInstanceCmd.execute(CommandContext commandContext)
                                                    --> processInstance = startProcessInstance(processDefinition)
                                                        --> ProcessInstanceHelper.createProcessInstance(ProcessDefinition, )
                                                            --> CommandContextUtil.getHistoryManager(commandContext).recordProcessInstanceStart(processInstance);
                                                                --> HistoricProcessInstanceEntity historicProcessInstance = getHistoricProcessInstanceEntityManager().create(processInstance);
                                                                    --> historicProcessInstanceDataManager.create(processInstanceExecutionEntity);
                                                                --> getHistoricProcessInstanceEntityManager().insert(historicProcessInstance, false);
                                                                    --> AbstractEntityManager.insert(EntityImpl, boolean)

1.5. 插入实体（只提交到缓存）

                                                                    //实体插入（加入缓存）顺序：ProcessInstance->IdentityLinkEntity->HistoricIdentityLinkEntityImpl
                                                                    //->HistoricProcessInstanceEntity->Execution->ActivityInstanceEntity->HistoricActivityInstanceEntity
                                                                        --> getDataManager().insert(entity);
                                                                            --> DbSqlSession.insert(Entity entity)
                                                                                --> insertedObjects.put(clazz, new LinkedHashMap<>()); 
                                                                                --> insertedObjects.get(clazz).put(entity.getId(), entity); //**加入缓存，待事务提交入库
                                                                                --> entityCache.put(entity, false);
                                                            --> eventDispatcher.dispatchEvent(FlowableEventBuilder.createEntityEvent(FlowableEngineEventType.HISTORIC_PROCESS_INSTANCE_CREATED, historicProcessInstance)); //HISTORIC_PROCESS_INSTANCE_CREATED
                                                                --> FlowableEventSupport.dispatchEvent(org.flowable.common.engine.api.delegate.event.FlowableEvent)
                                                                --> BpmnModelEventDispatchAction.dispatchEvent(CommandContext commandContext, FlowableEventSupport eventSupport, FlowableEvent event)
                                                            --> eventDispatcher.dispatchEvent(FlowableEventBuilder.createEntityEvent(FlowableEngineEventType.PROCESS_CREATED, processInstance)); //PROCESS_CREATED
                                                                --> FlowableEventSupport.dispatchEvent(org.flowable.common.engine.api.delegate.event.FlowableEvent)
                                                                --> BpmnModelEventDispatchAction.dispatchEvent(CommandContext commandContext, FlowableEventSupport eventSupport, FlowableEvent event)
                                                                    --> ((FlowableEventSupport) bpmnModel.getEventSupport()).dispatchEvent(event)
                                                                        --> FlowableEventSupport.dispatchEvent(org.flowable.common.engine.api.delegate.event.FlowableEvent)
                                                            --> eventDispatcher.dispatchEvent(FlowableEventBuilder.createEntityWithVariablesEvent(FlowableEngineEventType.ENTITY_INITIALIZED, processInstance, startInstanceBeforeContext.getVariables(), false)); //ENTITY_INITIALIZED
                                                                --> FlowableEventSupport.dispatchEvent(org.flowable.common.engine.api.delegate.event.FlowableEvent)
                                                                --> BpmnModelEventDispatchAction.dispatchEvent(CommandContext commandContext, FlowableEventSupport eventSupport, FlowableEvent event)
                                                                    --> ((FlowableEventSupport) bpmnModel.getEventSupport()).dispatchEvent(event)
                                                                        --> FlowableEventSupport.dispatchEvent(org.flowable.common.engine.api.delegate.event.FlowableEvent)
                                                            --> CommandContextUtil.getActivityInstanceEntityManager(commandContext).recordActivityStart(execution);
                                                                --> org.flowable.engine.impl.persistence.entity.ActivityInstanceEntityManagerImpl.recordActivityStart(ExecutionEntity executionEntity)

1.6. 完成ProcessInstance的创建，并返回

                                                            --> startProcessInstance(processInstance, commandContext, startInstanceBeforeContext.getVariables())
                                                                --> ExecutionEntity execution = processInstance.getExecutions().get(0); // There will always be one child execution created

1.7. 计划流程节点的操作

                                                                --> CommandContextUtil.getAgenda(commandContext).planContinueProcessOperation(execution); //计划第一个流程节点的操作
                                            --> executeOperations(commandContext);

1.8. 循环取出节点，分别执行对应的cmd

                                                //while (!CommandContextUtil.getAgenda(commandContext).isEmpty()) 循环取出流程图所有元素
                                                --> Runnable runnable = CommandContextUtil.getAgenda(commandContext).getNextOperation();
                                                --> executeOperation(runnable);
                                                    --> org.flowable.engine.impl.agenda.ContinueProcessOperation.run()
                                                        --> continueThroughFlowNode(FlowNode flowNode)
                                                            --> executeProcessStartExecutionListeners();
                                                                --> executeExecutionListeners(HasExecutionListeners elementWithExecutionListeners,ExecutionEntity executionEntity, String eventType)
                                                                    --> CommandContextUtil.getProcessEngineConfiguration(commandContext).getListenerNotificationHelper()
                                                                                       .executeExecutionListeners(elementWithExecutionListeners, executionEntity, eventType);
                                                                        --> org.flowable.engine.impl.bpmn.listener.ListenerNotificationHelper.executeExecutionListeners(HasExecutionListeners elementWithExecutionListeners, DelegateExecution execution, String eventType)
                                                                            --> executeSynchronous(flowNode);
                                                                                --> processEngineConfiguration.getEventDispatcher().dispatchEvent(
                                                                                        FlowableEventBuilder.createActivityEvent(FlowableEngineEventType.ACTIVITY_STARTED, flowNode.getId(), flowNode.getName(), execution.getId(),
                                                                                                execution.getProcessInstanceId(), execution.getProcessDefinitionId(), flowNode));
                                                                                    -->org.flowable.engine.impl.bpmn.behavior.FlowNodeActivityBehavior.execute() 
                                                            --> executeActivityBehavior(activityBehavior, flowNode);
                                                            --> executeBoundaryEvents(boundaryEvents, boundaryEventExecutions);
                                                        --> executeSynchronous(flowNode)/executeMultiInstanceSynchronous(flowNode)/executeAsynchronous(flowNode)
                                                            --> CommandContextUtil.getActivityInstanceEntityManager(commandContext).recordActivityStart(execution);
                                                    --> org.flowable.engine.impl.agenda.TakeOutgoingSequenceFlowsOperation.run()
                                                        --> cleanupExecutions(currentFlowElement);
                                                        --> handleActivityEnd(flowNode);
                                                            --> CommandContextUtil.getEventDispatcher(commandContext).dispatchEvent(
                                                                   lowableEventBuilder.createActivityEvent(FlowableEngineEventType.ACTIVITY_COMPLETED, flowNode.getId(), flowNode.getName(),
                                                                         execution.getId(), execution.getProcessInstanceId(), execution.getProcessDefinitionId(), flowNode));
                                                        --> leaveFlowNode(flowNode);
                                                            --> agenda.planContinueProcessOperation(outgoingExecution);
                                            //上面这段会循环执行找出流程图里的所有element： StartEvent id="StartEvent_1" -> sequenceFlow id="Flow_0s4uh4h" -> exclusiveGateway id="Gateway_1x6a8jq" -> sequenceFlow id="Flow_12jwnrf" -> userTask id="Activity_1wajqhb" -> ...

1.9. 按拦截器顺序逆向返回，之后进行事务提交

                            //按拦截器顺序逆向返回，之后进行事务提交
                            --> commandContext.close();
                                --> flushSessions(); 
                                    --> session.flush();
                                        --> flushInserts();
                                            --> flushInsertEntities(entityClass, insertedObjects.get(entityClass).values());
                                                --> flushRegularInsert(entitiesToInsert.iterator().next(), entityClass);

1.10. 提交事务的时候将缓存入库

                                                    --> DbSqlSession.insert(insertStatement, entity); //**执行插入，入库
                                            --> insertedObjects.remove(entityClass); //清空缓存
                                        --> flushUpdates();
                                        --> flushDeletes();

2.任务调度过程

ProcessEngineConfigurationImpl.setAsyncExecutorActivate控制着任务调度是否开启

ProcessEngineConfigurationImpl.buildProcessEngine
    --> init();
        --> initAsyncExecutor();
            --> asyncExecutor = defaultAsyncExecutor;
            --> asyncExecutor.setAutoActivate(asyncExecutorActivate); //**asyncExecutorActivate 控制着异步任务调度是否开启
    --> new ProcessEngineImpl(this)
        --> asyncExecutor.start() //if (asyncExecutor != null && asyncExecutor.isAutoActivate())
            --> AbstractAsyncExecutor.start()
                --> initializeRunnables() 
                    --> timerJobRunnable = new AcquireTimerJobsRunnable(this, jobServiceConfiguration.getJobManager());
                    --> resetExpiredJobsRunnable = new ResetExpiredJobsRunnable(resetRunnableName, this, jobEntityManagerToUse);
                    --> asyncJobsDueRunnable = new AcquireAsyncJobsDueRunnable(acquireJobsRunnableName, this, jobEntityManagerToUse)
                --> DefaultAsyncJobExecutor.startAdditionalComponents
                    --> initAsyncJobExecutionThreadPool();
                    --> startJobAcquisitionThread();
                    --> startTimerAcquisitionThread();
                        --> AcquireTimerJobsRunnable.run()
                    --> startResetExpiredJobsThread()
                        --> ResetExpiredJobsRunnable.run()
                            --> resetJobs()
                                --> List<? extends JobInfoEntity> expiredJobs = asyncExecutor.getJobServiceConfiguration().getCommandExecutor()
                                        .execute(new FindExpiredJobsCmd(asyncExecutor.getResetExpiredJobsPageSize(), jobEntityManager));
                                    --> asyncExecutor.getJobServiceConfiguration().getCommandExecutor().execute(
                                            new ResetExpiredJobsCmd(expiredJobIds, jobEntityManager));

3.默认命令拦截器配置

    public Collection<? extends CommandInterceptor> getDefaultCommandInterceptors() {
        if (defaultCommandInterceptors == null) {
            List<CommandInterceptor> interceptors = new ArrayList<>();
            interceptors.add(new LogInterceptor()); //1. LogInterceptor

            if (DATABASE_TYPE_COCKROACHDB.equals(databaseType)) {
                interceptors.add(new CrDbRetryInterceptor());
            }

            CommandInterceptor transactionInterceptor = createTransactionInterceptor(); //2. new SpringTransactionInterceptor(transactionManager);
            if (transactionInterceptor != null) {
                interceptors.add(transactionInterceptor);
            }

            if (commandContextFactory != null) {
                String engineCfgKey = getEngineCfgKey();
                CommandContextInterceptor commandContextInterceptor = new CommandContextInterceptor(commandContextFactory);
                engineConfigurations.put(engineCfgKey, this);
                commandContextInterceptor.setEngineConfigurations(engineConfigurations);
                commandContextInterceptor.setServiceConfigurations(serviceConfigurations);
                commandContextInterceptor.setCurrentEngineConfigurationKey(engineCfgKey);
                interceptors.add(commandContextInterceptor); //3. CommandContextInterceptor
            }

            if (transactionContextFactory != null) {
                interceptors.add(new TransactionContextInterceptor(transactionContextFactory)); //4. TransactionContextInterceptor
            }

            List<CommandInterceptor> additionalCommandInterceptors = getAdditionalDefaultCommandInterceptors(); //5. new BpmnOverrideContextInterceptor()
            if (additionalCommandInterceptors != null) {
                interceptors.addAll(additionalCommandInterceptors);
            }

            defaultCommandInterceptors = interceptors;
        }
        return defaultCommandInterceptors;
    }

3.1自定义拦截器

改造切入点：设置customPostCommandInterceptors

engineConfiguration.setCustomPostCommandInterceptors()

    public void initCommandInterceptors() {
        if (commandInterceptors == null) {
            commandInterceptors = new ArrayList<>();
            if (customPreCommandInterceptors != null) {
                commandInterceptors.addAll(customPreCommandInterceptors);
            }
            commandInterceptors.addAll(getDefaultCommandInterceptors());
            if (customPostCommandInterceptors != null) {
                commandInterceptors.addAll(customPostCommandInterceptors);
            }
            commandInterceptors.add(commandInvoker); //6. CommandInvoker
        }

4.事件监听器

    public void dispatchEvent(FlowableEvent event) {
        if (event == null) {
            throw new FlowableIllegalArgumentException("Event cannot be null.");
        }

        if (event.getType() == null) {
            throw new FlowableIllegalArgumentException("Event type cannot be null.");
        }

        // Call global listeners
        if (!eventListeners.isEmpty()) {
            for (FlowableEventListener listener : eventListeners) {
                dispatchEvent(event, listener);
            }
        }

        // Call typed listeners, if any
        List<FlowableEventListener> typed = typedListeners.get(event.getType());
        if (typed != null && !typed.isEmpty()) {
            for (FlowableEventListener listener : typed) {
                dispatchEvent(event, listener);
            }
        }
    }

改造切入点：
engine.setEventListeners(List eventListeners)
engine.setAdditionalEventDispatchActions(List additionalEventDispatchActions)

    public void initEventDispatcher() {
        if (this.eventDispatcher == null) {
            this.eventDispatcher = new FlowableEventDispatcherImpl();
        }

        if (this.additionalEventDispatchActions == null) {
            this.additionalEventDispatchActions = new ArrayList<>();
            this.additionalEventDispatchActions.add(new BpmnModelEventDispatchAction());
        }

        this.eventDispatcher.setEnabled(enableEventDispatcher);

        if (eventListeners != null) {
            for (FlowableEventListener listenerToAdd : eventListeners) {
                this.eventDispatcher.addEventListener(listenerToAdd);
            }
        }

        if (typedEventListeners != null) {
            for (Entry<String, List<FlowableEventListener>> listenersToAdd : typedEventListeners.entrySet()) {
                // Extract types from the given string
                FlowableEngineEventType[] types = FlowableEngineEventType.getTypesFromString(listenersToAdd.getKey());

                for (FlowableEventListener listenerToAdd : listenersToAdd.getValue()) {
                    this.eventDispatcher.addEventListener(listenerToAdd, types);
                }
            }
        }
    }

最后

  • flowable自带mapper

在这里插入图片描述

CH_PaulFrank
关注
专栏目录
flowable源码解析之流程引擎启动（四）
Sombie Fate的专栏
08-25 386
前面三篇文章中，我们分析了流程引擎配置类ProcessEngineConfigurationImpl的部分初始化方法的源码，本文继续分析完成后续所有方法的实现。
Flowable源码解析之流程的发起
Sombie Fate的专栏
08-25 500
在前文中，我们详细分析了流程的部署过程，以及流程文件是如何逐步转换为 BpmnModel 对象，并最终生成流程定义的。流程一旦成功部署，就可以根据部署结果来启动流程实例。从流程发起的角度出发，我们将分析 Flowable 的内部机制，看看Flowable在流程发起时都做了哪些操作。
Flowable背压支持——几乎可以说是对Flowable最全面而详细的讲解
{丸の子}
12-04 5033
背压（backpressure） 数据流发射，处理，响应可能在各自的线程中独立进行，上游在发射数据的时候，不知道下游是否处理完，也不会等下游处理完之后再发射。 这样，如果上游发射的很快而下游处理的很慢，会怎样呢？ 将会产生很多下游没来得及处理的数据，这些数据既不会丢失，也不会被垃圾回收机制回收，而是存放在一个异步缓存池中，如果缓存池中的数据一直得不到处理，越积越多，最后就会造成内存溢出，...
flowable源码解读——并行多实例节点任务是否是顺序生成
weixin_43841461的博客
08-23 830
最近在项目开发中需要在多实例开始监听里修改一个全局的计数变量，不太确定并行多实例任务在底层引擎是顺序生成还是并行生成的，如果是顺序生成的则不影响，如果是并行生成 则修改一个全局的计数变量就会出现数据错误问题，查阅了flowable源码，做个记录。 查看并行多实例节点任务类 ParallelMultiInstanceBehavior，代码如下： 通过源码可以看出，并行多实例任务底层还是按顺序生成的，并不是并行生成。以下是 该类的结构图： 可以看出该类是继承 FlowNodeActivityBehavi
Flowable-源码分析-2启动
andy的博客
12-16 429
流程引擎拥有如下插件类。
flowableUI源码分析（一）
qq_42583549的博客
04-17 1466
计划从flowable–ui-admin入手，分析flowable框架操作sql表情况。 1. Model类 UI应用，使用 Model类来存储BPM流程图、表单、流程应用。 创建BPM流程图、表单、流程应用。都会创建到 act_de_model 表中 代码通过常量定义model的类型 public static final int MODEL_TYPE_BPMN = 0; public static final int MODEL_TYPE_FORM = 2; public sta
Flowable从入门到精通源码
05-20
从基础讲起，结合应用场景，由浅到深细化讲解BPMN和Flowable的相关组件，并结合具体实例，演示功能的使用和注意事项。最终结合Springboot搭建一套工作流系统，囊括一般项目中所需要的知识点，理论结合实际，让真正入门到熟练。本资源是https://download.csdn.net/download/qq_36305027/72613407这个资源文件的源码部分，需要的朋友可以订阅我的专栏（工作流实战）https://blog.csdn.net/qq_36305027/article/details/122262786后免费申请该源码。改源码编写的例子在专栏中有所说明，需要了解里面具体有哪些内容的可以去看看
Flowable 6.4.0官方github源代码
12-23
Flowable 6.4.0官方github源代码，可以编译通过的代码，对于学习Flowable的底层机制是一个必不可少的资源
flowable源码解析之流程引擎启动（一）
Sombie Fate的专栏
08-25 410
在本次讨论中，我们从流程引擎启动的源码角度深入探讨了Flowable引擎中的一系列初始化方法以及其在流程引擎的构建和运行过程中的作用。这些方法在Flowable的源码中扮演着重要的角色，涵盖了流程图生成器、辅助类、拦截器、数据源初始化、表单类型定义等多个方面。后续将继续介绍剩下部分。
flowable源码解析之分析环境搭建
Sombie Fate的专栏
08-25 566
深入理解Flowable流程引擎的源码结构和内部工作机制是掌握该引擎的关键。搭建源码分析环境是开始的第一步，它使我们能够更好地分析源码并进行相关的改进。Flowable的整体结构由引擎服务层、拦截器层、命令层和数据访问层组成，它们协同工作，完成了流程引擎的各种功能。通过深入研究这些层次的工作原理，我们可以更好地理解Flowable流程引擎的内部机制，有了第一步之后，我们后续文章再继续深入！
Flowable-BPMN操作流程部署启动源码
01-11
在"Flowable-BPMN操作流程部署启动源码"中，我们可以了解到如何通过编程方式来实现Flowable的流程部署和启动。这通常涉及到以下步骤： 1. **创建流程定义**: 使用BPMN 2.0标准的XML文件描述流程。这个文件包含了...
flowable-engine-6.4.0 工作流引擎源码
11-14
最新flowable工作流引擎源码，包括moduler 设计器源码。
flowable-engine-flowable-6.5.0.zip(官方源码)
02-27
Flowable6.5.0源码下载，注意是官方源码，从github上搬来的。git的下载速度，不说了。
flowable-engine-flowable-6.4.2.zip（官方源码）
02-27
Flowable6.4.2源码下载，注意是官方源码，从github上搬来的。git的下载速度，不说了。
Flowable modeler集成源码
01-07
Flowable modeler集成源码，具体操作步骤参考我的blog，Flowable深入浅出-7、8、9 专栏地址:https://blog.csdn.net/houyj1986/column/info/31755
Flowable整合SpringBoot源码
03-28
Flowable整合SpringBoot源码
Flowable从入门到源码分析
CodeV的博客
04-20 3778
工作流，是把业务之间的各个步骤以及规则进行抽象和概括性的描述。使用特定的语言为业务流程建模，让其运行在计算机上，并让计算机进行计算和推动。工作流解决的痛点在于，解除业务宏观流程和微观逻辑的耦合，让熟悉宏观业务流程的人去制定整套流转逻辑，而让专业的人只需要关心他们应当关心的流程节点。BPM:Business Process Management，业务流程管理BPMN:Business Process Modeling Notation，BPMN是一个广泛接受与支持的，展现流程的注记方法，是一种图形化表示业务流
flowable源码解读——内存缓存设计
最新发布
weixin_43841461的博客
08-30 791
通过以上对比可以看到 Collections.synchronizedMap()的方式并不是原子级别的锁定，在高并发下有性能瓶颈，不太理解为什么flowable不用ConcurrentHashMap 这种方式做内存缓存，也许是考虑对流程定义的读写不会太频繁才这么设计。在高并发环境下，当多个线程同时访问不同的键值对时，可能会导致性能瓶颈。最近检查flowable缓存问题，顺便看了下源码，flowable默认是将缓存存储在内存中，以减少对数据库的压力，以下是flowable缓存类的设计。
flowable源码
08-23
Flowable是一个开源的流程引擎，可以用于处理和管理各种类型的业务流程。Flowable的源码可以在其官方的GitHub仓库上找到，具体地址是https://github.com/flowable/flowable-engine/releases/tag/flowable-6.7.2。 Flowable的启动流程有两种方式，但最终都是执行了StartProcessInstanceCmd命令。在我以流程key方式启动来分析源码中，启动流程的入口是通过runtimeService.startProcessInstance方法来实现的。 通过研究Flowable的源码，可以深入了解其内部的实现机制，从而更好地理解Flowable的工作原理和使用方法。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [flowable 6.7.2 源码压缩包](https://download.csdn.net/download/weixin_44393822/86790116)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] - *2* [flowable部署和启动源码解析](https://blog.csdn.net/u012483153/article/details/106736343)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] - *3* [Flowable流程启动源码分析](https://blog.csdn.net/CH_PaulFrank/article/details/116800070)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值