Activiti工作流学习笔记(三)——自动生成28张数据库表的底层原理分析

原创/朱季谦

网上关于工作流引擎Activiti生成表的机制大多仅限于四种策略模式，但其底层是如何实现的，相关文章还是比较少，因此，觉得撸一撸其生成表机制的底层原理。

我接触工作流引擎Activiti已有两年之久，但一直都只限于熟悉其各类API的使用，对底层的实现，则存在较大的盲区。

Activiti这个开源框架在设计上，其实存在不少值得学习和思考的地方，例如，框架用到以命令模式、责任链模式、模板模式等优秀的设计模式来进行框架的设计。

故而，是值得好好研究下Activiti这个框架的底层实现。

我在工作当中现阶段用的比较多是Activiti6.0版本，本文就以这个版本来展开分析。

在使用Activiti工作流引擎过程中，让我比较好奇的一个地方，是框架自带一套数据库表结构，在首次启动时，若设计了相应的建表策略时，将会自动生成28张表，而这些表都是以ACT_开头。

那么问题来了，您是否与我一样，曾好奇过这些表都是怎么自动生成的呢？

下面，就开始一点点深入研究——

在工作流Springboot+Activiti6.0集成框架，网上最常见的引擎启动配置教程一般长这样：

1 @Configuration

2 public class SpringBootActivitiConfig {

3 @Bean

4 public ProcessEngine processEngine(){

5 ProcessEngineConfiguration pro=ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();

6 pro.setJdbcDriver("com.mysql.jdbc.Driver");

7 pro.setJdbcUrl("xxxx");

8 pro.setJdbcUsername("xxxx");

9 pro.setJdbcPassword("xxx");

10 //避免发布的图片和xml中文出现乱码

11 pro.setActivityFontName("宋体");

12 pro.setLabelFontName("宋体");

13 pro.setAnnotationFontName("宋体");

14 //数据库更更新策略

15 pro.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);

16 return pro.buildProcessEngine();

17 }

18

19 @Bean

20 public RepositoryService repositoryService(){

21 return processEngine().getRepositoryService();

22 }

23

24 @Bean

25 public RuntimeService runtimeService(){

26 return processEngine().getRuntimeService();

27 }

28

29 @Bean

30 public TaskService taskService(){

31 return processEngine().getTaskService();

32 }

33 ......

34

35 }

其中，方法pro.setDatabaseSchemaUpdate()可对工作流引擎自带的28张表进行不同策略的更新。

Activiti6.0版本总共有四种数据库表更新策略。

查看这三种策略的静态常量标识，分别如下：

1 public abstract class ProcessEngineConfiguration {

2 public static final String DB_SCHEMA_UPDATE_FALSE = "false";

3 public static final String DB_SCHEMA_UPDATE_CREATE_DROP = "create-drop";

4 public static final String DB_SCHEMA_UPDATE_TRUE = "true";

5 ......

6 }

7

8 public abstract class ProcessEngineConfigurationImpl extends ProcessEngineConfiguration {

9 public static final String DB_SCHEMA_UPDATE_DROP_CREATE = "drop-create";

10 ......

11 }

flase：默认值，引擎启动时，自动检查数据库里是否已有表，或者表版本是否匹配，如果无表或者表版本不对，则抛出异常。（常用在生产环境）；

true:若表不存在，自动更新；若存在，而表有改动，则自动更新表，若表存在以及表无更新，则该策略不会做任何操作。（一般用在开发环境）；

create_drop：启动时自动建表，关闭时就删除表，有一种临时表的感觉。（需手动关闭，才会起作用）；

drop-create：启动时删除旧表，再重新建表。（无需手动关闭就能起作用）；

整个启动更新数据库的过程都是围绕这四种策略，接下来就以这四种策略为主题，撸一下自动更新据库表的底层原理，这一步骤是在引擎启动时所执行的buildProcessEngine()方法里实现。

