Activiti工作流引擎配置

用户2377824719262024-06-04 11:49

工作流引擎对象ProcessEngine 和其配置对象ProcessEngineConfiguration都是Activiti的核心

对象。Activiti工作流引擎启动时，需要经过以下两个步骤：

  • 创建一个工作流引擎配置对象ProcessEngineConfiguration对工作流引擎进行配置；

  • 通过工作流引擎配置对象创建工作流引擎对象ProcessEngine。

工作流引擎配置对象ProcessEngineConfiguration

在Activiti工作流引擎中，需要进行很多参数配置，如数据库配置、事务配置、工作流引擎内置服务配置 等，Activiti通过工作流引擎配置对象封装这些配置。工作流引擎配置对象ProcessEngineConfiguration存储Activiti工作流引擎的全部配置，代表Activiti的一个配置实例，通过该类提供的setter()和getter()方法可以对工作流引擎的可配置属性进行配置和获取。ProcessEngineConfiguration本身是一个抽象类，它与子类的结构图如图所示。

ProcessEngineConfiguration是所有配置类的父类，有一个ProcessEngineConfigurationImpl子类（这个子类也是抽象类）。ProcessEngineConfigurationImpl有4个直接子类，分别如下。

org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration ：标准工作流引擎配置类。使用该类 作为配置对象，工作流引擎处于独立环境下时，Activiti将会对数据库事务进行管理。默认情况下， 工作流引擎启动时会检查数据库结构及版本是否正确。 org.activiti.spring.SpringProcessEngineConfiguration ：Spring环境工作流引擎配置类。当Activiti与Spring 整合时，可以使用该类。它提供了以下重要功能：创建工作流引擎实例对象，在工作流引擎启动后 自动部署配置的流程文档（需要设置），设置工作流引擎连接的数据源、事务管理器等。这是常用的 一种配置方式，由Spring代理创建工作流引擎和管理数据库事务。将Activiti引擎嵌入业务系统，可以 实现业务系统事务与Activiti引擎事务的统一管理。 org.activiti.engine.impl.cfg.JtaProcessEngineConfiguration ：JTA工作流引擎配置类。该类不使用Activiti 管理事务，而是使用JTA管理事务。 org.activiti.engine.impl.cfg.multitenant.MultiSchemaMultiTenantProcessEngineConfiguration：多数据库多 租户工作流引擎配置类。Activiti通过此类提供自动路由机制，当工作流引擎需要连接多个数据库时， 客户端无须关心工作流引擎要连接哪个数据库，该类会通过路由规则自动选择需要操作的数据库， 且数据库操作对客户端透明，客户端无须关心其内部路由实现机制。

其中，StandaloneProcessEngineConfiguration类有一个子类org.activiti.engine.impl.cfg.StandaloneInMemProcessEngineConfiguration，适用于单元测试，默认采用H2数据库存储数据，由Acitviti处理事务。

ProcessEngineConfiguration类提供了多个创建该类对象的静态方法：

  •  ProcessEngineConfiguration createProcessEngineConfigurationFromResourceDefault()；
  •  ProcessEngineConfiguration createProcessEngineConfigurationFromResource(String resource)；
  •  ProcessEngineConfiguration createProcessEngineConfigurationFromResource(String resource, String beanName)；
  •  ProcessEngineConfiguration createProcessEngineConfigurationFromInputStream(InputStream inputStream)；
  •  ProcessEngineConfiguration createProcessEngineConfigurationFromInputStream(InputStream inputStream,
  • String beanName)；
  •  ProcessEngineConfiguration createStandaloneProcessEngineConfiguration()；
  •  ProcessEngineConfiguration createStandaloneInMemProcessEngineConfiguration()。 这些方法会读取和解析相应的配置文件，并通过该类中的setter()和getter()方法对工作流引擎配置对象进 行配置和获取，然后返回该对象的实例。
scss 复制代码 
1．createProcessEngineConfigurationFromResourceDefault()方法

该方法通过加载默认配置文件来创建工作流引擎配置对象，源码如下：

public static ProcessEngineConfiguration

createProcessEngineConfigurationFromResourceDefault() {

return createProcessEngineConfigurationFromResource("activiti.cfg.xml",

"processEngineConfiguration");

}

