1.2.3 修改flowable-ui.war的配置文件
文章目录 1.2.2 安装-ui1.2.3 修改-ui.war的配置文件1.2.4 启动来部署.2.5 启动报错问题解决1.3 用户管理1.4 绘制流程1.5 部署流程 二：介绍三：基础 四：基础表结构 4.3 服务接口 4.4 图标介绍 4.5 流程部署详解 4.6 启动流程实例4.7 处理流程4.8 完成一个流程
一： UI应用与本地部署 1.1 应用
提供了几个web应用，用于演示及介绍项目提供的功能：
所有其他的应用都需要 IDM提供认证。每个应用的WAR文件可以部署在相同的容器（如 ）中，也可以部署在不同的容器中。由于每个应用使用相同的进行认证，因此应用需要运行在相同的域名下。
1.2 本地的安装部署 1.2.1 安装
官网：
下载后，解压到非中文的安装目录下
1.2.2 安装-ui
下载地址：
然后把解压缩后的两个war包拷贝到的解压缩的目录下
目录：
1.2.3 修改-ui.war的配置文件
在D:\\\-ui\WEB-INF\修改-文件的配置信息
1）指定端口号，默认为8080
2）连接数据库的注册驱动，以及连接信息，如果数据库没有的库，则会自动创建
3）配置连接数据库的用户名和密码
1.2.4 启动来部署
进入到/bin目录下，双击.bat文件
此时访问 :8080/-ui/,默认的登录用户名和密码为admin test
1.2.5 启动报错问题解决
当启动时，遇到如下图问题
问题1： by: org..beans..:
问题2：
by: java.lang.n: load class: com.mysql.cj.jdbc.
1）修改-的注册驱动，mysql版本8.0以上要加上cj
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
2）修改mysql的连接信息，加上=UTF-8&=true&e=false&=Asia/&=true&ent=true&=false
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/flowable?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=Asia/Shanghai&allowMultiQueries=true&nullCatalogMeansCurrent=true&useSSL=false
3）下载mysql--java-8.0.16.jar的包
下载地址：
下载后，把下载好的jar包，拷贝到D:\\\-ui\WEB-INF\lib目录下
此时就不报错了！！！
1.3 用户管理
emsp;我们先在 身份管理应用程序 中创建用户并授权
创建用户
填写详细信息
授权管理
1.4 绘制流程
1）创建新的流程
2）流程图界面
3）创建流程，分配处理人
4）继续完成流程图的创建
1.5 部署流程
emsp; 绘制好的流程图，我们只需要一键导出即可
下载下来后拷贝到项目的目录下即可
然后就是正常的操作流程了！
二：介绍
是BPMN的一个基于java的软件实现，不过不仅仅包括BPMN，还有DMN决策表和CMMN Case管理引擎，并且有自己的用户管理、微服务API等一系列功能，是一个服务平台。
三：基础
官方手册：#
3.1 创建
用IDEA创建一个基本的maven工程，然后添加两个依赖。
在pom.xml文件中添加下列行：
<dependency><groupId>org.flowablegroupId><artifactId>flowable-engineartifactId><version>6.3.0version>
dependency>
<dependency><groupId>mysqlgroupId><artifactId>mysql-connector-javaartifactId><version>8.0.21version>
dependency>
emsp;然后创建一个普通的Java类，添加对应的main方法，首先要做的是初始化流程引擎实例。这是一个线程安全的对象，因此通常只需要在一个应用中初始化一次。 由实例创建。该实例可以配置与调整流程引擎的设置。 通常使用一个配置XML文件创建，但是（像在这里做的一样）也可以编程方式创建它。 所需的最小配置，是数据库JDBC连接：
public static void main(String[] args) {ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration().setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn?serverTimezone=UTC").setJdbcUsername("root").setJdbcPassword("123456").setJdbcDriver("com.mysql.cj.jdbc.Driver").setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);ProcessEngine processEngine = cfg.buildProcessEngine();
}
注意在.0中执行可能出现如下的错误
emsp;出现这种情况只需要在mysql的连接字符串中添加上ent=true，设置为只查当前连接的库即可。
public static void main(String[] args) {ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration().setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn1?serverTimezone=UTC&nullCatalogMeansCurrent=true").setJdbcUsername("root").setJdbcPassword("123456").setJdbcDriver("com.mysql.cj.jdbc.Driver").setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);ProcessEngine processEngine = cfg.buildProcessEngine();}
emsp;然后应用运行没有问题，但也没有在控制台提供有用的信息，只有一条消息提示日志没有正确配置。使用SLF4J作为内部日志框架。在这个例子中，我们使用log4j作为SLF4J的实现。因此在pom.xml文件中添加下列依赖：
<dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>1.7.21</version>
</dependency>
<dependency><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId><version>1.7.21</version>
</dependency>
Log4j需要一个配置文件。在src/main/文件夹下添加log4j.文件，并写入下列内容：
log4j.rootLogger=DEBUG, CA
log4j.appender.CA=org.apache.log4j.ConsoleAppender
log4j.appender.CA.layout=org.apache.log4j.PatternLayout
log4j.appender.CA.layout.ConversionPattern= %d{hh:mm:ss,SSS} [%t] %-5p %c %x - %m%n
重新运行应用。应该可以看到关于引擎启动与创建数据库表结构的提示日志：
同时可以看到创建了相关的表结构在数据库中
这样就得到了一个启动可用的流程引擎。接下来为它提供一个流程！
3.2 部署流程定义
接下来我们构建一个非常简单的请假流程，引擎需要流程定义为BPMN 2.0格式，这是一个业界广泛接受的XML标准。 在术语中，我们将其称为一个流程定义( )。一个流程定义可以启动多个流程实例( )。流程定义可以看做是重复执行流程的蓝图。 在这个例子中，流程定义定义了请假的各个步骤，而一个流程实例对应某个雇员提出的一个请假申请。
BPMN 2.0存储为XML，并包含可视化的部分：使用标准方式定义了每个步骤类型（人工任务，自动服务调用，等等）如何呈现，以及如何互相连接。这样BPMN 2.0标准使技术人员与业务人员能用双方都能理解的方式交流业务流程。
我们要使用的流程定义为：
流程定义说明：
一般来说，这样的流程定义使用可视化建模工具建立，如 ()或 Web (Web应用)。但在这里我们直接撰写XML，以熟悉BPMN 2.0及其概念。
与上面展示的流程图对应的BPMN 2.0 XML在下面显示。请注意这只包含了“流程部分”。如果使用图形化建模工具，实际的XML文件还将包含“可视化部分”，用于描述图形信息，如流程定义中各个元素的坐标（所有的图形化信息包含在XML的标签中，作为标签的子元素）。
将下面的XML保存在src/main/文件夹下名为-..xml的文件中。
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:xsd="http://www.w3.org/2001/XMLSchema"xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI"xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC"xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI"xmlns:flowable="http://flowable.org/bpmn"typeLanguage="http://www.w3.org/2001/XMLSchema"expressionLanguage="http://www.w3.org/1999/XPath"targetNamespace="http://www.flowable.org/processdef"><process id="holidayRequest" name="Holiday Request" isExecutable="true"><startEvent id="startEvent"/><sequenceFlow sourceRef="startEvent" targetRef="approveTask"/><userTask id="approveTask" name="Approve or reject request"/><sequenceFlow sourceRef="approveTask" targetRef="decision"/><exclusiveGateway id="decision"/><sequenceFlow sourceRef="decision" targetRef="externalSystemCall"><conditionExpression xsi:type="tFormalExpression">conditionExpression>sequenceFlow><sequenceFlow sourceRef="decision" targetRef="sendRejectionMail"><conditionExpression xsi:type="tFormalExpression">conditionExpression>sequenceFlow><serviceTask id="externalSystemCall" name="Enter holidays in external system"flowable:class="org.flowable.CallExternalSystemDelegate"/><sequenceFlow sourceRef="externalSystemCall" targetRef="holidayApprovedTask"/><userTask id="holidayApprovedTask" name="Holiday approved"/><sequenceFlow sourceRef="holidayApprovedTask" targetRef="approveEnd"/><serviceTask id="sendRejectionMail" name="Send out rejection email"flowable:class="org.flowable.SendRejectionMail"/><sequenceFlow sourceRef="sendRejectionMail" targetRef="rejectEnd"/><endEvent id="approveEnd"/><endEvent id="rejectEnd"/>process>definitions>
现在我们已经有了流程BPMN 2.0 XML文件，下来需要将它***部署()***到引擎中。部署一个流程定义意味着：
将流程定义部署至引擎，需要使用，其可以从对象获取。使用，可以通过XML文件的路径创建一个新的部署()，并调用*()*方法实际执行：
/*** 部署流程*/@Testpublic void testDeploy(){// 配置数据库相关信息 获取 ProcessEngineConfigurationProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration().setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn2?serverTimezone=UTC&nullCatalogMeansCurrent=true").setJdbcUsername("root").setJdbcPassword("123456").setJdbcDriver("com.mysql.cj.jdbc.Driver").setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);// 获取流程引擎对象ProcessEngine processEngine = cfg.buildProcessEngine();// 部署流程 获取RepositoryService对象RepositoryService repositoryService = processEngine.getRepositoryService();Deployment deployment = repositoryService.createDeployment()// 创建Deployment对象.addClasspathResource("holiday-request.bpmn20.xml") // 添加流程部署文件.name("请求流程") // 设置部署流程的名称.deploy(); // 执行部署操作System.out.println("deployment.getId() = " + deployment.getId());System.out.println("deployment.getName() = " + deployment.getName());}
然后执行该方法日志操作成功：
在后台表结构也可以看到相关的信息。
: 流程定义部署表，每部署一次就增加一条记录。
：流程定义表，部署每个新的流程定义都会在这张表中增加一条记录
：流程资源表，流程部署的 bpmn文件和png图片会保存在该表中
我们现在可以通过API查询验证流程定义已经部署在引擎中（并学习一些API）。通过创建的ry对象实现。
/*** 查看流程定义*/@Testpublic void testDeployQuery(){// 配置数据库相关信息 获取 ProcessEngineConfigurationProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration().setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn2?serverTimezone=UTC&nullCatalogMeansCurrent=true").setJdbcUsername("root").setJdbcPassword("123456").setJdbcDriver("com.mysql.cj.jdbc.Driver").setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);// 获取流程引擎对象ProcessEngine processEngine = cfg.buildProcessEngine();// 部署流程 获取RepositoryService对象RepositoryService repositoryService = processEngine.getRepositoryService();// 获取流程定义对象ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().deploymentId("2501").singleResult();System.out.println("processDefinition.getId() = " + processDefinition.getId());System.out.println("processDefinition.getName() = " + processDefinition.getName());System.out.println("processDefinition.getDeploymentId() = " + processDefinition.getDeploymentId());System.out.println("processDefinition.getDescription() = " + processDefinition.getDescription());}
输出结果为：
processDefinition.getId() = holidayRequest:2:2503
processDefinition.getName() = Holiday Request
processDefinition.getDeploymentId() = 2501
processDefinition.getDescription() = null
3.3 启动流程实例
msp;现在已经在流程引擎中部署了流程定义，因此可以使用这个流程定义作为“模板”启动流程实例。
要启动流程实例，需要提供一些初始化流程变量。一般来说，可以通过呈现给用户的表单，或者在流程由其他系统自动触发时通过REST API，来获取这些变量。在这个例子里，我们简化直接在代码中定义了，我们使用启动一个流程实例。
/*** 启动流程实例*/@Testpublic void testRunProcess(){// 配置数据库相关信息 获取 ProcessEngineConfigurationProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration().setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn2?serverTimezone=UTC&nullCatalogMeansCurrent=true").setJdbcUsername("root").setJdbcPassword("123456").setJdbcDriver("com.mysql.cj.jdbc.Driver").setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);// 获取流程引擎对象ProcessEngine processEngine = cfg.buildProcessEngine();// 启动流程实例通过 RuntimeService 对象RuntimeService runtimeService = processEngine.getRuntimeService();// 构建流程变量Map<String,Object> variables = new HashMap<>();variables.put("employee","张三") ;// 谁申请请假variables.put("nrOfHolidays",3); // 请几天假variables.put("description","工作累了，想出去玩玩"); // 请假的原因// 启动流程实例，第一个参数是流程定义的idProcessInstance processInstance = runtimeService.startProcessInstanceByKey("holidayRequest", variables);// 启动流程实例// 输出相关的流程实例信息System.out.println("流程定义的ID：" + processInstance.getProcessDefinitionId());System.out.println("流程实例的ID：" + processInstance.getId());System.out.println("当前活动的ID：" + processInstance.getActivityId());}
启动成功，输出结果如下：
流程定义的ID：holidayRequest:2:2503
流程实例的ID：5001
当前活动的ID：null
对应的流程实例ID为：5001
启动流程实例涉及到的表结构：
3.4 查看任务
上面员工发起了一个请假流程，接下来就会流转到总经理这儿来处理，之前我们没有指定经理这的处理人，我们可以加一个
然后我们来查看下lisi的任务
/*** 查看任务*/@Testpublic void testQueryTask(){// 配置数据库相关信息 获取 ProcessEngineConfigurationProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration().setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn2?serverTimezone=UTC&nullCatalogMeansCurrent=true").setJdbcUsername("root").setJdbcPassword("123456").setJdbcDriver("com.mysql.cj.jdbc.Driver").setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);// 获取流程引擎对象ProcessEngine processEngine = cfg.buildProcessEngine();TaskService taskService = processEngine.getTaskService();List<Task> list = taskService.createTaskQuery().processDefinitionKey("holidayRequestNew").taskAssignee("lisi").list();for (Task task : list) {System.out.println("task.getProcessDefinitionId() = " + task.getProcessDefinitionId());System.out.println("task.getId() = " + task.getId());System.out.println("task.getAssignee() = " + task.getAssignee());System.out.println("task.getName() = " + task.getName());}}
输出结果为：
task.getProcessDefinitionId() = holidayRequestNew:1:10003
task.getId() = 12508
task.getAssignee() = lisi
task.getName() = Approve or reject request
3.5 完成任务
现在李四这个角色可以来完成当前的任务了
emsp;在此处我们直接解决掉这个请假，然后会走发送拒绝邮件的流程，这块我们需要用到来触发。
我们定义这样一个Java类
public class SendRejectionMail implements JavaDelegate {/*** 触发发送邮件的操作* @param delegateExecution*/@Overridepublic void execute(DelegateExecution delegateExecution) {System.out.println("请假被拒绝,,,安心工作吧");}
}
然后来完成任务
/*** 完成任务*/@Testpublic void testCompleteTask(){// 配置数据库相关信息 获取 ProcessEngineConfigurationProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration().setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn2?serverTimezone=UTC&nullCatalogMeansCurrent=true").setJdbcUsername("root").setJdbcPassword("123456").setJdbcDriver("com.mysql.cj.jdbc.Driver").setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);// 获取流程引擎对象ProcessEngine processEngine = cfg.buildProcessEngine();TaskService taskService = processEngine.getTaskService();Task task = taskService.createTaskQuery().processDefinitionKey("holidayRequestNew").taskAssignee("lisi").singleResult();// 添加流程变量Map<String,Object> variables = new HashMap<>();variables.put("approved",false); // 拒绝请假// 完成任务taskService.complete(task.getId(),variables);}
然后可以看到触发了
3.6 流程的删除
有些流程已经没有用了，我们需要删除掉，其实也非常简单
/*** 删除流程*/@Testpublic void testDeleteProcess(){// 配置数据库相关信息 获取 ProcessEngineConfigurationProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration().setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn2?serverTimezone=UTC&nullCatalogMeansCurrent=true").setJdbcUsername("root").setJdbcPassword("123456").setJdbcDriver("com.mysql.cj.jdbc.Driver").setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);// 获取流程引擎对象ProcessEngine processEngine = cfg.buildProcessEngine();RepositoryService repositoryService = processEngine.getRepositoryService();// 删除流程定义，如果该流程定义已经有了流程实例启动则删除时报错// repositoryService.deleteDeployment("1");// 设置为TRUE 级联删除流程定义，及时流程有实例启动，也可以删除，设置为false 非级联删除操作。repositoryService.deleteDeployment("2501",true);}
3.7 查看历史信息
emsp; 选择使用这样的流程引擎的原因之一，是它可以自动存储所有流程实例的审计数据或历史数据。这些数据可以用于创建报告，深入展现组织运行的情况，瓶颈在哪里，等等。
例如，如果希望显示流程实例已经执行的时间，就可以从获取，并创建*历史活动( )*的查询。在下面的代码片段中，可以看到我们添加了一些额外的过滤条件：
结果按照结束时间排序，代表其执行顺序。
/*** 查看历史*/@Testpublic void testQueryHistory(){// 配置数据库相关信息 获取 ProcessEngineConfigurationProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration().setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn2?serverTimezone=UTC&nullCatalogMeansCurrent=true").setJdbcUsername("root").setJdbcPassword("123456").setJdbcDriver("com.mysql.cj.jdbc.Driver").setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);// 获取流程引擎对象ProcessEngine processEngine = cfg.buildProcessEngine();HistoryService historyService = processEngine.getHistoryService();List<HistoricActivityInstance> list = historyService.createHistoricActivityInstanceQuery().processDefinitionId("holidayRequestNew:1:10003").finished().orderByHistoricActivityInstanceEndTime().asc().list();for (HistoricActivityInstance historicActivityInstance : list) {System.out.println(historicActivityInstance.getActivityId() + " took "+ historicActivityInstance.getDurationInMillis() + " milliseconds");}}
输出结果
startEvent took 1 milliseconds
approveTask took 837735 milliseconds
decision took 13 milliseconds
sendRejectionMail took 2 milliseconds
rejectEnd took 1 milliseconds
好了~的基本应用我们就先介绍到这里了。
四：基础表结构 4.1 表结构讲解
工作流程的相关操作都是操作存储在对应的表结构中，为了能更好的弄清楚的实现原理和细节，我们有必要先弄清楚的相关表结构及其作用。在中的表结构在初始化的时候会创建五类表结构，具体如下：
4.2 讲解 4.2.1 硬编码的方式
我们前面讲解案例的时候是通过这个配置类来加载的。
// 配置数据库相关信息 获取 ProcessEngineConfiguration
ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration().setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn2?serverTimezone=UTC&nullCatalogMeansCurrent=true").setJdbcUsername("root").setJdbcPassword("123456").setJdbcDriver("com.mysql.cj.jdbc.Driver").setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
// 获取流程引擎对象
ProcessEngine processEngine = cfg.buildProcessEngine();
这种方式会调用()方法，里面的核心代码为：
4.2.2 配置文件
除了上面的硬编码的方式外，我们还可以在目录下创建一个.cfg.xml文件，注意这个名称是固定的哦。内容如下：
<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="processEngineConfiguration"class="org.flowable.engine.impl.cfg.StandaloneProcessEngineConfiguration"><property name="jdbcUrl" value="jdbc:mysql://localhost:3306/flow1?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC&nullCatalogMeansCurrent=true" /><property name="jdbcDriver" value="com.mysql.cj.jdbc.Driver" /><property name="jdbcUsername" value="root" /><property name="jdbcPassword" value="123456" /><property name="databaseSchemaUpdate" value="true" /><property name="asyncExecutorActivate" value="false" />bean>
beans>
在上面的配置文件中配置相关的信息。我们在Java代码中就可以简化为：
@Testpublic void test01(){// 获取流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();System.out.println("processEngine = " + processEngine);}
可以看下ine的源码，在里面最终还是执行了和硬编码一样的代码
public static ProcessEngine getProcessEngine(String processEngineName) {if (!isInitialized()) {init(); // 完成初始化操作}return processEngines.get(processEngineName);}
进入init方法
public static synchronized void init() {if (!isInitialized()) {if (processEngines == null) {// Create new map to store process-engines if current map is nullprocessEngines = new HashMap<>();}ClassLoader classLoader = ReflectUtil.getClassLoader();Enumeration<URL> resources = null;try {resources = classLoader.getResources("flowable.cfg.xml"); // 加载flowable.cfg.xml配置文件} catch (IOException e) {throw new FlowableIllegalArgumentException("problem retrieving flowable.cfg.xml resources on the classpath: " + System.getProperty("java.class.path"), e);}// Remove duplicated configuration URL's using set. Some// classloaders may return identical URL's twice, causing duplicate// startupsSet<URL> configUrls = new HashSet<>();while (resources.hasMoreElements()) {configUrls.add(resources.nextElement());}for (Iterator<URL> iterator = configUrls.iterator(); iterator.hasNext();) {URL resource = iterator.next();LOGGER.info("Initializing process engine using configuration '{}'", resource.toString());initProcessEngineFromResource(resource); // 初始化ProcessEngine}try {resources = classLoader.getResources("flowable-context.xml"); // 在整合Spring的情况下加载该文件} catch (IOException e) {throw new FlowableIllegalArgumentException("problem retrieving flowable-context.xml resources on the classpath: " + System.getProperty("java.class.path"), e);}while (resources.hasMoreElements()) {URL resource = resources.nextElement();LOGGER.info("Initializing process engine using Spring configuration '{}'", resource.toString());initProcessEngineFromSpringResource(resource); // 从Spring的资源文件中完成ProcessEngine的初始化}setInitialized(true);} else {LOGGER.info("Process engines already initialized");}}
在源码中提供了单独使用好整合的配置加载方式。再进入到()方法中：
而且我们也可以看到最终的实现是 对象。
4.2.3 自定义配置文件
最后我们如果要加载自定义名称的配置文件可以通过中的对应构造方法来实现
@Testpublic void test2() throws Exception{ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("flowable.cfg.xml");ProcessEngine processEngine = configuration.buildProcessEngine();System.out.println("processEngine = " + processEngine);}
4.3 服务接口
是工作流引擎提供用于进行工作流部署、执行、管理的服务接口，我们使用这些接口可以就是操作服务对应的数据表
4.3.1 创建方式
通过创建
方式如下：
RuntimeService runtimeService = processEngine.getRuntimeService();
RepositoryService repositoryService = processEngine.getRepositoryService();
TaskService taskService = processEngine.getTaskService();
// ...
4.3.2 总览
简单介绍：
是的资源管理类，提供了管理和控制流程发布包和流程定义的操作。使用工作流建模工具设计的业务流程图需要使用此将流程定义文件的内容部署到计算机。
除了部署流程定义以外还可以：查询引擎中的发布包和流程定义。
暂停或激活发布包，对应全部和特定流程定义。 暂停意味着它们不能再执行任何操作了，激活是对应的反向操作。获得多种资源，像是包含在发布包里的文件， 或引擎自动生成的流程图。
获得流程定义的pojo版本， 可以用来通过java解析流程，而不必通过xml。
的流程运行管理类。可以从这个服务类中获取很多关于流程执行相关的信息
的任务管理类。可以从这个类中获取任务的信息。
的历史管理类，可以查询历史信息，执行流程时，引擎会保存很多数据（根据配置），比如流程实例启动时间，任务的参与者， 完成任务的时间，每个流程实例的执行路径，等等。 这个服务主要通过查询功能来获得这些数据。
的引擎管理类，提供了对 流程引擎的管理和维护功能，这些功能不在工作流驱动的应用程序中使用，主要用于 系统的日常维护。
4.4 图标介绍
BPMN 2.0是业务流程建模符号2.0的缩写。它由 这个非营利协会创建并不断发展。作为一种标识，BPMN 2.0是使用一些符号来明确业务流程设计流程图的一整套符号规范，它能增进业务建模时的沟通效率。目前BPMN2.0是最新的版本，它用于在BPM上下文中进行布局和可视化的沟通。接下来我们先来了解在流程设计中常见的 符号。
BPMN2.0的基本符合主要包含：
4.4.1 事件图标
emsp;在中的事件图标启动事件，边界事件,中间事件和结束事件.
4.4.2 活动(任务)图标
活动是工作或任务的一个通用术语。一个活动可以是一个任务，还可以是一个当前流程的子处理流程； 其次，你还可以为活动指定不同的类型。常见活动如下:
4.4.3 网关图标
emsp; 网关用来处理决策，有几种常用网关需要了解：
4.5 流程部署详解 4.5.1 部署实现
我们先来看下流程部署的具体过程。代码实现
/*** 部署流程*/@Testpublic void test3(){ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RepositoryService repositoryService = processEngine.getRepositoryService();Deployment deploy = repositoryService.createDeployment().addClasspathResource("holiday-request-new.bpmn20.xml").name("请假流程...").category("请假") // 分类.tenantId("dpb") // 租户id.deploy();System.out.println("deploy.getId() = " + deploy.getId());System.out.println("deploy.getName() = " + deploy.getName());System.out.println("deploy.getCategory() = " + deploy.getCategory());}
4.5.2 部署涉及表结构
涉及到的三张表：
部署资源表：
部署ID表：
流程表：
注意：
业务流程定义数据表。此表和是多对一的关系，即，一个部署的bar包里可能包含多个流程定义文件，每个流程定义文件都会有一条记录在表内，每个流程定义的数据，都会对于表内的一个资源文件和PNG图片文件。和的关联是通过程序用.NAME与.NAME_完成的
4.5.3 挂起和激活
emsp; 部署的流程默认的状态为激活，如果我们暂时不想使用该定义的流程，那么可以挂起该流程。当然该流程定义下边所有的流程实例全部暂停。
流程定义为挂起状态，该流程定义将不允许启动新的流程实例，同时该流程定义下的所有的流程实例都将全部挂起暂停执行。
/*** 挂起流程*/@Testpublic void test05(){// 获取流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();RepositoryService repositoryService = processEngine.getRepositoryService();ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId("holiday:1:4").singleResult();// 获取流程定义的状态boolean suspended = processDefinition.isSuspended();System.out.println("suspended = " + suspended);if(suspended){// 表示被挂起System.out.println("激活流程定义");repositoryService.activateProcessDefinitionById("holiday:1:4",true,null);}else{// 表示激活状态System.out.println("挂起流程");repositoryService.suspendProcessDefinitionById("holiday:1:4",true,null);}}
具体的实现其实就是更新了流程定义表中的字段
而且通过REV_字段来控制数据安全，也是一种乐观锁的体现了，如果要启动一个已经挂起的流程就会出现如下的错误
4.6 启动流程实例
然后我们来看看启动流程实例的过程。实现代码如下：
/*** 启动流程实例*/@Testpublic void testRunProcess(){// 获取流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();// 启动流程实例通过 RuntimeService 对象RuntimeService runtimeService = processEngine.getRuntimeService();// 构建流程变量Map<String,Object> variables = new HashMap<>();variables.put("employee","张三") ;// 谁申请请假variables.put("nrOfHolidays",3); // 请几天假variables.put("description","工作累了，想出去玩玩"); // 请假的原因// 启动流程实例，第一个参数是流程定义的idProcessInstance processInstance = runtimeService.startProcessInstanceById("holiday:1:4", variables);// 启动流程实例// 输出相关的流程实例信息System.out.println("流程定义的ID：" + processInstance.getProcessDefinitionId());System.out.println("流程实例的ID：" + processInstance.getId());System.out.println("当前活动的ID：" + processInstance.getActivityId());}
4.7 处理流程
上面的流程已经流转到了这个用户这里，然后可以开始审批了
// 获取流程引擎对象ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();TaskService taskService = processEngine.getTaskService();Task task = taskService.createTaskQuery().processDefinitionId("holiday:1:4").taskAssignee("zhangsan").singleResult();// 添加流程变量Map<String,Object> variables = new HashMap<>();variables.put("approved",false); // 拒绝请假// 完成任务taskService.complete(task.getId(),variables);
在正常处理流程中涉及到的表结构
当然流程实例也可以挂起
// 1.获取ProcessEngine对象
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 2.获取RuntimeService
RuntimeService runtimeService = engine.getRuntimeService();
// 3.获取流程实例对象
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId("25001").singleResult();
// 4.获取相关的状态操作
boolean suspended = processInstance.isSuspended();
String id = processInstance.getId();
if(suspended){// 挂起--》激活runtimeService.activateProcessInstanceById(id);System.out.println("流程定义：" + id + "，已激活");
}else{// 激活--》挂起runtimeService.suspendProcessInstanceById(id);System.out.println("流程定义：" + id + "，已挂起");
}
4.8 完成一个流程
emsp; 然后我们把第一个流程处理完成
ProcessEngine processEngine = cfg.buildProcessEngine();
TaskService taskService = processEngine.getTaskService();
Task task = taskService.createTaskQuery().processDefinitionId("holiday:1:4").taskAssignee("lisi").singleResult();
// 添加流程变量
Map<String,Object> variables = new HashMap<>();
variables.put("approved",false); // 拒绝请假
// 完成任务
taskService.complete(task.getId(),variables);
处理完了一个工作流程后，我们来看看相关的表结构信息
首先我们会发现
这四张表中对应的数据都没有了，也就是这个流程已经不是运行中的流程了。然后在对应的历史表中我们可以看到相关的信息
