flowable引擎类与引擎配置类(1)

最新推荐文章于 2024-07-16 20:28:57 发布
最新推荐文章于 2024-07-16 20:28:57 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： flowable 文章标签： flowable
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42310146/article/details/89081961
版权

1. 导报

        <!-- https://mvnrepository.com/artifact/org.flowable/flowable-engine -->
        <dependency>
            <groupId>org.flowable</groupId>
            <artifactId>flowable-engine</artifactId>
            <version>6.4.0</version>
        </dependency>

        <!-- dbpool的jar -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.2</version>
        </dependency>

        <!-- mysql驱动包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.28</version>
        </dependency>

        <!-- Logging 日志相关-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/ch.qos.logback/logback-classic -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

 2. 配置flowable.conf.xml文件

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans   http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName">
            <value>com.mysql.jdbc.Driver</value>
        </property>
        <property name="url">
            <value>
            jdbc:mysql://127.0.0.1:3306/flowable? 
            useUnicode=true&amp;characterEncoding=UTF-8
            </value>
        </property>
        <property name="username">
            <value>root</value>
        </property>
        <property name="password" value="admin"/>
    </bean>

    <bean id="processEngineConfiguration"       
      class="org.flowable.engine.impl.cfg.StandaloneProcessEngineConfiguration">

        <property name="dataSource" ref="dataSource"></property>
        <!-- Database configurations -->
        <property name="databaseSchemaUpdate" value="true"/>
            <property name="databaseType" value="mysql"></property>
        </property>
    </bean>


</beans>

3. 日志配置文件

log4j.rootLogger=INFO, stdout

# Console Appender
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern= %d{hh:mm:ss,SSS} [%t] %-5p %c %x - %m%n

# Custom tweaks
log4j.logger.com.codahale.metrics=WARN
log4j.logger.com.ryantenney=WARN
log4j.logger.com.zaxxer=WARN
log4j.logger.org.apache=WARN
log4j.logger.org.hibernate=WARN
log4j.logger.org.hibernate.engine.internal=WARN
log4j.logger.org.hibernate.validator=WARN
log4j.logger.org.springframework=WARN
log4j.logger.org.springframework.web=WARN
log4j.logger.org.springframework.security=WARN
log4j.logger.org.flowable.engine.impl.persistence.entity=DEBUG
log4j.logger.org.flowable.task.service.impl.persistence.entity=DEBUG
log4j.logger.org.flowable.variable.service.impl.persistence.entity=DEBUG
log4j.logger.org.flowable.identitylink.service.impl.persistence.entity=DEBUG

log4j.logger.org.flowable.job.service.impl.persistence.entity=DEBUG

4. 流程引擎获取一些服务类

        processEngine = ProcessEngines.getDefaultProcessEngine();
        System.out.println("流程引擎类：" + processEngine);
        RepositoryService repositoryService = processEngine.getRepositoryService();
        System.out.println(repositoryService);
        String name = processEngine.getName();
        System.out.println("流程引擎的名称：" + name);
        DynamicBpmnService dynamicBpmnService = processEngine.getDynamicBpmnService();
        System.out.println(dynamicBpmnService);
        FormService formService = processEngine.getFormService();
        System.out.println(formService);

        HistoryService historyService = processEngine.getHistoryService();
        System.out.println(historyService);
        IdentityService identityService = processEngine.getIdentityService();
        System.out.println(identityService);
        ManagementService managementService = processEngine.getManagementService();
        System.out.println(managementService);
        ProcessEngineConfiguration processEngineConfiguration =         
            processEngine.getProcessEngineConfiguration();
        System.out.println(processEngineConfiguration);
        RuntimeService runtimeService = processEngine.getRuntimeService();
        System.out.println(runtimeService);
        TaskService taskService = processEngine.getTaskService();
        System.out.println(taskService);

5. 相关服务类的职责

6. 流程引擎类以及服务类的获取流程