从上述源码可知，该方法默认加载classpath下的activiti.cfg.xml文件，该文件是Spring环境的bean配置文

件，利用Spring的依赖注入，获取名称为processEngineConfiguration的bean实例。activiti.cfg.xml配置文件相关

内容将在后面节介绍。

采用默认方式创建工作流引擎配置对象的示例代码如下：

public void testCreateFromResourceDefault() {

ProcessEngineConfiguration processEngineConfigurationFromResourceDefault =

ProcessEngineConfiguration.createProcessEngineConfigurationFromResourceDefault();

System.out.println(processEngineConfigurationFromResourceDefault);

}

2．createProcessEngineConfigurationFromResource()方法

该方法通过加载自定义配置文件来创建一个工作流引擎配置对象，源码如下：

public static ProcessEngineConfiguration

createProcessEngineConfigurationFromResource(String resource, String beanName) {

return 

BeansConfigurationHelper.parseProcessEngineConfigurationFromResource(resource, beanName);

}

从上述源码可知，该方法并非加载默认配置文件activiti.cfg.xml，而是加载指定的配置文件，并获取给定

名称的bean从而创建一个工作流引擎配置对象。该方法有两个参数，一个是文件名称的字符串参数，另一个是

通过指定配置文件完成依赖注入的对象的名称字符串。其在org.activiti.engine.impl.cfg.BeansConfigurationHelper

类中实现，源代码如下：

public static ProcessEngineConfiguration

parseProcessEngineConfigurationFromResource(String resource, String beanName) {

Resource springResource = new ClassPathResource(resource);

return parseProcessEngineConfiguration(springResource, beanName);

}

public static ProcessEngineConfiguration parseProcessEngineConfiguration(Resource

springResource, String beanName) {

DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

XmlBeanDefinitionReader xmlBeanDefinitionReader = new

XmlBeanDefinitionReader(beanFactory);

xmlBeanDefinitionReader.setValidationMode(XmlBeanDefinitionReader.VALIDATION_XSD);

xmlBeanDefinitionReader.loadBeanDefinitions(springResource);

ProcessEngineConfigurationImpl processEngineConfiguration =

(ProcessEngineConfigurationImpl) beanFactory.getBean(beanName);

processEngineConfiguration.setBeans(new SpringBeanFactoryProxyMap(beanFactory));

return processEngineConfiguration;

}

从以上代码段可知，这种加载方法的实现步骤如下。

（1）使用ClassPathResource访问classpath下根据resource参数指定的配置文件，将其转换成Resource对象。

（2）通过XmlBeanDefinitionReader设置一个BeanDefinitionRegistry子类DefaultListableBeanFactory，作为

Spring的beanFactory。

（3）通过XmlBeanDefinitionReader加载由配置文件转换得到的Resource对象。

（4）在beanFactory中通过参数beanName获取processEngineConfiguration的实例，并将beanFactory赋给

processEngineConfiguration。

通过以上4步操作，Activiti通过Spring完成了ProcessEngineConfiguration类的配置、加载和获取，在

processEngineConfiguration中可以通过beanFactory直接获取配置文件中的bean。这种加载方式的好处是

Activiti可以对自身的工作流引擎配置信息进行单独管理，不受其他Spring配置文件的干扰，实现了配置文件

管理的隔离。

此外，ProcessEngineConfiguration还提供了createProcessEngineConfigurationFromResource(String resource)

方法：

public static ProcessEngineConfiguration

createProcessEngineConfigurationFromResource(String resource) {

return createProcessEngineConfigurationFromResource(resource,

"processEngineConfiguration");

}

该方法默认加载classpath下指定的XML配置文件，传入String类型的resource参数，指定bean为

processEngineConfiguration的ProcessEngineConfiguration实例。

通过读取自定义配置文件创建工作流引擎配置对象的示例代码如下：

public void testCreateFromResource() {

ProcessEngineConfiguration processEngineConfigurationFromResource =

ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(

"resource/my-config.xml","myProcessEngineConfiguration");

System.out.println(processEngineConfigurationFromResource);

}

由以上代码段可知，Activiti会在classpath下查找my-config.xml配置文件，并创建一个名为myProcess

