Flowable源码注释（五）引擎生命周期监听器

Flowable源码地址：https://github.com/flowable/flowable-engine

EngineLifecycleListener 引擎生命周期监听器接口类

描述在特定事件发生时收到通知的监听器接口，该事件与它所连接的引擎生命周期有关。

package org.flowable.common.engine.api.engine;

import org.flowable.common.engine.api.Engine;

/**
 * @author Frederik Heremans
 * @author Joram Barrez
 */
public interface EngineLifecycleListener {

    /**
     * 引擎创建完成后立即调用.
     */
    void onEngineBuilt(Engine engine);

    /**
     * 引擎关闭后立即调用.
     */
    void onEngineClosed(Engine engine);

}

ProcessEngineLifecycleListener 流程引擎生命周期监听器接口类，继承EngineLifecycleListener接口

描述在特定事件发生时收到通知的监听器接口，该事件与它所连接的流程引擎生命周期有关。

package org.flowable.engine;

import org.flowable.common.engine.api.Engine;
import org.flowable.common.engine.api.engine.EngineLifecycleListener;

/** 
 * @author Frederik Heremans
 */
public interface ProcessEngineLifecycleListener extends EngineLifecycleListener {

    @Override
    default void onEngineBuilt(Engine engine) {
        onProcessEngineBuilt((ProcessEngine) engine);
    }

    @Override
    default void onEngineClosed(Engine engine) {
        onProcessEngineClosed((ProcessEngine) engine);
    }

    /**
     * 流程引擎创建完成后立即调用.
     * 
     * @param processEngine
     *            已被创建的引擎
     */
    void onProcessEngineBuilt(ProcessEngine processEngine);

    /**
     * 流程引擎关闭后立即调用d.
     * 
     * @param processEngine
     *            已被关闭的引擎
     */
    void onProcessEngineClosed(ProcessEngine processEngine);

}

CloseXADataSourceLifecycleListener 关闭XA数据源生命周期监听器类

在JPA测试中用于在引擎关闭后关闭XA数据源，因为数据源的内部缓存独立于流程引擎和spring上下文

package org.flowable.standalone.jta;

import org.flowable.engine.ProcessEngine;
import org.flowable.engine.ProcessEngineLifecycleListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import bitronix.tm.BitronixTransactionManager;
import bitronix.tm.resource.jdbc.PoolingDataSource;

public class CloseXADataSourceLifecycleListener implements ProcessEngineLifecycleListener {

    private PoolingDataSource dataSource;
    private BitronixTransactionManager transactionManager;

    private static final Logger LOGGER = LoggerFactory.getLogger(CloseXADataSourceLifecycleListener.class);

    @Override
    public void onProcessEngineBuilt(ProcessEngine processEngine) {
        LOGGER.info("--------------------- Callback for engine start");
    }

    @Override
    public void onProcessEngineClosed(ProcessEngine processEngine) {
        LOGGER.info("--------------------- Callback for engine end");
        if (dataSource != null) {
            LOGGER.info("--------------------- Closing datasource");
            dataSource.close();
        }

        if (transactionManager != null) {
            transactionManager.shutdown();
        }
    }

    public void setDataSource(PoolingDataSource dataSource) {
        this.dataSource = dataSource;
    }

    public void setTransactionManager(BitronixTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

}

SchemaOperationsProcessEngineBuild 模式操作流程引擎创建

public class SchemaOperationsProcessEngineBuild implements Command<Void> {
    
    private static final Logger LOGGER = LoggerFactory.getLogger(SchemaOperationsProcessEngineBuild.class);

    @Override
    public Void execute(CommandContext commandContext) {
        
        SchemaManager schemaManager = CommandContextUtil.getProcessEngineConfiguration(commandContext).getSchemaManager();
        String databaseSchemaUpdate = CommandContextUtil.getProcessEngineConfiguration().getDatabaseSchemaUpdate();
        
        LOGGER.debug("Executing schema management with setting {}", databaseSchemaUpdate);
        if (ProcessEngineConfiguration.DB_SCHEMA_UPDATE_DROP_CREATE.equals(databaseSchemaUpdate)) {
            try {
                schemaManager.schemaDrop();
            } catch (RuntimeException e) {
                // ignore
            }
        }
        if (ProcessEngineConfiguration.DB_SCHEMA_UPDATE_CREATE_DROP.equals(databaseSchemaUpdate)
                || ProcessEngineConfigurationImpl.DB_SCHEMA_UPDATE_DROP_CREATE.equals(databaseSchemaUpdate) || ProcessEngineConfigurationImpl.DB_SCHEMA_UPDATE_CREATE.equals(databaseSchemaUpdate)) {
            schemaManager.schemaCreate();

        } else if (ProcessEngineConfiguration.DB_SCHEMA_UPDATE_FALSE.equals(databaseSchemaUpdate)) {
            schemaManager.schemaCheckVersion();

        } else if (ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE.equals(databaseSchemaUpdate)) {
            schemaManager.schemaUpdate();
        }
        
        return null;
    }
}

SchemaOperationProcessEngineClose 模式操作流程引擎关闭

public class SchemaOperationProcessEngineClose implements Command<Void> {

    @Override
    public Void execute(CommandContext commandContext) {
        ProcessEngineConfigurationImpl processEngineConfiguration = CommandContextUtil.getProcessEngineConfiguration(commandContext);
        if (processEngineConfiguration.isUsingRelationalDatabase()) {
            ((ProcessDbSchemaManager) processEngineConfiguration.getSchemaManager()).performSchemaOperationsProcessEngineClose();
        }
        return null;
    }
}