flowable创建引擎类源码分析请点击

7. 获取flowable.conf.xml文件中的bean

        Map<Object, Object> beans = processEngineConfiguration.getBeans();
        Object testA = beans.get("testA");
        System.out.println(testA);
        boolean testA1 = beans.containsKey("testA");
        System.out.println("是否包含testA:" + testA1);
        Object dataSource = beans.containsKey("dataSource");
        System.out.println("是否包含dataSource:" + dataSource);
        Object dataSource1 = beans.containsKey("dataSource1");
        System.out.println("是否包含dataSource1:" + dataSource1);

flowable添加bean原理

8. 流程实例化逻辑(创建ProcessEngine)

public ProcessEngine buildProcessEngine() {
        //调用init()初始化引擎配置类中的属性
        init();
        //实例化ProcessEngineImpl
        ProcessEngineImpl processEngine = new ProcessEngineImpl(this);

        // 检查是否使用Activiti或者flowable5版本
        if (flowable5CompatibilityEnabled && flowable5CompatibilityHandler != null) {
            commandExecutor.execute(new Command<Void>() {
                @Override
                public Void execute(CommandContext commandContext) {
                    flowable5CompatibilityHandler.getRawProcessEngine();
                    return null;
                }
            });
        }
        //检查是否使用流程实例相关数量记录
        postProcessEngineInitialisation();

        return processEngine;
}

第二步实例化相关类:

public ProcessEngineImpl(ProcessEngineConfigurationImpl processEngineConfiguration) {
            //服务类属性填充
            this.processEngineConfiguration = processEngineConfiguration;
            this.name = processEngineConfiguration.getEngineName();
            this.repositoryService = processEngineConfiguration.getRepositoryService();
            this.runtimeService = processEngineConfiguration.getRuntimeService();
            this.historicDataService = processEngineConfiguration.getHistoryService();
            this.identityService = processEngineConfiguration.getIdentityService();
            this.taskService = processEngineConfiguration.getTaskService();
            this.formService = processEngineConfiguration.getFormService();
            this.managementService = processEngineConfiguration.getManagementService();
            this.dynamicBpmnService = processEngineConfiguration.getDynamicBpmnService();
            this.asyncExecutor = processEngineConfiguration.getAsyncExecutor();
            this.asyncHistoryExecutor = processEngineConfiguration.getAsyncHistoryExecutor();
            this.commandExecutor = processEngineConfiguration.getCommandExecutor();
            this.sessionFactories = processEngineConfiguration.getSessionFactories();
            this.transactionContextFactory = processEngineConfiguration.getTransactionContextFactory();
            //根据databaseSchemaUpdate执行不同逻辑
            if (processEngineConfiguration.getSchemaManagementCmd() != null) {
                commandExecutor.execute(processEngineConfiguration.getSchemaCommandConfig(), processEngineConfiguration.getSchemaManagementCmd());
            }

        if (name == null) {
            LOGGER.info("default ProcessEngine created");
        } else {
            LOGGER.info("ProcessEngine {} created", name);
        }
        //注册当前流程实例对象
        ProcessEngines.registerProcessEngine(this);

        //触发流程引擎生命周期监听器  
        if (processEngineConfiguration.getProcessEngineLifecycleListener() != null) {
            processEngineConfiguration.getProcessEngineLifecycleListener().onProcessEngineBuilt(this);
        }

 //转发事件  
  processEngineConfiguration.getEventDispatcher().dispatchEvent(FlowableEventBuilder.createGlobalEvent(FlowableEngineEventType.ENGINE_CREATED));
        //判断是否要开启异步执行器
        if (asyncExecutor != null && asyncExecutor.isAutoActivate()) {
            asyncExecutor.start();
        }
        if (asyncHistoryExecutor != null && asyncHistoryExecutor.isAutoActivate()) {
            asyncHistoryExecutor.start();
        }
}

9. DDL版本执行逻辑

    databaseSchemaUpdate的值

