Activiti工作流學習筆記之自動生成28張數據庫表的底層原理解析

@Configuration
public class SpringBootActivitiConfig {
@Bean
public ProcessEngine processEngine(){
   ProcessEngineConfiguration pro=ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
   pro.setJdbcDriver("com.mysql.jdbc.Driver");
   pro.setJdbcUrl("xxxx");
   pro.setJdbcUsername("xxxx");
   pro.setJdbcPassword("xxx");
   //避免發佈的圖片和xml中文出現亂碼
   pro.setActivityFontName("宋體");
   pro.setLabelFontName("宋體");
   pro.setAnnotationFontName("宋體");
   //數據庫更更新策略
   pro.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
   return pro.buildProcessEngine();
}

   @Bean
   public RepositoryService repositoryService(){
     return processEngine().getRepositoryService();
   }

   @Bean
   public RuntimeService runtimeService(){
     return processEngine().getRuntimeService();
   }

   @Bean
   public TaskService taskService(){
     return processEngine().getTaskService();
   }
   ......

}

public abstract class ProcessEngineConfiguration {
   public static final String DB_SCHEMA_UPDATE_FALSE = "false";
   public static final String DB_SCHEMA_UPDATE_CREATE_DROP = "create-drop";
   public static final String DB_SCHEMA_UPDATE_TRUE = "true";
   ......
}

public abstract class ProcessEngineConfigurationImpl extends ProcessEngineConfiguration {
   public static final String DB_SCHEMA_UPDATE_DROP_CREATE = "drop-create";
   ......
}

public interface ProcessEngine {

  public static String VERSION = "6.0.0.4";

  String getName();

