Flowable6-整合Spring

Posted 2023-03-22

参考技术A

ProcessEngine 可配置为一个普通的Spring bean. 整合的时候我们需要用到 org.flowable.spring.ProcessEngineFactoryBean 类.

请注意, 这个 processEngineConfigurationbean 现在使用的是 org.flowable.spring.SpringProcessEngineConfiguration 类.

下面是我们在这个例子中使用的Spring配置文件. 显示的部分包含dataSource, transactionManager, processEngine和Flowable引擎服务.

将DataSource传递给SpringProcessEngineConfiguration时, Flowable在
org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy 内部使用包装传递的DataSource.

这样做是为了确保从DataSource和Spring事务检索到的SQL能够很好地协同工作. 这意味着它不再需要代理的数据源自己可以在Spring中配置.

虽然它仍然可能通过一个 TransactionAwareDataSourceProxy 进入 SpringProcessEngineConfiguration .

当使用 ProcessEngineFactoryBean 时, 默认情况下, BPMN进程中的所有表达式将看到所有的Spring bean. 可以使用配置映射来限制要在表达式中显示的bean(甚至没有)

为了让所有的bean都不暴露, 只需在 SpringProcessEngineConfiguration 上传递一个空的列表作为beans属性. 当没有设置bean属性时, 上下文中的所有Spring bean都将可用.

现在, 可以在表达式中使用暴露的bean: 例如, hello.bpmn20.xml
显示了如何使用UEL方法表达式来调用Spring bean上的方法:

Spring集成还具有用于部署资源的特殊功能. 在流程引擎配置中, 您可以指定一组资源. 在创建流程引擎时, 所有这些资源都将被扫描和部署.

有适当的过滤, 防止重复部署. 只有当资源实际发生变化时, 才会重新部署到Flowable DB.

默认情况下, 上面的配置会将与过滤器匹配的所有资源归入到Flowable引擎的单个部署中. 重复过滤防止重新部署不变的资源适用于整个部署.

在某些情况下, 这可能不是你想要的. 例如, 如果以这种方式部署一组流程资源, 并且这些资源中只有一个流程定义发生了变化, 则整个部署将被视为新的, 并且该部署中的所有流程定义将被重新部署.

为了能够自定义部署方式, 你可以指定一个附加属性 SpringProcessEngineConfiguration, deploymentMode . 该属性定义了部署将从匹配过滤器的一组资源中查找. 这个属性默认支持3个值:
default : 将所有资源分组到一个部署中, 并对该部署重复过滤. 这是默认值.

single-resource : 为每个单独的资源创建一个单独的部署, 并对该部署重复过滤. 这时您将每个流程定义分开部署, 并且只有在流程定义版本已更改时才创建新流程定义版本.

resource-parent-folder : 为共享相同父文件夹的资源创建单独的部署, 并对该部署重复过滤. 可以使用此值为大多数资源创建单独的部署，但仍可以通过将其放置在共享文件夹中对其进行分组。以下是如何指定single-resource配置的示例deploymentMode：

Flowable入门系列文章14 - 整合Spring 01

你肯定可以地使用Flowable without Spring，但是我们会介绍一些非常好的集成特性。

1、ProcessEngineFactoryBean

该ProcessEngine可配置为一个普通的Spring bean。整合的起点是班级org.flowable.spring.ProcessEngineFactoryBean。该bean采用流程引擎配置并创建流程引擎。这意味着Spring的属性的创建和配置与配置部分中记录的相同。对于Spring集成，配置和引擎bean将如下所示：

<bean id="processEngineConfiguration" class="org.flowable.spring.SpringProcessEngineConfiguration">
...
</bean>
<bean id="processEngine" class="org.flowable.spring.ProcessEngineFactoryBean">
<property name="processEngineConfiguration" ref="processEngineConfiguration" />
</bean>

请注意，这个processEngineConfigurationbean现在使用这个org.flowable.spring.SpringProcessEngineConfiguration类。

2、交易

我们将SpringTransactionIntegrationTest逐步解释在Spring的例子中发现的分布。下面是我们在这个例子中使用的Spring配置文件（你可以在SpringTransactionIntegrationTest-context.xml中找到它）。下面显示的部分包含dataSource，transactionManager，processEngine和Flowable引擎服务。

