Activiti 工作流引擎学习笔记

关于如何构建ProcessEngineConfiguration 的理解

1. ProcessEngineConfiguration 的类层次关系

通过类图。大致可以了解到ProcessEngineConfiguration的实现类大致有4中，即 jta spring standalone 和in mem 的。

2. ProcessEngineConfiguration 类中创建ProcessEngineConfiguration 的静态方法

   // 默认使用activiti.cfg.xml 配置文件获取processEngineConfiguration名称的ProcessEngineConfiguration对象
   public static ProcessEngineConfiguration createProcessEngineConfigurationFromResourceDefault() {
       return createProcessEngineConfigurationFromResource("activiti.cfg.xml", "processEngineConfiguration");
     }
   //通过指定配置获取文件获取processEngineConfiguration名称的ProcessEngineConfiguration对象
     public static ProcessEngineConfiguration createProcessEngineConfigurationFromResource(String resource) {
       return createProcessEngineConfigurationFromResource(resource, "processEngineConfiguration");
     }
   //通过指定配置文件和bean 获取ProcessEngineConfiguration对象
     public static ProcessEngineConfiguration createProcessEngineConfigurationFromResource(String resource, String beanName) {
       return BeansConfigurationHelper.parseProcessEngineConfigurationFromResource(resource, beanName);
     }
   
     public static ProcessEngineConfiguration createProcessEngineConfigurationFromInputStream(InputStream inputStream) {
       return createProcessEngineConfigurationFromInputStream(inputStream, "processEngineConfiguration");
     }
   
     public static ProcessEngineConfiguration createProcessEngineConfigurationFromInputStream(InputStream inputStream, String beanName) {
       return BeansConfigurationHelper.parseProcessEngineConfigurationFromInputStream(inputStream, beanName);
     }
   /*
   上面的方法，基本上是使用spring 的方式获取配置文件中创建的ProcessEngineConfiguration对象
   */
   
   
   
   //创建StandaloneProcessEngineConfiguration的ProcessEngineConfiguration 
     public static ProcessEngineConfiguration createStandaloneProcessEngineConfiguration() {
       return new StandaloneProcessEngineConfiguration();
     }
   //创建一个StandaloneInMemProcessEngineConfiguration de ProcessEngineConfiguration 对象
     public static ProcessEngineConfiguration createStandaloneInMemProcessEngineConfiguration() {
       return new StandaloneInMemProcessEngineConfiguration();
     }
   

重点

创建ProcessEngineConfiguration 的方式基本上是三种，一种是使用内存的，一种是使用StandaloneProcessEngineConfiguration 的，然后自己调用set方法进行配置，另外一种就是通过配置文件进行配置

关于 springboot 如何构建 SpringProcessEngineConfiguration

1. 不用说，我们先找到 spring.factories 查看自动配置类

## Activiti auto-configurations

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    org.activiti.spring.boot.EndpointAutoConfiguration,\
    org.activiti.spring.boot.ProcessEngineAutoConfiguration

即ProcessEngineAutoConfiguration

@Configuration
@AutoConfigureAfter(name = {"org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration",
        "org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration"})
///ActivitiProperties是我们的属性配置文件
@EnableConfigurationProperties({ActivitiProperties.class, AsyncExecutorProperties.class})
public class ProcessEngineAutoConfiguration extends AbstractProcessEngineAutoConfiguration {

    public static final String BEHAVIOR_FACTORY_MAPPING_CONFIGURER = "behaviorFactoryMappingConfigurer";
    private final UserGroupManager userGroupManager;

