org.flowable.spring.SpringProcessEngineConfiguration Java Examples

/**
 * Takes in an V6 process engine config, gives back an V5 Process engine.
 */
@Override
public ProcessEngine buildProcessEngine(ProcessEngineConfigurationImpl v6Configuration) {

    org.activiti.engine.impl.cfg.ProcessEngineConfigurationImpl v5Configuration = null;
    if (v6Configuration instanceof SpringProcessEngineConfiguration) {
        v5Configuration = new org.activiti.spring.SpringProcessEngineConfiguration();
        super.copyConfigItems(v6Configuration, v5Configuration);
        copySpringConfigItems((SpringProcessEngineConfiguration) v6Configuration, (org.activiti.spring.SpringProcessEngineConfiguration) v5Configuration);
        return v5Configuration.buildProcessEngine();

    } else {
        return super.buildProcessEngine(v6Configuration);
    }

}
 

@Bean
public EngineConfigurationConfigurer<SpringProcessEngineConfiguration> debuggerProcessEngineConfigurationConfigurer(
    FlowableEngineAgendaFactory agendaFactory) {
    return processEngineConfiguration -> {
        processEngineConfiguration.setEnableDatabaseEventLogging(true);
        processEngineConfiguration.setAgendaFactory(agendaFactory);
        processEngineConfiguration.addCustomJobHandler(new BreakpointJobHandler());

        List<AsyncRunnableExecutionExceptionHandler> customAsyncRunnableExecutionExceptionHandlers = processEngineConfiguration.getCustomAsyncRunnableExecutionExceptionHandlers();
        ArrayList<AsyncRunnableExecutionExceptionHandler> exceptionHandlers;
        if (customAsyncRunnableExecutionExceptionHandlers == null) {
            exceptionHandlers = new ArrayList<>();
        } else {
            exceptionHandlers = new ArrayList<>(customAsyncRunnableExecutionExceptionHandlers);
        }
        exceptionHandlers.add(new DefaultDebuggerExecutionExceptionHandler());
        processEngineConfiguration.setCustomAsyncRunnableExecutionExceptionHandlers(exceptionHandlers);
    };
}
 

@Test
public void withEntityManagerFactoryBeanAndMissingSpringProcessEngineConfigurationClass() {
    contextRunner
        .withConfiguration(AutoConfigurations.of(
            DataSourceAutoConfiguration.class,
            HibernateJpaAutoConfiguration.class
        ))
        .withClassLoader(new FilteredClassLoader(SpringProcessEngineConfiguration.class))
        .run(context -> {
            assertThat(context).doesNotHaveBean(FlowableJpaAutoConfiguration.class);
        });
}
 

protected void copySpringConfigItems(SpringProcessEngineConfiguration v6Configuration, org.activiti.spring.SpringProcessEngineConfiguration v5Configuration) {
    v5Configuration.setApplicationContext(v6Configuration.getApplicationContext());
    v5Configuration.setTransactionManager(v6Configuration.getTransactionManager());

    Map<Object, Object> beans = v6Configuration.getBeans();

    if (!(beans instanceof org.flowable.common.engine.impl.cfg.SpringBeanFactoryProxyMap)) {
        v5Configuration.setBeans(new SpringBeanFactoryProxyMap(v6Configuration.getApplicationContext()));
    }
    if (v5Configuration.getExpressionManager() == null) {
        v5Configuration.setExpressionManager(new SpringExpressionManager(v6Configuration.getApplicationContext(), v6Configuration.getBeans()));
    }
}
 