将DataSource传递给SpringProcessEngineConfiguration（使用属性“dataSource”）时，Flowable在
org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy内部使用包装传递的DataSource。这样做是为了确保从
DataSource和Spring事务检索到的SQL连接能够很好地协同工作。这意味着它不再需要代理的数据源自己在Spring的配置，虽然它仍然可能通过一个TransactionAwareDataSourceProxy进入SpringProcessEngineConfiguration。在这种情况下，不会发生额外的包装。

确保TransactionAwareDataSourceProxy在Spring配置中声明自己并不是将它用于已经知道Spring事务的资源（例如
DataSourceTransactionManager和JPATransactionManager需要未经代理的数据源）。

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
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
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
<bean id="dataSource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
<property name="driverClass" value="org.h2.Driver" />
<property name="url" value="jdbc:h2:mem:flowable;DB_CLOSE_DELAY=1000" />
<property name="username" value="sa" />
<property name="password" value="" />
</bean>
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
<bean id="processEngineConfiguration" class="org.flowable.spring.SpringProcessEngineConfiguration">
<property name="dataSource" ref="dataSource" />
<property name="transactionManager" ref="transactionManager" />
<property name="databaseSchemaUpdate" value="true" />
<property name="asyncExecutorActivate" value="false" />
</bean>
<bean id="processEngine" class="org.flowable.spring.ProcessEngineFactoryBean">
<property name="processEngineConfiguration" ref="processEngineConfiguration" />
</bean>
<bean id="repositoryService" factory-bean="processEngine" factory-method="getRepositoryService" />
<bean id="runtimeService" factory-bean="processEngine" factory-method="getRuntimeService" />
<bean id="taskService" factory-bean="processEngine" factory-method="getTaskService" />
<bean id="historyService" factory-bean="processEngine" factory-method="getHistoryService" />
<bean id="managementService" factory-bean="processEngine" factory-method="getManagementService" />
...

这个Spring配置文件的其余部分包含了我们在这个特例中使用的bean和配置：

<beans>
...
<tx:annotation-driven transaction-manager="transactionManager"/>
<bean id="userBean" class="org.flowable.spring.test.UserBean">
<property name="runtimeService" ref="runtimeService" />
</bean>
<bean id="printer" class="org.flowable.spring.test.Printer" />
</beans>

首先，应用程序上下文是使用Spring支持的任何方式创建的。在这个例子中，您可以使用类路径XML资源来配置我们的Spring应用程序上下文：

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"org/flowable/examples/spring/SpringTransactionIntegrationTest-context.xml");

或者，用这个方法试一试：

@ContextConfiguration(
"classpath:org/flowable/spring/test/transaction/SpringTransactionIntegrationTest-context.xml")

然后我们可以得到服务bean并调用它们的方法。ProcessEngineFactoryBean将向Flowable服务方法上应用Propagation.REQUIRED事务语义的服务添加一个额外的拦截器。所以，例如，我们可以使用repositoryService像这样部署一个进程：

RepositoryService repositoryService =
(RepositoryService) applicationContext.getBean("repositoryService");
String deploymentId = repositoryService
.createDeployment()
.addClasspathResource("org/flowable/spring/test/hello.bpmn20.xml")
.deploy()
.getId();

反过来也可以。在这种情况下，Spring事务将在userBean.hello（）方法的周围，并且Flowable服务方法调用将加入同一个事务。

UserBean userBean = (UserBean) applicationContext.getBean("userBean");
userBean.hello();

UserBean看起来像这样。请记住，从上面的Spring bean配置中，我们将repositoryService注入到userBean中。

public class UserBean {
/** injected by Spring */
private RuntimeService runtimeService;
@Transactional
public void hello() {
// here you can do transactional stuff in your domain model
// and it will be combined in the same transaction as
// the startProcessInstanceByKey to the Flowable RuntimeService
runtimeService.startProcessInstanceByKey("helloProcess");
} p
ublic void setRuntimeService(RuntimeService runtimeService) {
this.runtimeService = runtimeService;
}
}

上面文章来自盘古BPM研究院：http://vue.pangubpm.com/
文章翻译提交：https://github.com/qiudaoke/flowable-userguide
了解更多文章可以关注微信公众号：