EngineConfiguration的工作流引擎配置对象。

3．createProcessEngineConfigurationFromInputStream()方法

该方法基于配置文件输入流创建工作流引擎配置对象。这种方法不再限制Activiti必须将配置文件放在

classpath下，可以通过输入流加载任意路径下的配置文件，从而创建ProcessEngineConfiguration实例。其源

码中也提供了两种createProcessEngineConfigurationFromInputStream()方法，代码如下：

public static ProcessEngineConfiguration

createProcessEngineConfigurationFromInputStream(InputStream inputStream) {

return createProcessEngineConfigurationFromInputStream(inputStream,

"processEngineConfiguration");

}

public static ProcessEngineConfiguration

createProcessEngineConfigurationFromInputStream(InputStream inputStream, String beanName) {

return

BeansConfigurationHelper.parseProcessEngineConfigurationFromInputStream(

inputStream, beanName);

}

第1种方法只需传入配置文件输入流，默认获取一个名为processEngineConfiguration的ProcessEngineConfiguration

实例。第2种方法不仅可传入配置文件输入流，还可传入指定beanName的ProcessEngineConfiguration实例。其

在org.activiti.engine.impl.cfg.BeansConfigurationHelper类中实现，源代码如下：

public static ProcessEngineConfiguration

parseProcessEngineConfigurationFromInputStream(InputStream inputStream, String beanName) {

Resource springResource = new InputStreamResource(inputStream);

return parseProcessEngineConfiguration(springResource, beanName);

}

由以上代码段可知，该方法先将输入流转换为Resource对象，然后调用parseProcessEngineConfiguration()

方法创建一个ProcessEngineConfiguration实例。

使用createProcessEngineConfigurationFromInputStream()方法创建工作流引擎配置对象的示例代码如下：

public void testCreateFromInputStream() {

File file = new File("resource/my-config.xml");

// 获取文件输入流

InputStream fis = new FileInputStream(file);

//使用createProcessEngineConfigurationFromInputStream()方法创建

//ProcessEngineConfiguration

ProcessEngineConfiguration processEngineConfigurationFromInputStream =

ProcessEngineConfiguration.createProcessEngineConfigurationFromInputStream(fis,

"myProcessEngineConfiguration");

System.out.println(processEngineConfigurationFromInputStream);

}

由以上代码段可知，Activiti根据my-config.xml配置文件输入流，创建了一个名为myProcessEngineConfiguration

的工作流引擎配置对象。

4．createStandaloneProcessEngineConfiguration()方法

该方法基于硬编码创建工作流引擎配置对象，不加载任何配置文件，所有数据属性均硬编码在代码中。

该方法的源码如下：

public static ProcessEngineConfiguration

createStandaloneProcessEngineConfiguration() {

return new StandaloneProcessEngineConfiguration();

}

public class StandaloneProcessEngineConfiguration extends ProcessEngineConfigurationImpl {

@Override

public CommandInterceptor createTransactionInterceptor() {

return null;

}

}

由以上代码段可知，此方法返回的实例是StandaloneProcessEngineConfiguration，其所有属性均已在

ProcessEngineConfiguration中设置。该方法的属性配置（如数据库连接配置）在代码中手动进行，示例代码

如下：

public void testCreateFromStandalone() {

ProcessEngineConfiguration processEngineConfigurationFromStandalone =

ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();

processEngineConfigurationFromStandalone.setJdbcDriver("com.mysql.jdbc.Driver");

processEngineConfigurationFromStandalone.setJdbcUrl("jdbc:mysql://localhost:3306/workflow");

processEngineConfigurationFromStandalone.setJdbcUsername("root");

processEngineConfigurationFromStandalone.setJdbcPassword("root");

processEngineConfigurationFromStandalone.setDatabaseSchemaUpdate("true");

System.out.println(processEngineConfigurationFromStandalone);

}

5．createStandaloneInMemProcessEngineConfiguration()方法

该方法也是基于硬编码创建工作流引擎配置对象，同样不加载任何配置文件，所有数据属性也是硬编码

在代码中。该方法的源码如下：

public static ProcessEngineConfiguration

createStandaloneInMemProcessEngineConfiguration() {

return new StandaloneInMemProcessEngineConfiguration();

}