从该buildProcessEngine方法名上便可以看出，这是一个初始化工作流引擎框架的方法。

从这里开始，一步一步debug去分析源码实现。

一.初始化工作流的buildProcessEngine()方法——

processEngineConfiguration.buildProcessEngine()是一个抽象方法，主要功能是初始化引擎，获取到工作流的核心API接口：ProcessEngine。通过该API，可获取到引擎所有的service服务。

进入processEngine接口，可以看到，其涵盖了Activiti的所有服务接口：

1 public interface ProcessEngine {

2

3 public static String VERSION = "6.0.0.4";

4

5 String getName();

6

7 void close();

8 //流程运行服务类，用于获取流程执行相关信息

9 RepositoryService getRepositoryService();

10 //流程运行服务类，用于获取流程执行相关信息

11 RuntimeService getRuntimeService();

12 //内置表单，用于工作流自带内置表单的设置

13 FormService getFormService();

14 //任务服务类，用户获取任务信息

15 TaskService getTaskService();

16 //获取正在运行或已经完成的流程实例历史信息

17 HistoryService getHistoryService();

18 //创建、更新、删除、查询群组和用户

19 IdentityService getIdentityService();

20 //流程引擎的管理与维护

21 ManagementService getManagementService();

22 //提供对流程定义和部署存储库的访问的服务。

23 DynamicBpmnService getDynamicBpmnService();

24 //获取配置类

25 ProcessEngineConfiguration getProcessEngineConfiguration();

26 //提供对内置表单存储库的访问的服务。

27 FormRepositoryService getFormEngineRepositoryService();

28

29 org.activiti.form.api.FormService getFormEngineFormService();

30 }

buildProcessEngine()有三个子类方法的重写，默认是用ProcessEngineConfigurationImpl类继承重写buildProcessEngine初始化方法，如下图所示：

该buildProcessEngine重写方法如下：

1 @Override

2 public ProcessEngine buildProcessEngine() {

3 //初始化的方法

4 init();

5 //创建ProcessEngine

6 ProcessEngineImpl processEngine = new ProcessEngineImpl(this);

7

8 // Activiti 5引擎的触发装置

9 if (isActiviti5CompatibilityEnabled && activiti5CompatibilityHandler != null) {

10 Context.setProcessEngineConfiguration(processEngine.getProcessEngineConfiguration());

11 activiti5CompatibilityHandler.getRawProcessEngine();

12 }

13

14 postProcessEngineInitialisation();

15

16 return processEngine;

17 }

init()方法里面包含各类需要初始化的方法，涉及到很多东西，这里先暂不一一展开分析，主要先分析与数据库连接初始化相关的逻辑。Activiti6.0底层是通过mybatis来操作数据库的，下面主要涉及到mybatis的连接池与SqlSessionFactory 的创建。

1.initDataSource()：实现动态配置数据库DataSource源

1 protected boolean usingRelationalDatabase = true;

2 if (usingRelationalDatabase) {

3 initDataSource();

4 }

该数据库连接模式初始化的意义如何理解，这就需要回到最初引擎配置分析，其中里面有这样一部分代码：

1 pro.setJdbcDriver("com.mysql.jdbc.Driver");

2 pro.setJdbcUrl("xxxx");

3 pro.setJdbcUsername("xxxx");

4 pro.setJdbcPassword("xxx");

这部分设置的东西，都是数据库相关的参数，它将传到initDataSource方法里，通过mybatis默认的连接池PooledDataSource进行设置，可以说，这个方法主要是用来创建mybatis连接数据库的连接池，从而生成数据源连接。

