Activiti——流程引擎配置详解

Activiti流程引擎配置

启动Activiti流程引擎时，需要配置一系列的参数，告诉Activiti以何种方式进行工作。这些可以配置的参数包括数据库配置、事务配置和Activiti内置的服务配置等。在实际应用的过程中，有可能存在需要加入更个性化配置的情况，如果发现Activiti提供的配置项不能满足要求，则可以对Activiti的配置进行扩展，加入自定义的个性化配置。

1、流程引擎配置对象

ProcessEngineConfiguration对象代表一个Activiti流程引擎的全部配置，该类提供一系列创建ProcessEngineConfiguration实例的静态方法，这些方法用于读取和解析相应的配置文件，并返回ProcessEngineConfiguration的实例。除了这些静态方法外，该类还为其他可配置的引擎属性提供相应的setter和getter方法。

1.1、读取默认的配置文件

ProcessEngineConfiguration 对象的createProcessEngineConfigurationFromResourceDefault
方法，使用Activiti默认的方式创建ProcessEngineConfiguration的实例。这里所说的默认方式，是指由Activiti指定读取配置文件的位置、文件的名称和配置bean的名称这些信息。Activiti默认到ClassPath下读取名为“activiti.cfg.xml”的Activiti配置文件，启动并获取名称为“processEngineConfiguration”的bean的实例。解析XML与创建该bean实例的过程，由Spring代为完成。

使用过Spring的朋友知道，只需要指定Spring的XML配置文件，创建相应的BeanFactory实例，再通过getBean(bean名称)方法即可获取相应对象的实例，ProcessEngineConfiguration对象使用Spring框架的DefaultListableBeanFactory作为BeanFactory。

//使用Activiti默认的方式创建ProcessEngineConfiguration
ProcessEngineConfiguration config = ProcessEngineConfiguration.createProcessEngineConfigurationFromResourceDefault();
System.out.println(config);

Activiti默认到ClassPath下读取activiti.cfg.xml文件。

• 如果找不到该配置文件则抛出FileNotFoundException;
• 如果找不到名称为processEngineConfiguration的bean,则抛出org.springframework.beans.factory.NoSuchBeanDefinitionException。

1.2、读取自定义的配置文件

默认情况下Activiti将到ClassPath下读取activiti.cfg.xml文件，如果希望Activiti读取另外名称的配置文件，则可以使用createProcessEngineConfigurationFromResource方法创建ProcessEngineConfiguration,该方法的参数为一个字符串对象，当调用该方法时，需要告诉Activiti配置文件的位置。

//指定配置文件创建ProcessEngineConfiguration
ProcessEngineConfiguration config = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("my-activiti.xml");
System.out.println(config);

Activiti会到ClassPath下查找my-activiti.xml配置文件，并创建名称为“processEngineConfiguration”的bean,此处创建bean的过程与前面描述的一致。

ProcessEngineConfiguration对象中还有一个createProcessEngineConfigurationFromResource的重载方法，该方法需要提供两个参数来创建ProcessEngineConfiguration:第一个参数为Activiti
配置文件的位置；第二个参数为创建bean的名称。

ProcessEngineConfiguration config = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("my-activiti.xml", "test");
System.out.println(config.getProcessEngineName());

1.3、读取输入流的配置

ProcessEngineConfiguration对象中提供了一个createProcessEngineConfigurationFromInputStream方法，该方法使得Activiti配置文件的加载不再局限于项目的ClassPath,只要得到配置文件的输入流，即可创建ProcessEngineConfiguration。

同样createProcessEngineConfigurationFromInputStream方法也有两个重载的方法，可以指定在解析XML时bean的名称。

File file = new File("resource/input-stream.xml");
InputStream fis = new FileInputStream(file);
ProcessEngineConfiguration config = ProcessEngineConfiguration.createProcessEngineConfigurationFromInputStream(fis, "test");
System.out.println(config.getProcessEngineName());

1.4、使用默认内存配置