@Bean
public SpringProcessEngineConfiguration processEngineConfiguration(DataSource dataSource, PlatformTransactionManager transactionManager,
    JobManager jobManager) {
    SpringProcessEngineConfiguration configuration = new SpringProcessEngineConfiguration();
    configuration.setDataSource(dataSource);
    configuration.setTransactionManager(transactionManager);
    configuration.setDatabaseSchemaUpdate(SpringProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
    configuration.setAsyncExecutorMessageQueueMode(true);
    configuration.setAsyncExecutorActivate(true);
    configuration.setJobManager(jobManager);
    return configuration;
}
 

@Bean
public SpringProcessEngineConfiguration processEngineConfiguration(DataSource dataSource, PlatformTransactionManager transactionManager) {
    SpringProcessEngineConfiguration configuration = new SpringProcessEngineConfiguration();
    configuration.setDataSource(dataSource);
    configuration.setTransactionManager(transactionManager);
    configuration.setDatabaseSchemaUpdate("true");
    return configuration;
}
 

@Override
public void configure(SpringProcessEngineConfiguration engineConfiguration) {
    engineConfiguration.setActivityFontName("宋体");
    engineConfiguration.setLabelFontName("宋体");
    engineConfiguration.setAnnotationFontName("宋体");
    StrongUuidGenerator uuidGenerator = new StrongUuidGenerator();
    engineConfiguration.setIdGenerator(uuidGenerator) ;
}
 

@Bean
@ConditionalOnMissingBean(name = "dmnProcessEngineConfigurationConfigurer")
public EngineConfigurationConfigurer<SpringProcessEngineConfiguration> dmnProcessEngineConfigurationConfigurer(
    DmnEngineConfigurator dmnEngineConfigurator
) {
    return processEngineConfiguration -> processEngineConfiguration.addConfigurator(dmnEngineConfigurator);
}
 

@ConditionalOnMissingBean(name = "jpaProcessEngineConfigurer")
@Bean
public EngineConfigurationConfigurer<SpringProcessEngineConfiguration> jpaProcessEngineConfigurer(EntityManagerFactory emf) {
    return processEngineConfiguration -> {
        processEngineConfiguration.setJpaEntityManagerFactory(emf);
        processEngineConfiguration.setJpaHandleTransaction(false);
        processEngineConfiguration.setJpaCloseEntityManager(false);
    };
}
 

@Bean
@ConditionalOnMissingBean(name = "idmProcessEngineConfigurationConfigurer")
public EngineConfigurationConfigurer<SpringProcessEngineConfiguration> idmProcessEngineConfigurationConfigurer(
    IdmEngineConfigurator idmEngineConfigurator
) {
    return processEngineConfiguration -> processEngineConfiguration.setIdmEngineConfigurator(idmEngineConfigurator);
}
 

@Bean
public ProcessEngineFactoryBean processEngine(SpringProcessEngineConfiguration configuration) throws Exception {
    ProcessEngineFactoryBean processEngineFactoryBean = new ProcessEngineFactoryBean();
    processEngineFactoryBean.setProcessEngineConfiguration(configuration);
    
    invokeConfigurers(configuration);
    
    return processEngineFactoryBean;
}
 

@Bean
@ConditionalOnMissingBean(name = "formProcessEngineConfigurationConfigurer")
public EngineConfigurationConfigurer<SpringProcessEngineConfiguration> formProcessEngineConfigurationConfigurer(
    FormEngineConfigurator formEngineConfigurator) {
    
    return processEngineConfiguration -> processEngineConfiguration.addConfigurator(formEngineConfigurator);
}
 

@Bean
@ConditionalOnMissingBean(name = "eventProcessEngineConfigurationConfigurer")
public EngineConfigurationConfigurer<SpringProcessEngineConfiguration> eventProcessEngineConfigurationConfigurer(
                EventRegistryEngineConfigurator eventRegistryEngineConfigurator) {
    
    return processEngineConfiguration -> processEngineConfiguration.setEventRegistryConfigurator(eventRegistryEngineConfigurator);
}
 

@Inject
@Bean
@DependsOn("coreChangelog")
public ProcessEngine processEngine(ApplicationContext applicationContext, SpringProcessEngineConfiguration processEngineConfiguration)
    throws Exception {
    ProcessEngineFactoryBean processEngineFactoryBean = new ProcessEngineFactoryBean();
    processEngineFactoryBean.setApplicationContext(applicationContext);
    processEngineFactoryBean.setProcessEngineConfiguration(processEngineConfiguration);
    return processEngineFactoryBean.getObject();
}
 

@Override
public SpringProcessEngineConfiguration springProcessEngineConfiguration(DataSource dataSource, PlatformTransactionManager platformTransactionManager, ObjectProvider<AsyncExecutor> asyncExecutorProvider)
        throws IOException {
    SpringProcessEngineConfiguration conf = super.springProcessEngineConfiguration(dataSource, platformTransactionManager, asyncExecutorProvider);
    String databaseSchema = conf.getDatabaseSchema();
    conf.setDatabaseCatalog(databaseSchema);
    conf.setDatabaseTablePrefix(databaseSchema + ".");
    conf.setTablePrefixIsSchema(true);
    conf.setActivityFontName("黑体");
    conf.setLabelFontName("黑体");
    conf.setAnnotationFontName("黑体");
    return conf;
}
 

@Override
public void configure(SpringProcessEngineConfiguration engineConfiguration) {
    engineConfiguration.setActivityFontName("宋体");
    engineConfiguration.setLabelFontName("宋体");
    engineConfiguration.setAnnotationFontName("宋体");
}
 

@Bean
@ConditionalOnMissingBean(name = "cmmnProcessEngineConfigurationConfigurer")
public EngineConfigurationConfigurer<SpringProcessEngineConfiguration> cmmnProcessEngineConfigurationConfigurer(
    CmmnEngineConfigurator cmmnEngineConfigurator) {
    return processEngineConfiguration -> processEngineConfiguration.addConfigurator(cmmnEngineConfigurator);
}
 

@Bean
public ProcessEngineFactoryBean processEngine(SpringProcessEngineConfiguration processEngineConfiguration) {
    ProcessEngineFactoryBean factoryBean = new ProcessEngineFactoryBean();
    factoryBean.setProcessEngineConfiguration(processEngineConfiguration);
    return factoryBean;
}
 

@Override
public SpringProcessEngineConfiguration getProcessEngineConfiguration() {
    return (SpringProcessEngineConfiguration) processEngineConfiguration;
}
 

@Bean
public ProcessEngineFactoryBean processEngine(SpringProcessEngineConfiguration processEngineConfiguration) {
    ProcessEngineFactoryBean processEngineFactoryBean = new ProcessEngineFactoryBean();
    processEngineFactoryBean.setProcessEngineConfiguration(processEngineConfiguration);
    return processEngineFactoryBean;
}
 

@Bean
public ProcessEngineFactoryBean cmmnEngine(SpringProcessEngineConfiguration processEngineConfiguration) {
    ProcessEngineFactoryBean processEngineFactoryBean = new ProcessEngineFactoryBean();
    processEngineFactoryBean.setProcessEngineConfiguration(processEngineConfiguration);
    return processEngineFactoryBean;
}
 

@Bean
public EngineConfigurationConfigurer<SpringProcessEngineConfiguration> customUserSpringProcessEngineConfigurer() {
    return this::configurationInvoked;
}
 

@Bean
public EngineConfigurationConfigurer<SpringProcessEngineConfiguration> customIdGeneratorConfigurer() {
    return engineConfiguration -> engineConfiguration.setIdGenerator(new DbIdGenerator());
}
 

@Test
public void standaloneProcessEngineWithBasicDatasourceAndCustomAutoDeploymentStrategies() {
    contextRunner.withUserConfiguration(CustomAutoDeploymentStrategyConfiguration.class)
        .run(context -> {
            assertThat(context).as("Process engine").hasSingleBean(ProcessEngine.class);
            assertThat(context)
                .doesNotHaveBean(AppEngine.class)
                .doesNotHaveBean(IdGenerator.class)
                .doesNotHaveBean("processAppEngineConfigurationConfigurer");

            ProcessEngine processEngine = context.getBean(ProcessEngine.class);

            assertThat(processEngine.getProcessEngineConfiguration().getIdGenerator()).isInstanceOf(StrongUuidGenerator.class);

            assertAllServicesPresent(context, processEngine);
            assertAutoDeployment(context);

            assertThat(context).hasSingleBean(CustomUserEngineConfigurerConfiguration.class)
                .getBean(CustomUserEngineConfigurerConfiguration.class)
                .satisfies(configuration -> {
                    assertThat(configuration.getInvokedConfigurations())
                        .containsExactly(
                            SpringProcessEngineConfiguration.class
                        );
                });

            SpringProcessEngineConfiguration springProcessEngineConfiguration = (SpringProcessEngineConfiguration) processEngine
                .getProcessEngineConfiguration();

            Collection<AutoDeploymentStrategy<ProcessEngine>> deploymentStrategies = springProcessEngineConfiguration.getDeploymentStrategies();

            assertThat(deploymentStrategies).element(0)
                .isInstanceOf(TestProcessEngineAutoDeploymentStrategy.class);

            assertThat(deploymentStrategies).element(1)
                .isInstanceOfSatisfying(DefaultAutoDeploymentStrategy.class, strategy -> {
                    assertThat(strategy.isUseLockForDeployments()).isFalse();
                    assertThat(strategy.getDeploymentLockWaitTime()).isEqualTo(Duration.ofMinutes(5));
                });

            assertThat(deploymentStrategies).element(2)
                .isInstanceOfSatisfying(SingleResourceAutoDeploymentStrategy.class, strategy -> {
                    assertThat(strategy.isUseLockForDeployments()).isFalse();
                    assertThat(strategy.getDeploymentLockWaitTime()).isEqualTo(Duration.ofMinutes(5));
                });

            assertThat(deploymentStrategies).element(3)
                .isInstanceOfSatisfying(ResourceParentFolderAutoDeploymentStrategy.class, strategy -> {
                    assertThat(strategy.isUseLockForDeployments()).isFalse();
                    assertThat(strategy.getDeploymentLockWaitTime()).isEqualTo(Duration.ofMinutes(5));
                });

            deleteDeployments(processEngine);
        });
}
 

@Test
public void standaloneProcessEngineWithBasicDatasourceAndAutoDeploymentWithLocking() {
    contextRunner
        .withPropertyValues(
            "flowable.auto-deployment.engine.bpmn.use-lock=true",
            "flowable.auto-deployment.engine.bpmn.lock-wait-time=10m",
            "flowable.auto-deployment.engine.bpmn.throw-exception-on-deployment-failure=false",
            "flowable.auto-deployment.engine.bpmn.lock-name=testLock"
        )
        .run(context -> {
            assertThat(context).as("Process engine")
                    .hasSingleBean(ProcessEngine.class)
                    .doesNotHaveBean(AppEngine.class)
                    .doesNotHaveBean(IdGenerator.class)
                    .doesNotHaveBean("processAppEngineConfigurationConfigurer");

            ProcessEngine processEngine = context.getBean(ProcessEngine.class);

            assertThat(processEngine.getProcessEngineConfiguration().getIdGenerator()).isInstanceOf(StrongUuidGenerator.class);

            assertAllServicesPresent(context, processEngine);
            assertAutoDeployment(context);

            assertThat(context).hasSingleBean(CustomUserEngineConfigurerConfiguration.class)
                .getBean(CustomUserEngineConfigurerConfiguration.class)
                .satisfies(configuration -> {
                    assertThat(configuration.getInvokedConfigurations())
                        .containsExactly(
                            SpringProcessEngineConfiguration.class
                        );
                });

            SpringProcessEngineConfiguration springProcessEngineConfiguration = (SpringProcessEngineConfiguration) processEngine
                .getProcessEngineConfiguration();

            Collection<AutoDeploymentStrategy<ProcessEngine>> deploymentStrategies = springProcessEngineConfiguration.getDeploymentStrategies();

            assertThat(deploymentStrategies).element(0)
                .isInstanceOfSatisfying(DefaultAutoDeploymentStrategy.class, strategy -> {
                    assertThat(strategy.isUseLockForDeployments()).isTrue();
                    assertThat(strategy.getDeploymentLockWaitTime()).isEqualTo(Duration.ofMinutes(10));
                    assertThat(strategy.isThrowExceptionOnDeploymentFailure()).isFalse();
                    assertThat(strategy.getLockName()).isEqualTo("testLock");
                });

            assertThat(deploymentStrategies).element(1)
                .isInstanceOfSatisfying(SingleResourceAutoDeploymentStrategy.class, strategy -> {
                    assertThat(strategy.isUseLockForDeployments()).isTrue();
                    assertThat(strategy.getDeploymentLockWaitTime()).isEqualTo(Duration.ofMinutes(10));
                    assertThat(strategy.isThrowExceptionOnDeploymentFailure()).isFalse();
                    assertThat(strategy.getLockName()).isEqualTo("testLock");
                });

            assertThat(deploymentStrategies).element(2)
                .isInstanceOfSatisfying(ResourceParentFolderAutoDeploymentStrategy.class, strategy -> {
                    assertThat(strategy.isUseLockForDeployments()).isTrue();
                    assertThat(strategy.getDeploymentLockWaitTime()).isEqualTo(Duration.ofMinutes(10));
                    assertThat(strategy.isThrowExceptionOnDeploymentFailure()).isFalse();
                    assertThat(strategy.getLockName()).isEqualTo("testLock");
                });

            deleteDeployments(processEngine);
        });
}
 

@Test
public void standaloneProcessEngineWithBasicDatasource() {
    contextRunner.run(context -> {
        assertThat(context).as("Process engine")
                .hasSingleBean(ProcessEngine.class)
                .doesNotHaveBean(AppEngine.class)
                .doesNotHaveBean(IdGenerator.class)
                .doesNotHaveBean("processAppEngineConfigurationConfigurer");

        ProcessEngine processEngine = context.getBean(ProcessEngine.class);

        assertThat(processEngine.getProcessEngineConfiguration().getIdGenerator()).isInstanceOf(StrongUuidGenerator.class);

        assertAllServicesPresent(context, processEngine);
        assertAutoDeployment(context);

        assertThat(context).hasSingleBean(CustomUserEngineConfigurerConfiguration.class)
            .getBean(CustomUserEngineConfigurerConfiguration.class)
            .satisfies(configuration -> {
                assertThat(configuration.getInvokedConfigurations())
                    .containsExactly(
                        SpringProcessEngineConfiguration.class
                    );
            });

        SpringProcessEngineConfiguration springProcessEngineConfiguration = (SpringProcessEngineConfiguration) processEngine
            .getProcessEngineConfiguration();

        Collection<AutoDeploymentStrategy<ProcessEngine>> deploymentStrategies = springProcessEngineConfiguration.getDeploymentStrategies();

        assertThat(deploymentStrategies).element(0)
            .isInstanceOfSatisfying(DefaultAutoDeploymentStrategy.class, strategy -> {
                assertThat(strategy.isUseLockForDeployments()).isFalse();
                assertThat(strategy.getDeploymentLockWaitTime()).isEqualTo(Duration.ofMinutes(5));
                assertThat(strategy.isThrowExceptionOnDeploymentFailure()).isTrue();
                assertThat(strategy.getLockName()).isNull();
            });

        assertThat(deploymentStrategies).element(1)
            .isInstanceOfSatisfying(SingleResourceAutoDeploymentStrategy.class, strategy -> {
                assertThat(strategy.isUseLockForDeployments()).isFalse();
                assertThat(strategy.getDeploymentLockWaitTime()).isEqualTo(Duration.ofMinutes(5));
                assertThat(strategy.isThrowExceptionOnDeploymentFailure()).isTrue();
                assertThat(strategy.getLockName()).isNull();
            });

        assertThat(deploymentStrategies).element(2)
            .isInstanceOfSatisfying(ResourceParentFolderAutoDeploymentStrategy.class, strategy -> {
                assertThat(strategy.isUseLockForDeployments()).isFalse();
                assertThat(strategy.getDeploymentLockWaitTime()).isEqualTo(Duration.ofMinutes(5));
                assertThat(strategy.isThrowExceptionOnDeploymentFailure()).isTrue();
                assertThat(strategy.getLockName()).isNull();
            });

        deleteDeployments(processEngine);
    });
}
 

@Bean
public EngineConfigurationConfigurer<SpringProcessEngineConfiguration> customIdGeneratorConfigurer() {
    return engineConfiguration -> engineConfiguration.setIdGenerator(new DbIdGenerator());
}
 

@Test
public void testInclusiveGatewayProcessTask() {
    contextRunner.run((context -> {
        SpringCmmnEngineConfiguration cmmnEngineConfiguration = context.getBean(SpringCmmnEngineConfiguration.class);
        SpringProcessEngineConfiguration processEngineConfiguration = context.getBean(SpringProcessEngineConfiguration.class);

        CmmnRuntimeService cmmnRuntimeService = cmmnEngineConfiguration.getCmmnRuntimeService();
        CmmnHistoryService cmmnHistoryService = cmmnEngineConfiguration.getCmmnHistoryService();
        RuntimeService runtimeService = processEngineConfiguration.getRuntimeService();
        TaskService taskService = processEngineConfiguration.getTaskService();

        CaseInstance caseInstance = cmmnRuntimeService.createCaseInstanceBuilder().caseDefinitionKey("myCase").start();
        assertThat(cmmnHistoryService.createHistoricMilestoneInstanceQuery().count()).isZero();
        assertThat(runtimeService.createProcessInstanceQuery().count()).isZero();

        List<PlanItemInstance> planItemInstances = cmmnRuntimeService.createPlanItemInstanceQuery()
                .caseInstanceId(caseInstance.getId())
                .planItemDefinitionId("theTask")
                .planItemInstanceState(PlanItemInstanceState.ACTIVE)
                .list();
        assertThat(planItemInstances).hasSize(1);
        cmmnRuntimeService.triggerPlanItemInstance(planItemInstances.get(0).getId());
        assertThat(runtimeService.createProcessInstanceQuery().count()).as("No process instance started").isEqualTo(1L);

        assertThat(taskService.createTaskQuery().count()).isEqualTo(2);

        List<Task> tasks = taskService.createTaskQuery().list();
        taskService.complete(tasks.get(0).getId());
        taskService.complete(tasks.get(1).getId());

        assertThat(taskService.createTaskQuery().count()).isZero();
        assertThat(runtimeService.createProcessInstanceQuery().count()).isZero();

        planItemInstances = cmmnRuntimeService.createPlanItemInstanceQuery()
                .caseInstanceId(caseInstance.getId())
                .planItemDefinitionId("theTask2")
                .list();
        assertThat(planItemInstances)
                .extracting(PlanItemInstance::getName, PlanItemInstance::getState)
                .containsExactly(tuple("Task Two", PlanItemInstanceState.ENABLED));
    }));
}
 

@Test
public void withEntityManagerFactoryBeanAndSpringProcessEngineConfigurationClass() {
    contextRunner
        .withConfiguration(AutoConfigurations.of(
            DataSourceAutoConfiguration.class,
            HibernateJpaAutoConfiguration.class
        ))
        .run(context -> {
            assertThat(context)
                .hasSingleBean(FlowableJpaAutoConfiguration.class)
                .hasBean("jpaProcessEngineConfigurer");

            EntityManagerFactory entityManagerFactory = context.getBean(EntityManagerFactory.class);
            @SuppressWarnings("unchecked")
            EngineConfigurationConfigurer<SpringProcessEngineConfiguration> jpaProcessEngineConfigurer =
                (EngineConfigurationConfigurer<SpringProcessEngineConfiguration>) context
                    .getBean("jpaProcessEngineConfigurer", EngineConfigurationConfigurer.class);

            SpringProcessEngineConfiguration configuration = new SpringProcessEngineConfiguration();

            assertThat(configuration.getJpaEntityManagerFactory())
                .as("Process JPA Entity Manager Factory")
                .isNull();
            assertThat(configuration.isJpaHandleTransaction())
                .as("Process JPA handle transaction")
                .isFalse();
            assertThat(configuration.isJpaCloseEntityManager())
                .as("Process JPA close entity manager")
                .isFalse();

            jpaProcessEngineConfigurer.configure(configuration);

            assertThat(configuration.getJpaEntityManagerFactory())
                .as("Process JPA Entity Manager Factory")
                .isSameAs(entityManagerFactory);
            assertThat(configuration.isJpaHandleTransaction())
                .as("Process JPA handle transaction")
                .isFalse();
            assertThat(configuration.isJpaCloseEntityManager())
                .as("Process JPA close entity manager")
                .isFalse();
        });
}
 

public SpringProcessEngineConfigurator setProcessEngineConfiguration(SpringProcessEngineConfiguration processEngineConfiguration) {
    this.processEngineConfiguration = processEngineConfiguration;
    return this;
}