工作流Activiti学习二 Activiti流程引擎初始化

　　Activiti流程中的核心是流程引擎，其他服务都是通过ProcessEngine来获取的，获取流程引擎的同时也会初始化Activiti的原始表，下面简单介绍一下创建Activiti流程引擎的几种方式，Activiti的原始表后面再介绍。

一、pom.xml依赖

复制代码
<!-- 配置版本 -->
    <properties>
        <sping.version>4.3.17.RELEASE</sping.version>
        <mysql.version>5.1.39</mysql.version>
        <activiti.version>5.22.0</activiti.version>
        <mybatis.version>3.4.6</mybatis.version>
        <!-- 只能使用2.0以下的版本 -->
        <log4j.version>1.2.17</log4j.version>
    </properties>

    <dependencies>
        <!-- activiti的依赖 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-engine</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- ssm集成 -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <!-- mysql驱动 -->
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>

        <!-- Spring相关依赖 -->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${sping.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${sping.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${sping.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${sping.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${sping.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${sping.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${sping.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${sping.version}</version>
        </dependency>

        <!-- mybatis依赖 -->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/log4j/log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.25</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- 配置编译的jdk版本 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
                <configuration>
                    <!-- 指定source和target的版本 -->
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
复制代码

二、配置数据源DataSource方式初始化Activiti原始表

复制代码
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.junit.Test;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

/**
 * 
* @ClassName: InitTable  
* @Description: 初始化activiti表
* @date 2020年6月25日  
*
 */
public class InitTable {
    /**
     * 初始化方式一
     *        配置数据源方式
     */
    @Test
    public void intiTables_1() {
        // 创建数据源
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/activiti");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        
        // 创建流程引擎的配置
        ProcessEngineConfiguration configuration = ProcessEngineConfiguration
                    .createStandaloneProcessEngineConfiguration();
        configuration.setDataSource(dataSource);    
        
        // 配置初始化的方式
        // DB_SCHEMA_UPDATE_FALSE：如果数据库里面没有activiti相关表，不会创建
        // DB_SCHEMA_UPDATE_TRUE：如果数据库里面没有activiti相关表，创建
        // DB_SCHEMA_UPDATE_CREATE_DROP：创建表，使用完成后删除
//        configuration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
        // drop-create：如果数据库里面有表，先删除再新建
        configuration.setDatabaseSchemaUpdate("drop-create");
        
        // 获得流程引擎
        ProcessEngine processEngine = configuration.buildProcessEngine();
        System.out.println(processEngine);
    }
}
复制代码

　　  属性databaseSchemaUpdate的默认值是false。

复制代码
 /** Checks the version of the DB schema against the library when 
   * the process engine is being created and throws an exception
   * if the versions don't match. */
  public static final String DB_SCHEMA_UPDATE_FALSE = "false";

/** Upon building of the process engine, a check is performed and 
   * an update of the schema is performed if it is necessary. */
  public static final String DB_SCHEMA_UPDATE_TRUE = "true";

 protected String databaseSchemaUpdate = DB_SCHEMA_UPDATE_FALSE;
复制代码

　　databaseSchemaUpdate=‘true’： activiti会对数据库中所有表进行更新操作。如果表不存在，则自动创建。

       databaseSchemaUpdate=‘false’： activiti会对数据库中表进行检测。如果表不存在，则抛出异常。默认值是false。

二、读取配置文件的方式

1、创建配置文件activiti.cfg.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="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
 <!-- 数据库相关信息 -->
    <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/activiti" />
    <property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
    <property name="jdbcUsername" value="root" />
    <property name="jdbcPassword" value="123456" />
 <!-- 允许执行数据库更新 -->
    <property name="databaseSchemaUpdate" value="true" />
  </bean>
 
</beans>
复制代码

2、读取配置文件的方式初始化Activiti相关表

复制代码
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.junit.Test;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

/**
 * 
* @ClassName: InitTable  
* @Description: 初始化activiti表
* @author xzp
* @date 2020年6月25日  
*
 */
public class InitTable {
    /**
     * 初始化方式二
     *         xml方式
     */
    @Test
    public void intiTables_2() {
        // 读取资源文件获取流程引擎配置对象
        ProcessEngineConfiguration configuration = ProcessEngineConfiguration
                .createProcessEngineConfigurationFromResource("activiti.cfg.xml");
        // 获取流程引擎
        ProcessEngine processEngine = configuration.buildProcessEngine();
        System.out.println(processEngine);
    }
}
复制代码

三、获取默认的流程引擎

复制代码
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;
import org.junit.Test;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

/**
 * 
* @ClassName: InitTable  
* @Description: 初始化activiti表
* @author 
* @date 2020年6月25日  
*
 */
public class InitTable {
    @Test
    public void intiTables_3() {
        /**
         * 以这种方式创建，必须创建activiti.cfg.xml配置文件，配置文件中配置数据库、初始化方式
         */
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        System.out.println(processEngine);
    }  
}
复制代码

     我们来看下getDefaultProcessEngine做了哪些事情：

1、根据名称获流程引擎，这里是获取默认的流程引擎。判断流程引擎是否已经被初始化，如果没有被初始化，先做初始化，再从processEngines容器中获取Bean。这里ProcesssEngines是一个Map容器。

 

 2、初始化过程

       初始化大致过程：读取xml文件转化为可读资源信息，判断流程引擎信息容器中是否存在配置文件中的引擎bean信息，如果存在则移除流程引擎信息容器中bean信息，通过可读资源信息初始化流程引擎实例，并放入容器中。其实第三种方式---获取默认流程引擎是对第二种方式的封装。

复制代码
/* 初始化xml文件中的所有流程引擎*/
  public synchronized static void init() {
    if (!isInitialized()) {
      if(processEngines == null) {
        //   如果当前processEngine容器为null,创建容器用来存储流程引擎的bean
        processEngines = new HashMap<String, ProcessEngine>();        
      }
// 获取类加载器
      ClassLoader classLoader = ReflectUtil.getClassLoader();
      Enumeration<URL> resources = null;
      try {
// 读取xml文件资源，获取默认的流程引擎，配置文件名称必须为activiti.cfg.xml
        resources = classLoader.getResources("activiti.cfg.xml");
      } catch (IOException e) {
        throw new ActivitiIllegalArgumentException("problem retrieving activiti.cfg.xml resources on the classpath: "+System.getProperty("java.class.path"), e);
      }
// Set集合去重操作
      Set<URL> configUrls = new HashSet<URL>();
      while (resources.hasMoreElements()) {
        configUrls.add( resources.nextElement() );
      }
      for (Iterator<URL> iterator = configUrls.iterator(); iterator.hasNext();) {
        URL resource = iterator.next();
        log.info("Initializing process engine using configuration '{}'",  resource.toString());
 // 初始化流程引擎
        initProcessEnginFromResource(resource);
      }
       // 通过Spring的配置初始化Activiti的流程引擎，我这个demo里并未配置
      try {
        resources = classLoader.getResources("activiti-context.xml");
      } catch (IOException e) {
        throw new ActivitiIllegalArgumentException("problem retrieving activiti-context.xml resources on the classpath: "+System.getProperty("java.class.path"), e);
      }
      while (resources.hasMoreElements()) {
        URL resource = resources.nextElement();
        log.info("Initializing process engine using Spring configuration '{}'",  resource.toString());
        initProcessEngineFromSpringResource(resource);
      }

      setInitialized(true);
    } else {
      log.info("Process engines already initialized");
    }
  }
复制代码

      initProcessEnginFromResource(resource);方法如下

复制代码
private static ProcessEngineInfo initProcessEnginFromResource(URL resourceUrl) {
  // 获取文件中的流程引擎信息
    ProcessEngineInfo processEngineInfo = processEngineInfosByResourceUrl.get(resourceUrl.toString());
    // 如果流程引擎信息在容器中已经存在，则移除容器中的流程引擎信息
    if (processEngineInfo!=null) {
      processEngineInfos.remove(processEngineInfo);
      if (processEngineInfo.getException()==null) {
        String processEngineName = processEngineInfo.getName();
        processEngines.remove(processEngineName);
    processEngineInfosByName.remove(processEngineName);
      }
      processEngineInfosByResourceUrl.remove(processEngineInfo.getResourceUrl());
    }

    String resourceUrlString = resourceUrl.toString();
    try {
      log.info("initializing process engine for resource {}", resourceUrl);
  // 通过xml文件资源初始化流程引擎
      ProcessEngine processEngine = buildProcessEngine(resourceUrl);
      String processEngineName = processEngine.getName();
      log.info("initialised process engine {}", processEngineName);
      processEngineInfo = new ProcessEngineInfoImpl(processEngineName, resourceUrlString, null);
// 将流程引擎实例放入流程引擎容器中
      processEngines.put(processEngineName, processEngine);
      processEngineInfosByName.put(processEngineName, processEngineInfo);
    } catch (Throwable e) {
      log.error("Exception while initializing process engine: {}", e.getMessage(), e);
      processEngineInfo = new ProcessEngineInfoImpl(null, resourceUrlString, getExceptionString(e));
    }
processEngineInfosByResourceUrl.put(resourceUrlString, processEngineInfo);
// 将流程引擎信息实例放入流程引擎信息容器中
    processEngineInfos.add(processEngineInfo);
    return processEngineInfo;
  }
复制代码

       就罗列以上几种流程引擎初始化的方式，简单记录下，方便以后复习。

posted @   无虑的小猪  阅读(647)  评论(0)  编辑  收藏  举报
编辑推荐：
· 记一次.NET内存居高不下排查解决与启示
· 探究高空视频全景AR技术的实现原理
· 理解Rust引用及其生命周期标识（上）
· 浏览器原生「磁吸」效果！Anchor Positioning 锚点定位神器解析
· 没有源码，如何修改代码逻辑？
阅读排行：
· 分享4款.NET开源、免费、实用的商城系统
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
· 上周热点回顾（2.24-3.2）
点击右上角即可分享
微信分享提示