使用该方法创建ProcessEngineConfiguration,并不需要指定任何参数，该方法直接返回一个StandaloneInMemProcessEngineConfiguration实例，该类为ProcessEngineConfiguration的子类。使用该方法创建ProcessEngineConfiguration,并不会读取任何Activiti配置文件，这意味着流程引擎配置的全部属性都会使用默认值。与其他子类不一样的是，创建的
StandaloneInMemProcessEngineConfiguration实例，只特别指定了databaseSchemaUpdate属性
和jdbcUrl属性。

ProcessEngineConfiguration config = ProcessEngineConfiguration.createStandaloneInMemProcessEngineConfiguration();
//值为create-drop
System.out.println(config.getDatabaseSchemaUpdate());
//值为jdbc:h2:mem:activiti
System.out.println(config.getJdbcUrl());

该方法不需要读取任何配置文件，ClassPath下也没有任何Activiti配置文件，如果需要改变相关的配置，则可以调用ProcessEngineConfiguration中相应的setter方法进行修改。

createStandaloneInMemProcessEngineConfiguration方法返回的是一个org.activiti.engine.impl.cfg.StandaloneInMemProcessEngineConfiguration实例。如果使用配置文件的方式创建Process-
EngineConfiguration,则可以将该类配置为bean的class,但使用时需要注意该类中属性的默认值。

1.5、使用createStandaloneProcessEngineConfiguration方法

createStandaloneProcessEngineConfiguration方法返回一个StandaloneProcessEngineConfiguration实例，并且需要注意的是，StandaloneInMemProcessEngineConfiguration类是StandaloneProcessEngineConfiguration类的子类。

ProcessEngineConfiguration config = ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
//默认值为false
System.out.println(config.getDatabaseSchemaUpdate());
//默认值为jdbc:h2:tcp://localhost/~/activiti
System.out.println(config.getJdbcUrl());

2、数据源配置

Activiti在启动时，会读取数据源配置，以便对数据库进行相应的操作。由前面的讲述我们知道，Activiti会先读取配置文件，然后取得配置的bean,并对其进行初始化。

2.1、Activiti支持的数据库

Activiti默认支持H2数据库，H2是一个开源的嵌入式数据库，使用Java语言编写而成。使用H2数据库并不需要另外安装服务器或者客户端，只需要提供一个jar包即可。在实际的企业应用中，很少会使用这种轻量级的嵌入式数据库，因此H2数据库更适合用于单元测试。除了H2数据库外，Activiti还为以下的数据库提供支持。

• MySQL：主流数据库之一，它是一个开源的小型关系型数据库，由于它体积小、速度快，受到相当多开发者的青睐，并且最重要的是，它是免费的。
• Oracle:目前世界上最流行的商业数据库，价格昂贵，但是它高效的性能、可靠的数据管理，仍令不少企业心甘情愿为其掏钱。
• PostgreSQL:PostgreSQL是另外一款开源的数据库。
• DB2:由BM公司研发的一款关系型数据库，其良好的伸缩性和数据库的高效性，让它成为继Oracle之后，又一款应用广泛的商业数据库。
• MSSQL:微软研发的一款数据库产品，目前也支持在Liux下使用。

2.2、Activiti与Spring

Spring是目前非常流行的一个轻量级J2EE框架，它提供了一套轻量级的企业应用解决方案，包括IoC容器、AOP面向切面技术及Web MVC框架等。

使用Activiti的项目，并不意味着一定要使用Spring,Activiti可以在没有Spring的环境中使用。虽然Activiti并不需要使用Spring环境，但是Activiti在创建流程引擎时，却使用了Spring的XML解析与依赖注入功能，ProcessEngineConfiguration对应的配置，即为Spring中的一个bean。

2.3、JDBC配置

使用DBC连接数据库，需要使用jdbc url、jdbc驱动、数据库用户名和密码。以下代码为连接MySQL的配置：

<bean id="processEngineConfiguration"
          class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
       <property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/activiti" />
        <property name="jdbcUsername" value="root" />
        <property name="jdbcPassword" value="123456" />
    </bean>

2.4、DBCP数据源配置