 void close();
  //流程運行服務類，用於獲取流程執行相關信息
  RepositoryService getRepositoryService();
  //流程運行服務類，用於獲取流程執行相關信息
  RuntimeService getRuntimeService();
  //內置表單，用於工作流自帶內置表單的設置
  FormService getFormService();
  //任務服務類，用戶獲取任務信息
  TaskService getTaskService();
  //獲取正在運行或已經完成的流程實例歷史信息
  HistoryService getHistoryService();
  //創建、更新、刪除、查詢群組和用戶
  IdentityService getIdentityService();
  //流程引擎的管理與維護
  ManagementService getManagementService();
  //提供對流程定義和部署存儲庫的訪問的服務。
  DynamicBpmnService getDynamicBpmnService();
  //獲取配置類
  ProcessEngineConfiguration getProcessEngineConfiguration();
  //提供對內置表單存儲庫的訪問的服務。
  FormRepositoryService getFormEngineRepositoryService();

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

@Override
public ProcessEngine buildProcessEngine() {
  //初始化的方法
  init();
  //創建ProcessEngine
  ProcessEngineImpl processEngine = new ProcessEngineImpl(this);

 // Activiti 5引擎的觸發裝置
  if (isActiviti5CompatibilityEnabled && activiti5CompatibilityHandler != null) {
   Context.setProcessEngineConfiguration(processEngine.getProcessEngineConfiguration());
   activiti5CompatibilityHandler.getRawProcessEngine();
  }

 postProcessEngineInitialisation();

 return processEngine;
}

protected boolean usingRelationalDatabase = true;
if (usingRelationalDatabase) {
  initDataSource();
}

pro.setJdbcDriver("com.mysql.jdbc.Driver");
  pro.setJdbcUrl("xxxx");
 pro.setJdbcUsername("xxxx");
  pro.setJdbcPassword("xxx");

public void initDataSource() {
  //判斷數據源dataSource是否存在
  if (dataSource == null) {
    /
    //判斷是否使用JNDI方式連接數據源
   if (dataSourceJndiName != null) {
    try {
     dataSource = (DataSource) new InitialContext().lookup(dataSourceJndiName);
    } catch (Exception e) {
     ......
    }
   //使用非JNDI方式且數據庫地址不為空，走下面的設置
   } else if (jdbcUrl != null) {
     //jdbc驅動為空或者jdbc連接賬戶為空
    if ((jdbcDriver == null) || (jdbcUsername == null)) {
    ......
    }

    //創建mybatis默認連接池PooledDataSource對象，這裡傳進來的，就是上面pro.setJdbcDriver("com.mysql.jdbc.Driver")配置的參數，
    //debug到這裡，就可以清晰明白，配置類裡設置的JdbcDriver、JdbcUrl、JdbcUsername、JdbcPassword等，就是為瞭用來創建連接池需要用到的；
    PooledDataSource pooledDataSource = new PooledDataSource(ReflectUtil.getClassLoader(), jdbcDriver, jdbcUrl, jdbcUsername, jdbcPassword);

    if (jdbcMaxActiveConnections > 0) {
     //設置最大活躍連接數
     pooledDataSource.setPoolMaximumActiveConnections(jdbcMaxActiveConnections);
    }
    if (jdbcMaxIdleConnections > 0) {
     // 設置最大空閑連接數
     pooledDataSource.setPoolMaximumIdleConnections(jdbcMaxIdleConnections);
    }
    if (jdbcMaxCheckoutTime > 0) {
     // 最大checkout 時長
     pooledDataSource.setPoolMaximumCheckoutTime(jdbcMaxCheckoutTime);
    }
    if (jdbcMaxWaitTime > 0) {
     // 在無法獲取連接時，等待的時間
     pooledDataSource.setPoolTimeToWait(jdbcMaxWaitTime);
    }
    if (jdbcPingEnabled == true) {
     //是否允許發送測試SQL語句
     pooledDataSource.setPoolPingEnabled(true);

    ......

    dataSource = pooledDataSource;
   }

    ......
  }
  //設置數據庫類型
  if (databaseType == null) {
   initDatabaseType();
  }
}

public void initDatabaseType() {
   Connection connection = null;
   try {
     connection = this.dataSource.getConnection();
     DatabaseMetaData databaseMetaData = connection.getMetaData();
     String databaseProductName = databaseMetaData.getDatabaseProductName();
     this.databaseType = databaseTypeMappings.getProperty(databaseProductName);
     ......
   } catch (SQLException var12) {
   ......
   } finally {
   ......
   }
}

package com.mysql.cj.jdbc;

public class DatabaseMetaData implements java.sql.DatabaseMetaData 

@Override
 public String getDatabaseProductName() throws SQLException {
   return "MySQL";
 }

 String databaseProductName = databaseMetaData.getDatabaseProductName();
 this.databaseType = databaseTypeMappings.getProperty(databaseProductName);

 protected boolean usingRelationalDatabase = true;
 if (usingRelationalDatabase) {
 initSqlSessionFactory();
}

ProcessEngineImpl processEngine = new ProcessEngineImpl(this);

public ProcessEngineImpl(ProcessEngineConfigurationImpl processEngineConfiguration) {
 this.processEngineConfiguration = processEngineConfiguration;
 this.name = processEngineConfiguration.getProcessEngineName();
 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.commandExecutor = processEngineConfiguration.getCommandExecutor();
 this.sessionFactories = processEngineConfiguration.getSessionFactories();
 this.transactionContextFactory = processEngineConfiguration.getTransactionContextFactory();
 this.formEngineRepositoryService = processEngineConfiguration.getFormEngineRepositoryService();
 this.formEngineFormService = processEngineConfiguration.getFormEngineFormService();
​
 if (processEngineConfiguration.isUsingRelationalDatabase() && processEngineConfiguration.getDatabaseSchemaUpdate() != null) {
  commandExecutor.execute(processEngineConfiguration.getSchemaCommandConfig(), new SchemaOperationsProcessEngineBuild());
 }
 ......
}

if (processEngineConfiguration.isUsingRelationalDatabase() && processEngineConfiguration.getDatabaseSchemaUpdate() != null) {
  commandExecutor.execute(processEngineConfiguration.getSchemaCommandConfig(), new SchemaOperationsProcessEngineBuild());
 }

public final class SchemaOperationsProcessEngineBuild implements Command<Object> {
​
 public Object execute(CommandContext commandContext) {
  DbSqlSession dbSqlSession = commandContext.getDbSqlSession();
  if (dbSqlSession != null) {
   dbSqlSession.performSchemaOperationsProcessEngineBuild();
  }
  return null;
 }
}

public void performSchemaOperationsProcessEngineBuild() {
  String databaseSchemaUpdate = Context.getProcessEngineConfiguration().getDatabaseSchemaUpdate();
  log.debug("Executing performSchemaOperationsProcessEngineBuild with setting " + databaseSchemaUpdate);
   //drop-create模式
  if ("drop-create".equals(databaseSchemaUpdate)) {
    try {
      this.dbSchemaDrop();
    } catch (RuntimeException var3) {
    }
  }

  if (!"create-drop".equals(databaseSchemaUpdate) && !"drop-create".equals(databaseSchemaUpdate) && !"create".equals(databaseSchemaUpdate)) {
     //false模式
    if ("false".equals(databaseSchemaUpdate)) {
      this.dbSchemaCheckVersion();
    } else if ("true".equals(databaseSchemaUpdate)) {
       //true模式
      this.dbSchemaUpdate();
    }
  } else {
    //create_drop模式
    this.dbSchemaCreate();
  }
​
}

public String dbSchemaUpdate() {
​
 String feedback = null;
 //判斷是否需要更新，默認是false
 boolean isUpgradeNeeded = false;
 int matchingVersionIndex = -1;
 //判斷是否需要更新或者創建引擎核心engine表，若isEngineTablePresent()為true，表示需要更新，若為false，則需要新創建
 if (isEngineTablePresent()) {
 ......
 } else {
   //創建表方法，稍後會詳細分析
  dbSchemaCreateEngine();
 }

 //判斷是否需要創建或更新歷史相關表
 if (this.isHistoryTablePresent()) {
   if (isUpgradeNeeded) {
      this.dbSchemaUpgrade("history", matchingVersionIndex);
    }
 } else if (this.dbSqlSessionFactory.isDbHistoryUsed()) {
    this.dbSchemaCreateHistory();
 }
 //判斷是否需要更新群組和用戶
 if (this.isIdentityTablePresent()) {
    if (isUpgradeNeeded) {
     this.dbSchemaUpgrade("identity", matchingVersionIndex);
    }
 } else if (this.dbSqlSessionFactory.isDbIdentityUsed()) {
     this.dbSchemaCreateIdentity();
    }
 return feedback;
}

public boolean isEngineTablePresent() {
  return isTablePresent("ACT_RU_EXECUTION");
}

tables = databaseMetaData.getTables(catalog, schema, tableName, JDBC_METADATA_TABLE_TYPES);
return tables.next();

if (isEngineTablePresent()) {
 ......
 } else {
   //創建表方法
  dbSchemaCreateEngine();
 }
​

protected void dbSchemaCreateEngine() {
  this.executeMandatorySchemaResource("create", "engine");
}

public void executeMandatorySchemaResource(String operation, String component) {
  this.executeSchemaResource(operation, component, this.getResourceForDbOperation(operation, operation, component), false);
}

public String getResourceForDbOperation(String directory, String operation, String component) {
   String databaseType = this.dbSqlSessionFactory.getDatabaseType();
  return "org/activiti/db/" + directory + "/activiti." + databaseType + "." + operation + "." + component + ".sql";
}

public void executeMandatorySchemaResource(String operation, String component) {
   this.executeSchemaResource(operation, component, this.getResourceForDbOperation(operation, operation, component), false);
 }

public void executeSchemaResource(String operation, String component, String resourceName, boolean isOptional) {
   InputStream inputStream = null;
   try {
     //根據resourceName路徑字符串，獲取到對應engine.sql文件的輸入流inputStream，即讀取engine.sql文件
     inputStream = ReflectUtil.getResourceAsStream(resourceName);
     if (inputStream == null) {
     ......
     } else {
       //將得到的輸入流inputStream傳入該方法
       this.executeSchemaResource(operation, component, resourceName, inputStream);
     }
   } finally {
    ......
   }
}

private void executeSchemaResource(String operation, String component, String resourceName, InputStream inputStream) {
  //sql語句字符串
  String sqlStatement = null;

  try {
 //1、jdbc連接mysql數據庫
    Connection connection = this.sqlSession.getConnection();
 //2、分行讀取resourceName="org/activiti/db/create/activiti.mysql.create.engine.sql"目錄底下的文件數據
    byte[] bytes = IoUtil.readInputStream(inputStream, resourceName);
 //3.將engine.sql文件裡的數據分行轉換成字符串，換行的地方，可以看到字符串用轉義符“\n”來代替
    String ddlStatements = new String(bytes);
    try {

      if (this.isMysql()) {
        DatabaseMetaData databaseMetaData = connection.getMetaData();
        int majorVersion = databaseMetaData.getDatabaseMajorVersion();
        int minorVersion = databaseMetaData.getDatabaseMinorVersion();
        if (majorVersion <= 5 && minorVersion < 6) {
          //若數據庫類型是在mysql 5.6版本以下，需要做一些替換，因為低於5.6版本的MySQL是不支持變體時間戳或毫秒級的日期，故而需要在這裡對sql語句的字符串做替換。（註意，這裡的majorVersion代表主版本，minorVersion代表主版本下的小版本）
          ddlStatements = this.updateDdlForMySqlVersionLowerThan56(ddlStatements);
        }
      }
    } catch (Exception var26) {
      ......
    }
    //4.以字符流形式讀取字符串數據
    BufferedReader reader = new BufferedReader(new StringReader(ddlStatements));
    //5.根據字符串中的轉義符“\n”分行讀取
    String line = this.readNextTrimmedLine(reader);
    //6.循環每一行
    for(boolean inOraclePlsqlBlock = false; line != null; line = this.readNextTrimmedLine(reader)) {

      if (line.startsWith("# ")) {
      ......
      }
      //7.若下一行line還有數據，證明還沒有全部讀取，仍可執行讀取
    else if (line.length() > 0) {
          if (this.isOracle() && line.startsWith("begin")) {
           .......

          }
      /**
      8.在沒有拼接夠一個完整建表語句時，！line.endsWith(";")會為true，即一直循環進行拼接，當遇到";"就跳出該if語句
      **/
      else if ((!line.endsWith(";") || inOraclePlsqlBlock) && (!line.startsWith("/") || !inOraclePlsqlBlock)) {
            sqlStatement = this.addSqlStatementPiece(sqlStatement, line);
          } else {
        /**
       9.循環拼接中若遇到符號";"，就意味著，已經拼接形成一個完整的sql建表語句，例如
      create table ACT_GE_PROPERTY (
      NAME_ varchar(64),
      VALUE_ varchar(300),
      REV_ integer,
      primary key (NAME_)
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin
      這樣，就可以先通過代碼來將該建表語句執行到數據庫中，實現如下：
        **/
            if (inOraclePlsqlBlock) {
              inOraclePlsqlBlock = false;
            } else {

              sqlStatement = this.addSqlStatementPiece(sqlStatement, line.substring(0, line.length() - 1));
            }
          //10.將建表語句字符串包裝成Statement對象
            Statement jdbcStatement = connection.createStatement();
            try {
          //11.最後，執行建表語句到數據庫中
              jdbcStatement.execute(sqlStatement);
              jdbcStatement.close();
            } catch (Exception var27) {
            ......
            } finally {
          //12.到這一步，意味著上一條sql建表語句已經執行結束，若沒有出現錯誤話，這時已經證明第一個數據庫表結構已經創建完成，可以開始拼接下一條建表語句，
              sqlStatement = null;
            }
          }
        }
      }
​
      ......
    } catch (Exception var29) {
      ......
    }
  }