//第一步
if (processEngineConfiguration.getSchemaManagementCmd() != null) {
                commandExecutor.execute(processEngineConfiguration.getSchemaCommandConfig(), processEngineConfiguration.getSchemaManagementCmd());
}
//第二部
public void initSchemaManagementCommand() {
        if (schemaManagementCmd == null) {
            if (usingRelationalDatabase && databaseSchemaUpdate != null) {
                this.schemaManagementCmd = new SchemaOperationsProcessEngineBuild();
            }
        }
}
//第三部
public Void execute(CommandContext commandContext) {
        
        SchemaManager schemaManager = CommandContextUtil.getProcessEngineConfiguration(commandContext).getSchemaManager();
        String databaseSchemaUpdate = CommandContextUtil.getProcessEngineConfiguration().getDatabaseSchemaUpdate();
        
        LOGGER.debug("Executing schema management with setting {}", databaseSchemaUpdate);
        //进行逻辑判断
        if (ProcessEngineConfiguration.DB_SCHEMA_UPDATE_DROP_CREATE.equals(databaseSchemaUpdate)) {
            try {
                schemaManager.schemaDrop();
            } catch (RuntimeException e) {
                // ignore
            }
        }
        if (ProcessEngineConfiguration.DB_SCHEMA_UPDATE_CREATE_DROP.equals(databaseSchemaUpdate)
                || ProcessEngineConfigurationImpl.DB_SCHEMA_UPDATE_DROP_CREATE.equals(databaseSchemaUpdate) || ProcessEngineConfigurationImpl.DB_SCHEMA_UPDATE_CREATE.equals(databaseSchemaUpdate)) {
            schemaManager.schemaCreate();

        } else if (ProcessEngineConfiguration.DB_SCHEMA_UPDATE_FALSE.equals(databaseSchemaUpdate)) {
            schemaManager.schemaCheckVersion();

        } else if (ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE.equals(databaseSchemaUpdate)) {
            schemaManager.schemaUpdate();
        }
        
        return null;
}

10. 手动方式引擎配置类构造引擎

  //方法1
 public void buildEngine1() {

        ProcessEngineConfiguration standaloneProcessEngineConfiguration = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
        standaloneProcessEngineConfiguration.setJdbcDriver("com.mysql.jdbc.Driver");
        standaloneProcessEngineConfiguration.setJdbcUrl("jdbc:mysql://127.0.0.1:3306/shareniu-idm?useUnicode=true&amp;characterEncoding=UTF-8");
        standaloneProcessEngineConfiguration.setJdbcUsername("root");
        standaloneProcessEngineConfiguration.setJdbcPassword("123");
        processEngine = standaloneProcessEngineConfiguration.buildProcessEngine();
        System.out.println(processEngine);

    }

//方法2
    public void buildEngine2() {
        StandaloneProcessEngineConfiguration standaloneProcessEngineConfiguration = new StandaloneProcessEngineConfiguration();
        standaloneProcessEngineConfiguration.setJdbcDriver("com.mysql.jdbc.Driver");
        standaloneProcessEngineConfiguration.setJdbcUrl("jdbc:mysql://127.0.0.1:3306/shareniu-idm?useUnicode=true&amp;characterEncoding=UTF-8");
        standaloneProcessEngineConfiguration.setJdbcUsername("root");
        standaloneProcessEngineConfiguration.setJdbcPassword("123");
        processEngine = standaloneProcessEngineConfiguration.buildProcessEngine();
        System.out.println(processEngine);

    }

//方法3
    public void buildEngine3() {
        InputStream inputStream = ProcessEngineTest.class.getClassLoader().getResourceAsStream("flowable.cfg.xml");
        ProcessEngineConfiguration processEngineConfigurationFromInputStream = ProcessEngineConfiguration.createProcessEngineConfigurationFromInputStream(inputStream);
        processEngine = processEngineConfigurationFromInputStream.buildProcessEngine();
        System.out.println(processEngine);
    }