DBCP是Apache提供的一个数据库连接池。ProcessEngineConfiguration中提供了一个dataSource属性，如果用户不希望将JDBC的相关连接属性交给Activiti.,则可以自己创建数据库连接，然后通过这个dataSource属性设置到ProcessEngineConfiguration中。为Activiti的
ProcessEngineConfiguration设置dataSource,可以采用配置或者编写代码的方式。

<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/activiti" />
    <property name="username" value="root" />
    <property name="password" value="123456" />
</bean>
<bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
	<property name="dataSource" ref="dataSource"/>
</bean>

代码配置了一个DBCP的dataSource bean,然后在processEngineConfiguration的bean中注入该dataSource。在初始化流程引擎配置时，只需根据情况调用ProcessEngineConfiguration的createXXX方法即可，如以下代码所示：

//读取dbcp-config.xml配置
ProcessEngineConfiguration config = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("dbcp-config.xml");
//能正常输出，即完成配置
DataSource ds = config.getDataSource();
//查询数据库元信息，如果能查询则表示连接成功
ds.getConnection().getMetaData();
//结果为org.apache.commons.dbcp.BasicDataSource
System.out.println(ds.getClass().getName());

本例使用createProcessEngineConfigurationFromResource方法读取Activiti的配置文件。除使用配置方式外，也可以通过编码方式设置相应的dataSource,只需要先创建一个DataSource对象，然后将其设置到ProcessEngineConfiguration中即可。

//创建DBCP数据源
BasicDataSource ds = new BasicDataSource();
ds.setUsername("root");
ds.setPassword("123456");
ds.setUrl("jdbc:mysql://localhost:3306/activiti");
ds.setDriverClassName("com.mysql.jdbc.Driver");
//验证是否连接成功
ds.getConnection().getMetaData();
//读取Activiti配置文件
ProcessEngineConfiguration config = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("dbcp-coding.xml");
//设置数据源
config.setDataSource(ds);
System.out.println(config.getDataSource());

先创建了DataSource对象，随后为该对象设置相应的数据库连接属性，然后读取Activiti配置文件，得到ProcessEngineConfiguration对象，并将DataSource设置到该对象中。ProcessEngineConfiguration的bean配置不需要设置任何属性：

<!-- 不初始化任何属性 -->
<bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
</bean>

2.5、C3P0数据源配置

与DBCP类似，C3P0也是一个开源的数据库连接池，它们都被广泛地应用到开源项目以及企业中。与DBCP类似，可以在Activiti中使用C3P0数据源，配置方式大致相同：

<!-- 这里可以使用 链接池 C3P0-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver" />
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/activiti" />
    <property name="user" value="root" />
    <property name="password" value="123456" />
</bean>

<bean id="processEngineConfiguration"
      class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
    <!-- 引用数据源 上面已经设置好了-->
    <property name="dataSource" ref="dataSource" />
    <!-- activiti数据库表处理策略 -->
    <property name="databaseSchemaUpdate" value="true"/>
</bean>

除了使用配置方式外，也可以使用编码方式创建C3P0数据源，设置方式基本与DBCP相同，只是创建DataSource实例的方式不一样而已:

ComboPooledDataSource ds = new ComboPooledDataSource();
ds.setUser("root");
ds.setPassword("123456");
ds.setJdbcUrl("jdbc:mysql://localhost:3306/activiti");
ds.setDriverClass("com.mysql.jdbc.Driver");
ds.getConnection().getMetaData();
ProcessEngineConfiguration config = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("c3p0-coding.xml");
config.setDataSource(ds);
System.out.println(config.getDataSource());

2.6、Activiti其他数据源配置

如果不使用第三方数据源，可以直接使用Activiti提供的数据源，并且还可以指定其他些数据库属性。Activiti默认使用的是yBatis的数据连接池，因此ProcessEngineConfiguration中也提供了一些MyBatis的配置。

• jdbcMaxActiveConnections:在数据库连接池内最大的活跃连接数，默认值为l0。
• jdbcMaxIdleConnections:连接池最大的空闲连接数。
• jdbcMaxCheckoutTime:当连接池内的连接耗尽，外界向连接池请求连接时，创建连接的等待时间，单位为ms,默认值为20000，即20s。
• jdbcMaxWaitTime:当整个连接池需要重新获取连接时，设置的等待时间，单位为ms,默认值为20000，即20s。