public class StandaloneInMemProcessEngineConfiguration extends

StandaloneProcessEngineConfiguration {

public StandaloneInMemProcessEngineConfiguration() {

this.databaseSchemaUpdate = DB_SCHEMA_UPDATE_CREATE_DROP;

this.jdbcUrl = "jdbc:h2:mem:activiti";

}

}

由以上代码段可知，此方法返回实例StandaloneInMemProcessEngineConfiguration，它是StandaloneProcess

EngineConfiguration的子类，只特别指定了databaseSchemaUpdate属性和jdbcUrl属性，值分别为DB_SCHEMA_

UPDATE_CREATE_DROP和jdbc:h2:mem:activiti，说明该方法默认使用h2内存数据库。如果在代码编写过程

中需要改变某个属性的值，需要调用这个类的set()方法。

使用createStandaloneInMemProcessEngineConfiguration()方法创建工作流引擎配置对象的示例代码

如下：

public void testCreateFromStandaloneInMem() {

ProcessEngineConfiguration processEngineConfigurationFromStandaloneInMem =

ProcessEngineConfiguration.createStandaloneInMemProcessEngineConfiguration();

System.out.println(processEngineConfigurationFromStandaloneInMem);

工作流引擎对象ProcessEngine

工作流引擎对象ProcessEngine是Activiti的核心对象之一，一个ProcessEngine实例代表一个工作流引擎，使用ProcessEngine提供的诸如getRuntimeService()、getTaskService()、getRepositoryService()和getHistoryService()等一系列方法可以获取对应的工作流引擎服务，用于执行工作流部署、执行、管理等操作。

要获取ProcessEngine，需要先获取ProcessEngineConfiguration配置工作流引擎。创建ProcessEngine的方法一般有以下两种。

  • 通过ProcessEngineConfiguration的buildProcessEngine()方法创建；
  • 通过ProcessEngines创建。

1．通过ProcessEngineConfiguration的buildProcessEngine()方法创建 ProcessEngineConfiguration负责Activiti框架的属性配置、初始化工作，初始化入口是buildProcessEngine()方法。这种方式先通过调用ProcessEngineConfiguration类的静态方法，加载相应的XML配置文件，获取ProcessEngineConfiguration实例，然后调用buildProcessEngine()方法，创建一个ProcessEngine对象。其示例代码 如下：

java 复制代码 
public void createProcessEngineByBuildProcessEngineTest() {
ProcessEngineConfiguration configuration = ProcessEngineConfiguration
.createProcessEngineConfigurationFromResourceDefault();
ProcessEngine processEngine = configuration.buildProcessEngine();
System.out.println(processEngine);
}

以上代码段先使用ProcessEngineConfiguration的createProcessEngineConfigurationFromResourceDefault()静态 方法加载默认配置文件activiti.cfg.xml，获取一个ProcessEngineConfiguration实例，然后调用其buildProcessEngine()方法创建工作流引擎。在实际应用中，可以根据具体场景选择不同方法获取ProcessEngineConfiguration实例。

2．通过ProcessEngines创建

ProcessEngines是一个创建、关闭工作流引擎的工具类，所有创建的ProcessEngine实例均被注册到 ProcessEngines中。它类似一个容器工厂，维护了一个Map，其key为ProcessEngine实例的名称，value为 ProcessEngine实例。通过ProcessEngines类创建工作流引擎对象的方法有以下两种。

通过ProcessEngines.init()方法创建。ProcessEngines的init()方法会依次扫描、解析classpath下的activiti.cfg.xml和activiti-context.xml文件，并将创建的工作流引擎对象缓存到Map中。该方法会在Map中创建key值为default的ProcessEngine对象，然后就可以先获取这个Map，再通过Map获取key=defalut的工作流引擎对象了。其示例代码如下：

java 复制代码 
public void createProcessEngineByInitTest() {
//读取activiti.cfg.xml配置文件，创建工作流引擎对象缓存到Map中
ProcessEngines.init();
//获取Map
Map<String, ProcessEngine> enginesMap = ProcessEngines.getProcessEngines();
//获取key为default的对象
ProcessEngine processEngine = enginesMap.get("default");
System.out.println(processEngine);

}

通过getDefaultProcessEngine()方法创建**。ProcessEngines的getDefaultProcessEngine()方法会返回缓存Map中key值为default的工作流引擎对象，如果该Map还没有进行初始化，getDefaultProcessEngine()方法会先调用ProcessEngines.init()方法初始化缓存Map，然后再获取key为default的工作流引擎对象。 其示例代码如下：

java 复制代码 
public void createProcessEngineByGetDefaultProcessEngineTest() {
ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
System.out.println(defaultProcessEngine);

}

一般建议使用ProcessEngines的getDefaultProcessEngine()方法创建ProcessEngine。这是因为它比较简单，只需提供默认配置文件activiti.cfg.xml，并做好对工作流引擎配置，即可创建一个工作流引擎对象。

Activiti工作流引擎配置文件 工作流引擎配置对象ProcessEngineConfiguration需要通过加载、解析流程配置文件完成初始化。Activiti

配置文件主要有以下两种配置方式。

  •  遵循Activiti配置风格。这种方式是Activiti的默认配置方式，使用这种方式的配置文件名称为activiti.cfg.xml。对于activiti.cfg.xml文件，工作流引擎会使用Activiti的经典方式---ProcessEngineConfiguration. createProcessEngineConfigurationFromInputStream(inputStream).buildProcessEngine()构建，具体逻辑详见org.activiti.engine.ProcessEngines的initProcessEngineFromResource(URL resourceUrl)方法。
  •  遵循Spring配置风格。这种方式一般在与Spring集成时使用，使用这种方式的文件名称可以自定义， 如activiti.context.xml、spring.activiti.xml等。对于activiti.context.xml文件，工作流引擎会使用Spring方法构建：先创建一个Spring环境，然后通过该环境获得工作流引擎，具体逻辑详见org.activiti.engine.ProcessEngines的initProcessEngineFromSpringResource (URL resource)方法。 以上两种方式均可以实现工作流引擎的配置，下面将分别对其进行详细说明。

Activiti配置风格

activiti.cfg.xml配置文件内容如下：

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="org.apache.commons.dbcp.BasicDataSource">

<property name="driverClassName" value="org.h2.Driver"/>

<property name="url" value="jdbc:h2:mem:activiti"/>

<property name="username" value="sa"/>

<property name="password" value=""/>

</bean>

<!--activiti工作流引擎-->

<bean id="processEngineConfiguration"

class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">

<!-- 数据源 -->

<property name="dataSource" ref="dataSource"/>

<!-- 数据库更新策略 -->

<property name="databaseSchemaUpdate" value="true"/>

</bean>

</beans>

从以上配置文件内容可知，activiti.cfg.xml配置文件采用Spring bean配置文件格式。其先定义了一个id为 processEngineConfiguration的bean对象，即Activiti默认引擎配置管理器，接着为其指定一个具体的Java类org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration，由Spring负责实例化引擎配置管理器并注入一系列配置。使用这种方式配置工作流引擎的示例代码如下：

ini 复制代码 
public void createProcessEngineByGetDefaultProcessEngineTest() {
ProcessEngineConfiguration configuration = ProcessEngineConfiguration
.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
ProcessEngine processEngine = configuration.buildProcessEngine();
System.out.println(processEngine);

Spring配置风格

activiti.context.xml配置文件内容如下：

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"

xmlns:context="http://www.springframework.org/schema/context"

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.xsd">

<!--数据源配置-->

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">

<property name="driverClassName" value="org.h2.Driver"/>

<property name="url" value="jdbc:h2:mem:activiti"/>

<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.activiti.spring.SpringProcessEngineConfiguration">

<!-- 配置数据源 -->

<property name="dataSource" ref="dataSource" />

<!-- 配置事务管理器 -->

<property name="transactionManager" ref="transactionManager" />

<!-- 数据库更新策略 -->

<property name="databaseSchemaUpdate" value="true"/>

</bean>
<!-- 定义工作流引擎接口 -->

<bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean">

<property name="processEngineConfiguration" ref="processEngineConfiguration" />

</bean>

<!-- 定义Service服务接口 -->

<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="IdentityService" factory-bean="processEngine"

factory-method="getIdentityService" />

<bean id="managementService" factory-bean="processEngine"

factory-method="getManagementService" />

<bean id="formService" factory-bean="processEngine"

factory-method="getFormService" />

</beans>

从以上配置文件内容可知，activiti.context.xml配置文件也采用Spring bean配置文件格式，先定义了一个 id为processEngineConfiguration的bean对象，即Activiti默认引擎配置管理器，接着为其指定一个具体的Java类org.activiti.spring.SpringProcessEngineConfiguration，由Spring负责实例化引擎配置管理器并注入一系列配置。其与activiti.cfg.xml配置文件大同小异，但使用Spring配置风格需要注意以下4点：

 这种方式可以配置事务管理器，由Spring管理数据库事务；  必须定义工作流引擎接口ProcessEngineFactoryBean并为其设置processEngineConfiguration属性，从而创建工作流引擎；  可以定义Service接口，由工作流引擎接口引入；  使用这种方式实现工作流引擎配置需要在Spring配置文件中 引入： < import resource="activiti.context.xml"/>

使用Spring配置风格配置工作流引擎的示例代码如下：

ini 复制代码 
public void createProcessEngineBySpringXmlTest() throws IOException {

//读取activiti.context.xml配置文件

ClassLoader classLoader = ReflectUtil.getClassLoader();

URL resource = classLoader.getResource("activiti.context.xml");

//实例化Spring的ApplicationContext对象

ApplicationContext applicationContext = new GenericXmlApplicationContext

(new UrlResource(resource));

//从Spring中获取ProcessEngine对象

Map<String, ProcessEngine> beansOfType =

applicationContext.getBeansOfType(ProcessEngine.class);

if ((beansOfType == null) || (beansOfType.isEmpty())) {

throw new ActivitiException("no " + ProcessEngine.class.getName() +

" defined in the application context " + resource.toString());

}

//获取第一个ProcessEngine实例对象

ProcessEngine processEngine = beansOfType.values().iterator().next();

System.out.println(processEngine);

数据库连接配置

Activiti启动时，会加载工作流引擎配置文件中的数据库连接配置连接数据库，从而实现对数据库的

操作。Activiti支持多种主流的数据库，包括H2、MySQL、Oracle、PostgreSQL、SQL Server、DB2等。

数据库连接配置 Activiti支持通过JDBC和DataSource方式配置数据库连接。 1．JDBC方式配置

一个标准的Activiti配置文件activiti.cfg.xml的内容如下：

<beans xmlns="www.springframework.org/schema/bean..."

xmlns:xsi="www.w3.org/2001/XMLSch..."

xsi:schemaLocation="www.springframework.org/schema/bean...

www.springframework.org/schema/bean...

<bean id="processEngineConfiguration"

class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">

从以上配置文件内容可知，使用JDBC方式配置数据库连接时，将数据库相关配置信息写入了配置文件。 使用JDBC方式连接数据库，会用到jdbcDriver、jdbcUrl、jdbcUsername、jdbcPassword。ProcessEngineConfiguration类中有相应属性的setter()方法，可将这4个数据库属性注入该bean。

 jdbcDriver：针对特定数据库类型的驱动程序的实现。  jdbcUrl：数据库的JDBC URL。  jdbcUsername：连接数据库的用户名。  jdbcPassword：连接数据库的密码。

Activiti默认使用MyBatis数据连接池，基于提供的jdbc属性构建的数据源具有默认的MyBatis连接池设 置，可以通过以下属性调整该连接池。  jdbcMaxActiveConnections：连接池中处于激活状态的最大连接值，默认为10。  jdbcMaxIdleConnections：连接池中处于空闲状态的最大连接值。  jdbcMaxCheckoutTime：连接被取出使用的最长时间（单位为毫秒），默认为20000（20秒），超过 时间的连接会被强制回收。  jdbcMaxWaitTime：当整个连接池需要重新获取连接时，设置等待时间（单位为毫秒）。这是一个底 层配置，使连接池可以在长时间无法获得连接时打印日志状态，并重新尝试获取连接，避免在连接 池配置错误的情况下静默失败，默认为20000（20秒）。

2．DataSource方式配置

对于Activiti数据库连接配置，除了采用上面介绍的JDBC方式配置，还可以采用DataSource方式配置， 如使用DBCP、C3P0、Hikari、Tomcat连接池等配置数据库连接。这里以采用DBCP连接池配置数据库连接为 例进行说明：

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="org.apache.commons.dbcp.BasicDataSource">

<!-- 数据库驱动名称 -->

<property name="driverClassName" value="com.mysql.jdbc.Driver"/>

<!-- 数据库地址 -->

<property name="url" value="jdbc:mysql://localhost:3306/workflow"/>

<!-- 数据库用户名 -->

<property name="username" value="root"/>

<!-- 数据库密码 -->

<property name="password" value="123456"/>
<!--activiti工作流引擎配置-->

<bean id="processEngineConfiguration"

class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">

<!-- 数据源配置 -->

<property name="dataSource" ref="dataSource"/>

</bean>

</beans>

在上述数据库连接配置中，Activiti先配置了一个DBCP连接池，然后通过dataSource属性将其引入

ProcessEngineConfiguration。

数据库策略属性配置

不论使用JDBC方式还是使用DataSource方式配置数据库连接，都可以设置以下属性。

1．databaseType属性

该属性用于指定数据库类型，默认为h2。通常无须指定此属性，因为工作流引擎会在数据库连接元数据 中自动分析该属性，只有在自动检测失败的情况下才需要指定，其值可以是h2、hsql、mysql、oracle、postgresql、mssql或db2。该属性用于确定引擎使用哪种数据库的create/drop/upgrade的SQL DDL脚本（其中DDL代表data definition language，即数据定义语言），以及数据库操作的sql语句。Activiti的SQL DDL存储在activiti-6.0.0.zip的database子文件夹，或JAR文件中的org/activiti/db包内，其命名规范为activiti.{db}.{create|drop|upgrade}.{type}.sql。其中，db为支持的数据库名，type为engine、history或identity。

2．databaseSchemaUpdate属性

该属性用于设置工作流引擎启动、关闭时数据库执行的策略。该属性值可以是false、true、create-drop 或drop-create。

  •  false：默认值。设置为该值后，Activiti启动时会对比数据库表中保存的版本，如果数据库中没有表 或者版本不匹配，则抛出异常。
  •  true：设置为该值后，Activiti启动时会更新所有表，如果表不存在，则自动创建表。
  •  create-drop：设置为该值后，Activiti启动时会自动执行数据库表的创建操作，关闭时会自动执行数据 库表的删除操作。
  •  drop-create：设置为该值后，Activiti启动时会先执行数据库表的删除操作，再执行数据库表的创建操 作。与create-drop
相关推荐
摇滚侠3 小时前
Spring Boot 3零基础教程，IOC容器中组件的注册，笔记08
spring boot·笔记·后端
程序员小凯5 小时前
Spring Boot测试框架详解
java·spring boot·后端
你的人类朋友6 小时前
什么是断言？
前端·后端·安全
程序员小凯7 小时前
Spring Boot缓存机制详解
spring boot·后端·缓存
i学长的猫7 小时前
Ruby on Rails 从0 开始入门到进阶到高级 - 10分钟速通版
后端·ruby on rails·ruby
用户21411832636028 小时前
别再为 Claude 付费！Codex + 免费模型 + cc-switch，多场景 AI 编程全搞定
后端
茯苓gao8 小时前
Django网站开发记录（一）配置Mniconda，Python虚拟环境，配置Django
后端·python·django
Cherry Zack8 小时前
Django视图进阶：快捷函数、装饰器与请求响应
后端·python·django
爱读源码的大都督9 小时前
为什么有了HTTP，还需要gPRC？
java·后端·架构
码事漫谈9 小时前
致软件新手的第一个项目指南：阶段、文档与破局之道
后端
热门推荐
01BongoCat - 跨平台键盘猫动画工具02两千字总结：Codex 国内如何安装和使用的教程，以及如何设置中文回答03GitHub 镜像站点04智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践05UV安装并设置国内源06Linux下V2Ray安装配置指南07GitLab 零基础入门指南：从安装到项目管理全流程082025羊城杯网络安全大赛 wp09Cursor Plan Mode：AI 终于知道先想后做了10Spring Boot 实现微信登录，So Easy !