//方法4
    public void buildEngine4() {
        InputStream inputStream = ProcessEngineTest.class.getClassLoader().getResourceAsStream("flowable.cfg.xml");
        String beanName="processEngineConfiguration1";
        ProcessEngineConfiguration processEngineConfigurationFromInputStream = ProcessEngineConfiguration.createProcessEngineConfigurationFromInputStream(inputStream,beanName);
        processEngine = processEngineConfigurationFromInputStream.buildProcessEngine();
        System.out.println(processEngine);
    }

 

超人很能飞
关注
专栏目录
flowable源码解析之流程引擎启动（四）
Sombie Fate的专栏
08-25 347
前面三篇文章中，我们分析了流程引擎配置类ProcessEngineConfigurationImpl的部分初始化方法的源码，本文继续分析完成后续所有方法的实现。
flowable源码解析之流程引擎启动（一）
Sombie Fate的专栏
08-25 368
在本次讨论中，我们从流程引擎启动的源码角度深入探讨了Flowable引擎中的一系列初始化方法以及其在流程引擎的构建和运行过程中的作用。这些方法在Flowable的源码中扮演着重要的角色，涵盖了流程图生成器、辅助类、拦截器、数据源初始化、表单类型定义等多个方面。后续将继续介绍剩下部分。
Flowable(五)：ProcessEngine系列（2）
FNTP_
09-30 1544
其实我们看了这些源码后，有了很明确的结论：（1）ProcessEngine构建的方式方法只有一种，源头就是配置构建，离不开ProcessEngineConfiguration配置类。（2）ProcessEngine构建非常依赖于配置，也就告诉你，ProcessEngine高度可定义，ProcessEngine可以通过ProcessEngineConfiguration来进行任意构建。好了今天就聊到这里吧，更多精彩，尽在码农修炼笔记！
Flowable获取ProcessEngine的三种方式
一起coding，一起嗨。
08-15 319
Flowable获取ProcessEngine的三种方式
Flowable流程引擎学习实践
最新发布
风雨无阻学习之路
07-16 1811
Flowable 是一个使用 Java 编写的轻量级业务流程引擎，工作流在企业管理系统中是高频使用的功能，事实上，工作流引擎能支持的业务场景远远不止单据审批，几乎所有涉及到业务流转、多人按流程完成工作的场景背后都可以通过工作流引擎作为支撑。
Flowable源码注释（三十四）定时器修改流程定义挂起状态作业处理器
jinyangjie的博客
02-12 496
Flowable源码地址：https://github.com/flowable/flowable-engine Flowable-6.7.2 源码注释地址：https://github.com/solojin/flowable-6.7.2-annotated 包路径：org.flowable.engine.impl.jobexecutor TimerChangeProcessDefinitionSuspensionStateJobHandler 定时器修改流程定义挂起状态作业处理器 package org
Flowable入门系列文章2 - 创建一个Flowable流程引擎
分享牛
09-22 1043
flowable入门、flowable现状、flowable开源产品、flwoable入门系列、flowable课程、flowable与activiti区别 Flowable是用Java编写的轻量级业务流程引擎。Flowable流程引擎允许您部署BPMN 2.0流程定义（用于定义流程的行业XML标准），创建 流程定义的流程实例，运行查询，访问活动或历史流程实例以及相关数据等等。本节将逐步介绍各种概念和API，通过您可以在自己的开发 机器上进行的实例进行实现。
https://mvnrepository.com/访问不了
热门推荐
codingxc的博客
10-13 2万+
访问https://mvnrepository.com/时无法验证信息加载不出来问题。 解决方法：修改DNS，首选114.114.114.114，备用8.8.8.8即可访问。 第一步：选择“打开网络和internet设置”。 第二步：双击打开“更改适配器选项”。 第三步：右键你使用的网络类型（如以太网，如果你使用的是WiFi就点WiFi）打开“属性”。 第四步：选中“iPv4协议”，右键点击属性。 第五部：手动将DNS更改为如下图，点击确定即可。 ...
flowable流程引擎-核心表分析
06-27
Flowable流程引擎核心表分析 流程引擎的核心表是Flowable流程引擎的基础组件，用于存储流程引擎的各种数据。这些表可以配置为在启动时生成，所有的表都以“act_”开头，沿用了Activiti的传统。 Flowable流程引擎...
在SpringBoot中集成flowable流程引擎及modeler可视化流程设计器项目完整源码，附有使用说明文档
06-09
在SpringBoot中集成flowable流程引擎及modeler可视化流程设计器项目完整源码，附有使用说明文档 1、使用开发工具eclipse或者idea等导入项目myflow 2、配置application.properties中的数据库连接，修改用户名和登录...
flowable源码解析之流程引擎启动（三）
Sombie Fate的专栏
08-25 698
继续深入探讨了Flowable流程引擎的初始化过程，分析了init方法中方法的实现，其中最核心的是initCommandExecutors()方法和initServices()。initCommandExecutors()方法详细介绍拦截器链的实现方式，包括拦截器链的入口和出口实现逻辑，后续再分析流程引擎的具体功能时，比如流程发起、任务办理等都还会更进一步对相关内容进行讲解。
maven仓库地址httpsmvnrepository.com
web18484626332的博客
08-20 5416
之前百度搜maven，前几个就能找到这个网址，现在不容易搜到了。
mvn仓库地址及mirror镜像网址
hjw199089的博客
03-27 4367
1：http://mvnrepository.com/ mvn依赖查询 2:https://mirrors.tuna.tsinghua.edu.cn/ 清华镜像下载地址
Flowable V5.x迁移至Flowable V6时需要注意的事项
勇往直前的专栏
08-22 2666
1. 介绍 Introduction 本手册介绍了从Flowable V5.x迁移至Flowable V6时需要注意的事项。 2. 设计目标 Design goals V6版本的设计目标是： 完全向前兼容V5版本：数据库层面、概念层面以及代码层面。 重写核心引擎：直接执行BPMN 2.0（不再转换为中间模型）。 更简洁干净的运行时执行数据结构，重点关注结构的可预判性...
Flowable(五)：ProcessEngine系列（1）
FNTP_
09-30 1773
好了，本文主要对ProcessEngine构建过程中的数据库配置以及启动过程中的源码进行了一个简单的解读。接下来的下文中，将会对Flowable的ProcessEngine中，一个ProcessEngine构建的真的流程，完整的给大家解读一番。更多精彩，尽在码农修炼笔记！
更好的maven依赖查询网站：https://mvnrepository.com/
u011495642的博客
10-31 2万+
https://mvnrepository.com/
maven中央仓库地址
qq_25983579的博客
10-17 697
mavn中央仓库地址:https://mvnrepository.com/
Flowable 流程实例
qq_37790902的博客
09-28 9417
流程实例系列 RuntimeService 运行服务类 核心功能 启动实例、查询与实例相关的一些信息 是Flowable的流程执行服务类。可以从这个类中获取很多关于流程执行相关的信息。 实现类为RuntimeServiceImpl 提供了一系列根据自身业务场景启动流程实例的API 流程定义、执行实例、流程实例概念 流程定义类 可以从这里获得资源文件。类似于java类 流程实例 代表流程定义的执行实例，比如张三请了一天假，他就必须发出一个流程实例的申请 一个流程实例包括了
如何用SpringBoot & Flowable实践工作流
qq_36984455的博客
03-21 680
在工作中难免会碰到许多流程处理的业务，本文测试环境： SpringBoot 2.2.9.RELEASE & flowable 6.5.0 & Mysql 5.5.27 添加Flowable依赖 <dependency> <groupId>org.flowable</groupId> <artifactId>flowable-spring-boot-starter-process</artifactId> &
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值