2.7、数据库策略配置

ProcessEngineConfiguration提供databaseSchemaUpdate属性，使用该属性可以设置流程引擎启动和关闭时数据库执行的策略。在Activiti的官方文档中，databaseSchemaUpdate有以下三个值。

• false:false为默认值，设置为该值后，Activiti在启动时，会对比数据库表中保存的版本，如果没有表或者版本不匹配，将在启动时抛出异常。
• true:设置为该值后，Activiti会对数据库中所有的表进行更新，如果表不存在，则Activiti会自动创建。
• create-drop:Activiti启动时，会执行数据库表的创建操作；在Activiti关闭时，执行数据库表的删除操作。

<bean id="processEngineConfiguration"
          class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
   <property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/activiti" />
    <property name="jdbcUsername" value="root" />
    <property name="jdbcPassword" value="123456" />
    <property name="databaseSchemaUpdate" value="false"/>
</bean>

ProcessEngineConfiguration config = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("schemaUpdate-false.xml");
//启动Activiti
config.buildProcessEngine();

如果想要Activiti执行“drop”操作，必须调用
ProcessEngine的close方法，否则将不会删除表。一般情况下，将databaseSchemaUpdate配置为create-drop,更适合在单元测试中使用。除了false、true和create-drop三个值外，databaseSchemaUpdate还有T个drop-create值。
与create-.drop类似，drop-create会在流程引擎启动时，先将原来全部的数据表删除，再进行创建。与create-drop不同的是，不管是否调用ProcessEngine的close方法，都会执行create操作。

同样，该值在单元测试中使用比较合适，在流程引擎初始化时将原有的数据删除，在实际应用中，此举会带来较大的风险，Activiti的官方文档并没有提供该项配置，读者知道即可。

2.8、databaseType配置

如果将databaseSchemaUpdate设置为create-drop或者drop-create,Activiti在启动和初始化时，会执行相应的创建表和删除表操作，而Activiti支持多种数据库，每种数据库的创建表与删除表的语法有可能不一样，因此，需要指定databaseType属性，来告诉Activiti,.目前使用了何种数据库（当然，如果设置为true而数据库中没有表的话，也需要
知道使用哪种数据库)。databaseType属性支持这些值：h2、mysql、oracle、postgres、mssql、db2,当没有指定值时，databaseType为null。指定databaseType属性，目的是为了确定执行创建（或删除）表的SQL脚本。

<bean id="processEngineConfiguration"
          class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
   <property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/activiti" />
    <property name="jdbcUsername" value="root" />
    <property name="jdbcPassword" value="123456" />
    <property name="databaseSchemaUpdate" value="false"/>
    <property name="databaseType" value="oracle"/>
</bean>

3、其他属性配置

3.1、history配置

在流程执行的过程中，会产生一些流程相关的数据，例如流程实例、流程任务和流程参数等，随着流程的进行与结束，这些数据将会被从流程数据表中删除，为了能保存这些数据，Activiti提供了历史数据表，可以将这些数据保存到历史数据表中。

对于这些历史数据，保存到何种粒度，Activiti提供history属性对其进行配置。history属性有点像1og4j的日志输出级别，该属性有以下四个值。

• none:不保存任何的历史数据，因此，在流程执行过程中，这是最高效的。
• activity:级别高于none,保存流程实例与流程行为，其他数据不保存。
• audit:除activity级别会保存的数据外，还会保存全部的流程任务及其属性数据。audit为history的默认值。
• full:保存历史数据的最高级别，除了会保存audit级别的数据外，还会保存其他全部流程相关的细节数据，包括一些流程参数等。

3.2、异步执行器配置

asyncExecutorActivate属性主要用于配置异步执行器是否启动，true则表示Activiti在创建流程引擎时，需要启动异步执行器，该属性默认值为flse。异步执行器启动后，会启动定时器扫描并执行各种工作，如果查找到符合执行条件的工作，则会启动一条线程并交由线程池去执行。