    public ProcessEngineAutoConfiguration(UserGroupManager userGroupManager) {
        this.userGroupManager = userGroupManager;
    }
//创建SpringProcessEngineConfiguration  bean
    @Bean
    @ConditionalOnMissingBean
    public SpringProcessEngineConfiguration springProcessEngineConfiguration(
            DataSource dataSource,
            PlatformTransactionManager transactionManager,
            SpringAsyncExecutor springAsyncExecutor,
            ActivitiProperties activitiProperties,
            ProcessDefinitionResourceFinder processDefinitionResourceFinder,
            ProjectModelService projectModelService,
            @Autowired(required = false) List<ProcessEngineConfigurationConfigurer> processEngineConfigurationConfigurers,
            @Autowired(required = false) List<ProcessEngineConfigurator> processEngineConfigurators) throws IOException {

        SpringProcessEngineConfiguration conf = new SpringProcessEngineConfiguration(projectModelService);
        return conf;
    }

我们去看看父类中实现了哪些功能

public abstract class AbstractProcessEngineAutoConfiguration
        extends AbstractProcessEngineConfiguration {

  @Bean
  public SpringAsyncExecutor springAsyncExecutor(TaskExecutor applicationTaskExecutor) {
    return new SpringAsyncExecutor(applicationTaskExecutor, springRejectedJobsHandler());
  }
  
  @Bean 
  public SpringRejectedJobsHandler springRejectedJobsHandler() {
    return new SpringCallerRunsRejectedJobsHandler();
  }

  protected Set<Class<?>> getCustomMybatisMapperClasses(List<String> customMyBatisMappers) {
    Set<Class<?>> mybatisMappers = new HashSet<>();
    for (String customMybatisMapperClassName : customMyBatisMappers) {
      try {
        Class customMybatisClass = Class.forName(customMybatisMapperClassName);
        mybatisMappers.add(customMybatisClass);
      } catch (ClassNotFoundException e) {
        throw new IllegalArgumentException("Class " + customMybatisMapperClassName + " has not been found.", e);
      }
    }
    return mybatisMappers;
  }

  @Bean
  public ProcessEngineFactoryBean processEngine(SpringProcessEngineConfiguration configuration) {
    return super.springProcessEngineBean(configuration);
  }

  @Bean
  @ConditionalOnMissingBean
  @Override
  public RuntimeService runtimeServiceBean(ProcessEngine processEngine) {
    return super.runtimeServiceBean(processEngine);
  }

  @Bean
  @ConditionalOnMissingBean
  @Override
  public RepositoryService repositoryServiceBean(ProcessEngine processEngine) {
    return super.repositoryServiceBean(processEngine);
  }

  @Bean
  @ConditionalOnMissingBean
  @Override
  public TaskService taskServiceBean(ProcessEngine processEngine) {
    return super.taskServiceBean(processEngine);
  }

  @Bean
  @ConditionalOnMissingBean
  @Override
  public HistoryService historyServiceBean(ProcessEngine processEngine) {
    return super.historyServiceBean(processEngine);
  }

  @Bean
  @ConditionalOnMissingBean
  @Override
  public ManagementService managementServiceBeanBean(ProcessEngine processEngine) {
    return super.managementServiceBeanBean(processEngine);
  }

  @Bean
  @ConditionalOnMissingBean
  public TaskExecutor taskExecutor() {
    return new SimpleAsyncTaskExecutor();
  }

  @Bean
  @ConditionalOnMissingBean
  @Override
  public IntegrationContextManager integrationContextManagerBean(ProcessEngine processEngine) {
    return super.integrationContextManagerBean(processEngine);
  }

  @Bean
  @ConditionalOnMissingBean
  @Override
  public IntegrationContextService integrationContextServiceBean(ProcessEngine processEngine) {
    return super.integrationContextServiceBean(processEngine);
  }
}

通过代码我们基本上了解到，其为我们自动创建了 RepositoryService,ProcessEngineFactoryBean ,RuntimeService,TaskService,ManagementService等bean

我们在到其父类中看看是如何通过spring java 的方式去创建 ProcessEngineFactoryBean 的

 public ProcessEngineFactoryBean springProcessEngineBean(SpringProcessEngineConfiguration configuration) {
    ProcessEngineFactoryBean processEngineFactoryBean = new ProcessEngineFactoryBean();
    processEngineFactoryBean.setProcessEngineConfiguration(configuration);
    return processEngineFactoryBean;
  }

public class ProcessEngineFactoryBean implements FactoryBean<ProcessEngine>, DisposableBean, ApplicationContextAware {

  protected ProcessEngineConfigurationImpl processEngineConfiguration;

  protected ApplicationContext applicationContext;
  protected ProcessEngine processEngine;

  public void destroy() throws Exception {
    if (processEngine != null) {
      processEngine.close();
    }
  }

  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    this.applicationContext = applicationContext;
  }

  public ProcessEngine getObject() throws Exception {
    configureExpressionManager();
    configureExternallyManagedTransactions();

    if (processEngineConfiguration.getBeans() == null) {
      processEngineConfiguration.setBeans(new SpringBeanFactoryProxyMap(applicationContext));
    }

    this.processEngine = processEngineConfiguration.buildProcessEngine();
    return this.processEngine;
  }

  protected void configureExpressionManager() {
    if (processEngineConfiguration.getExpressionManager() == null && applicationContext != null) {
      processEngineConfiguration.setExpressionManager(new SpringExpressionManager(applicationContext, processEngineConfiguration.getBeans()));
    }
  }

  protected void configureExternallyManagedTransactions() {
    if (processEngineConfiguration instanceof SpringProcessEngineConfiguration) { // remark: any config can be injected, so we cannot have SpringConfiguration as member
      SpringProcessEngineConfiguration engineConfiguration = (SpringProcessEngineConfiguration) processEngineConfiguration;
      if (engineConfiguration.getTransactionManager() != null) {
        processEngineConfiguration.setTransactionsExternallyManaged(true);
      }
    }
  }

  public Class<ProcessEngine> getObjectType() {
    return ProcessEngine.class;
  }

  public boolean isSingleton() {
    return true;
  }

  public ProcessEngineConfigurationImpl getProcessEngineConfiguration() {
    return processEngineConfiguration;
  }

  public void setProcessEngineConfiguration(ProcessEngineConfigurationImpl processEngineConfiguration) {
    this.processEngineConfiguration = processEngineConfiguration;
  }
}

我们学习到 其实只要其继承自FactoryBean 就已经是bean的工厂了。

重点

我们参见ActivitiProperties.class, AsyncExecutorProperties.class 类中的属性在 application.properties 文件中进行配置，而且自动为我们创建了 基本的服务 如 ProcessEngine ManagementServiceTaskService 等,