1 public void initDataSource() {

2 //判断数据源dataSource是否存在

3 if (dataSource == null) {

4 /

5 //判断是否使用JNDI方式连接数据源

6 if (dataSourceJndiName != null) {

7 try {

8 dataSource = (DataSource) new InitialContext().lookup(dataSourceJndiName);

9 } catch (Exception e) {

10 ......

11 }

12 //使用非JNDI方式且数据库地址不为空，走下面的设置

13 } else if (jdbcUrl != null) {

14 //jdbc驱动为空或者jdbc连接账户为空

15 if ((jdbcDriver == null) || (jdbcUsername == null)) {

16 ......

17 }

18

19 //创建mybatis默认连接池PooledDataSource对象，这里传进来的，就是上面pro.setJdbcDriver("com.mysql.jdbc.Driver")配置的参数，

20 //debug到这里，就可以清晰明白，配置类里设置的JdbcDriver、JdbcUrl、JdbcUsername、JdbcPassword等，就是为了用来创建连接池需要用到的；

21 PooledDataSource pooledDataSource = new PooledDataSource(ReflectUtil.getClassLoader(), jdbcDriver, jdbcUrl, jdbcUsername, jdbcPassword);

22

23 if (jdbcMaxActiveConnections > 0) {

24 //设置最大活跃连接数

25 pooledDataSource.setPoolMaximumActiveConnections(jdbcMaxActiveConnections);

26 }

27 if (jdbcMaxIdleConnections > 0) {

28 // 设置最大空闲连接数

29 pooledDataSource.setPoolMaximumIdleConnections(jdbcMaxIdleConnections);

30 }

31 if (jdbcMaxCheckoutTime > 0) {

32 // 最大checkout 时长

33 pooledDataSource.setPoolMaximumCheckoutTime(jdbcMaxCheckoutTime);

34 }

35 if (jdbcMaxWaitTime > 0) {

36 // 在无法获取连接时，等待的时间

37 pooledDataSource.setPoolTimeToWait(jdbcMaxWaitTime);

38 }

39 if (jdbcPingEnabled == true) {

40 //是否允许发送测试SQL语句

41 pooledDataSource.setPoolPingEnabled(true);

42

43 ......

44

45 dataSource = pooledDataSource;

46 }

47

48 ......

49 }

50 //设置数据库类型

51 if (databaseType == null) {

52 initDatabaseType();

53 }

54 }

initDatabaseType()作用是设置工作流引擎的数据库类型。在工作流引擎里，自带的28张表，其实有区分不同的数据库，而不同数据库其建表语句存在一定差异。

进入到 initDatabaseType()方法看看其是如何设置数据库类型的——

1 public void initDatabaseType() {

2 Connection connection = null;

3 try {

4 connection = this.dataSource.getConnection();

5 DatabaseMetaData databaseMetaData = connection.getMetaData();

6 String databaseProductName = databaseMetaData.getDatabaseProductName();

7 this.databaseType = databaseTypeMappings.getProperty(databaseProductName);

8 ......

9 } catch (SQLException var12) {

10 ......

11 } finally {

12 ......

13 }

14 }

进入到databaseMetaData.getDatabaseProductName()方法里，可以看到这是一个接口定义的方法：

String getDatabaseProductName() throws SQLException;

这个方法在java.sql包中的DatabaseMetData接口里被定义，其作用是搜索并获取数据库的名称。这里配置使用的是mysql驱动，那么就会被mysql驱动中的jdbc中的DatabaseMetaData实现，如下代码所示：

1 package com.mysql.cj.jdbc;

2

3 public class DatabaseMetaData implements java.sql.DatabaseMetaData

在该实现类里，其重写的方法中，将会返回mysql驱动对应的类型字符串：

1 @Override

2 public String getDatabaseProductName() throws SQLException {

3 return "MySQL";

4 }

故而，就会返回“MySql”字符串，并赋值给字符串变量databaseProductName，再将databaseProductName当做参数传给

databaseTypeMappings.getProperty(databaseProductName)，最终会得到一个 this.databaseType =“MySQL”，也就是意味着，设置了数据库类型databaseType的值为mysql。注意，这一步很重要，因为将在后面生成表过程中，会判断该databaseType的值究竟是代表什么数据库类型。

1 String databaseProductName = databaseMetaData.getDatabaseProductName();

2 this.databaseType = databaseTypeMappings.getProperty(databaseProductName);

该方法对SqlSessionFactory进行 初始化创建：SqlSessionFactory是mybatis的核心类，简单的讲，创建这个类，接下来就可以进行增删改查与事务操作了。

1 protected boolean usingRelationalDatabase = true;

2 if (usingRelationalDatabase) {

3 initSqlSessionFactory();

4 }

init()主要都是初始化引擎环境的相关操作，里面涉及到很多东西，但在本篇文中主要了解到这里面会创建线程池以及mybatis相关的初始创建即可。

二、开始进行processEngine 的创建

ProcessEngineImpl processEngine = new ProcessEngineImpl(this);

这部分代码，就是创建Activiti的各服务类了：

1 public ProcessEngineImpl(ProcessEngineConfigurationImpl processEngineConfiguration) {

2 this.processEngineConfiguration = processEngineConfiguration;

3 this.name = processEngineConfiguration.getProcessEngineName();

4 this.repositoryService = processEngineConfiguration.getRepositoryService();

5 this.runtimeService = processEngineConfiguration.getRuntimeService();

6 this.historicDataService = processEngineConfiguration.getHistoryService();

7 this.identityService = processEngineConfiguration.getIdentityService();

8 this.taskService = processEngineConfiguration.getTaskService();

9 this.formService = processEngineConfiguration.getFormService();

10 this.managementService = processEngineConfiguration.getManagementService();

11 this.dynamicBpmnService = processEngineConfiguration.getDynamicBpmnService();

12 this.asyncExecutor = processEngineConfiguration.getAsyncExecutor();

13 this.commandExecutor = processEngineConfiguration.getCommandExecutor();

14 this.sessionFactories = processEngineConfiguration.getSessionFactories();

15 this.transactionContextFactory = processEngineConfiguration.getTransactionContextFactory();

16 this.formEngineRepositoryService = processEngineConfiguration.getFormEngineRepositoryService();

17 this.formEngineFormService = processEngineConfiguration.getFormEngineFormService();

18 ​

19 if (processEngineConfiguration.isUsingRelationalDatabase() && processEngineConfiguration.getDatabaseSchemaUpdate() != null) {

20 commandExecutor.execute(processEngineConfiguration.getSchemaCommandConfig(), new SchemaOperationsProcessEngineBuild());

21 }

22 ......

23 }

注意，这里面有一段代码，整个引擎更新数据库的相应策略是具体实现，就在这里面：

1 if (processEngineConfiguration.isUsingRelationalDatabase() && processEngineConfiguration.getDatabaseSchemaUpdate() != null) {

2 commandExecutor.execute(processEngineConfiguration.getSchemaCommandConfig(), new SchemaOperationsProcessEngineBuild());

3 }

processEngineConfiguration.isUsingRelationalDatabase()默认是true，即代表需要对数据库模式做设置，例如前面初始化的dataSource数据源，创建SqlSessionFactory等，这些都算是对数据库模式进行设置；若为false，则不会进行模式设置与验证，需要额外手动操作，这就意味着，引擎不能验证模式是否正确。

processEngineConfiguration.getDatabaseSchemaUpdate()是用户对数据库更新策略的设置，如，前面配置类里设置了pro.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE)，若设置四种模式当中的任何一种，就意味着，需要对引擎的数据库进行相应策略操作。

综上，if()判断为true，就意味着，将执行括号里的代码，这块功能就是根据策略去对数据库进行相应的增删改查操作。

commandExecutor.execute()是一个典型的命令模式，先暂时不深入分析，直接点开new SchemaOperationsProcessEngineBuild()方法。

1 public final class SchemaOperationsProcessEngineBuild implements Command