3.3、邮件服务器配置

Activiti支持邮件服务，当流程执行到某一个节点时，Activiti会根据流程文件配置(Email Task),发送邮件到相应的邮箱。以下为ProcessEngineConfiguration中提供的邮件服务器配置项。

• mailServerHost:邮件服务器地址，非必填，默认值为localhost。
• mailServerPort:SMTP发送邮件服务器端口，默认值为25。
• mailServerDefaultFrom:非必填，发送人的邮箱地址，默认值为activiti@activiti.org。
• mailServerUsername:邮箱登录用户名。
• mailServerPassword:邮箱登录密码。
• mailServerUseSSL:是否使用SSL协议通信，默认为false。
• mailServerUseTLS:是否使用TLS协议通信，默认为false。

使用SMTP协议发送邮件，需要知道邮件服务器地址、SMTP端口、邮箱登录用户名和密码：

<bean id="processEngineConfiguration"
      class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
    <!-- 引用数据源 上面已经设置好了-->
    <property name="dataSource" ref="dataSource" />
    <!-- activiti数据库表处理策略 -->
    <property name="databaseSchemaUpdate" value="true"/>
    <!-- 邮件配置 -->
    <property name="mailServerHost" value="smtp.163.com"/>
    <property name="mailServerPort" value="25"/>
    <property name="mailServerDefaultFrom" value="xxxx@163.com"/>
    <property name="mailServerUsername" value="xxxx"/>
    <property name="mailServerPassword" value="xxxxx"/>
</bean>

4、ProcessEngineConfiguration

4.1、ProcessEngineConfiguration及其子类

ProcessEngineConfiguration代表Activiti的一个配置实例，ProcessEngineConfiguration本身是一个抽象类，因此要配置bean的话，需要知道其子类。Activiti提供了多个ProcessEngineConfiguration的子类，其中官方文档谈及了四个子类的作用。

• org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration:使用该类作为配置对象，Activiti将会对事务进行管理，默认情况下，流程引擎启动时将会检查数据库结构以及版本是否正确。
• org.activiti.engine.impl.cfg.StandalonelnMemProcessEngineConfiguration:StandaloneProcessEngineConfiguration的子类，同样由Activiti进行事务管理，但是该类设置了databaseSchemaUpdate(create-drop)和jdbcUrl(jdbc:h2:mem:activiti)属性，以便可以在单元测试中使用。
• org.activiti…spring.SpringProcessEngineConfiguration:当Activiti与Spring进行整合时，可以使用该类。
• org.activiti…engine.impl.cfg.JtaProcessEngineConfiguration:不使用Activiti的事务，使用JTA进行事务管理。

4.2、自定义ProcessEngineConfiguration

可以选择继承ProcessEngineConfiguration或者它的直接子类ProcessEngineConfigurationImpl。

继承ProcessEngineConfigurationImpl,需要实现createTransactionInterceptor方法。可以为自己的ProcessEngineConfiguration类添加属性，并且添加相应的setter方法。

public class MyConfifuration extends ProcessEngineConfigurationImpl {

    public MyConfifuration() {
    }

    //测试属性，需要在processEngineConfiguration注入
    private String userName;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public CommandInterceptor createTransactionInterceptor() {
        return null;
    }
}

MyConfiguration类继承ProcessEngineConfigurationImpl,并实现了createTransactionInterceptor方法，在此不需要实现，返回null即可。在MyConfiguration类中定义了一个userName属性，可以在配置processEngineConfiguration的XML文件中为其设置相应的值

<bean id="processEngineConfiguration"
      class="pers.zhang.MyConfiguration">
    <!-- 引用数据源 上面已经设置好了-->
    <property name="dataSource" ref="dataSource" />
    <!-- activiti数据库表处理策略 -->
    <property name="databaseSchemaUpdate" value="true"/>
    <property name="userName" value="testValue" />
</bean>

MyConfifuration confifuration = (MyConfifuration) ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("my-config.xml");
confifuration.buildProcessEngine();
System.out.println(confifuration.getUserName());

5、Activiti的命令拦截器

Activiti提供了命令拦截器功能，外界对Activiti流程中各个实例进行的操作，实际可以看作对数据进行的相应操作，在此过程中，Activiti使用了设计模式中的命令模式，每一个操作数据库的过程，均可被看作一个命令，然后交由命令执行者去完成。

5.1、命令模式

在GoF的设计模式中，命令模式属于行为型模式，它把一个请求或者操作封装到命令对象中，这些请求或者操作的内容包括接收者信息，然后将该命令对象交由执行者执行，执行者不需要关心命令的接收人或者命令的具体内容，因为这些信息均被封装到命令对象中。命令模式中涉及的角色及其作用如下。

• 命令接口(Command):声明执行操作的接口。
• 接口实现(ConcreteCommand):命令接口实现，需要保存接收者的相应操作，并执行相应的操作。
• 命令执行者(Invoker)：要求命令执行此次请求。
• 命令接收人(Receiver):由命令接口的实现类来维护Receiver实例，并在命令执行时处理相应的任务。

5.2、责任链模式

与命令模式一样，责任链模式也是GoF的设计模式之一，同样也是行为型模式。该设计模式让多个对象都有机会处理请求，从而避免了请求发送者和请求接收者之间的耦合。这些请求接收者将组成一条链，并沿着这条链传递请求，直到有一个对象处理这个请求为止，这就形成了一条责任链。责任链模式有以下参与者。

• 请求处理者接口(Handler)：定义一个处理请求的接口，可以实现后继链
• 请求处理者实现(ConcreteHandler):请求处理接口的实现，如果它可以处理请求就处理，否则就将该请求转发给它的后继者。

5.3、自定义拦截器

public class InterceptorA implements CommandInterceptor {
    
    private CommandInterceptor next;
    
    public <T> T execute(CommandConfig commandConfig, Command<T> command) {
        //输出字符串和命令
        System.out.println("this is interceptor A: " + command.getClass().getName());
        //然后让责任链中的下一请求者处理命令
        return getNext().execute(commandConfig, command);
    }

    public CommandInterceptor getNext() {
        return this.next;
    }

    public void setNext(CommandInterceptor commandInterceptor) {
        this.next = commandInterceptor;
    }
}

InterceptorA类实现CommandInterceptor接口，当实现责任链模式时，在拦截器的execute方法中，执行完拦截器自己的程序后（输出业务命令），会执行责任链的下一个拦截器的execute方法。了解了责任链模式的原理后，不难发现，此处的next就是拦截器中的下一任请求处理者，而此处的请求，则是命令模式中的Command接口，编写的
InterceptorA就是责任链模式中请求处理者的其中一个实现。

使用同样的方式，创建拦截器B,与拦截器A类似，其输出字符串与业务命令，再将请求（此处为Command)交由下一执行者执行。完成了两个拦截器后，再去实现父类的初始化拦截器方法，将拦截器“侵入”到Activiti的责任链中:

public class TestConfiguration extends ProcessEngineConfigurationImpl {
    public CommandInterceptor createTransactionInterceptor() {
        //不实现事务拦截器
        return null;
    }

    @Override
    public void initCommandInterceptors() {
        //为父类的命令集合添加拦截器
        customPreCommandInterceptors = new ArrayList<CommandInterceptor>();
        customPreCommandInterceptors.add(new InterceptorA());
        customPreCommandInterceptors.add(new InterceptorB());
        //再次调用父类的实例化方法
        super.initCommandInterceptors();
    }
}

ProcessEngineConfiguration configuration = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("my-config.xml");
ProcessEngine processEngine = configuration.buildProcessEngine();
//不是一个简单流程
processEngine.getRepositoryService().createDeployment()
        .addClasspathResource("hello.BPMN20.xml").deploy();
//构建流程参数
Map<String, Object> vars = new HashMap<String, Object>();
vars.put("day", 10);
//开始流程
processEngine.getRuntimeService().startProcessInstanceByKey("vacationProcess", vars);