You have a number of options to configure and create a process engine depending on whether you use an application managed or a shared, container managed process engine.

Application Managed Process Engine

You manage the process engine as part of your application. The following ways exist to configure it:

A container of your choice (e.g., Tomcat, JBoss or IBM WebSphere) manages the process engine for you. The configuration is carried out in a container specific way, see Runtime Container Integration for details.

ProcessEngineConfiguration Bean

The Camunda engine uses the ProcessEngineConfiguration bean to configure and construct a standalone Process Engine. There are multiple subclasses available that can be used to define the process engine configuration. These classes represent different environments, and set defaults accordingly. It’s a best practice to select the class that matches (most of) your environment to minimize the number of properties needed to configure the engine. The following classes are currently available:

  • org.camunda.bpm.engine.impl.cfg.StandaloneProcessEngineConfigurationThe process engine is used in a standalone way. The engine itself will take care of the transactions. By default the database will only be checked when the engine boots (an exception is thrown if there is no database schema or the schema version is incorrect).
  • org.camunda.bpm.engine.impl.cfg.StandaloneInMemProcessEngineConfigurationThis is a convenience class for unit testing purposes. The engine itself will take care of the transactions. An H2 in-memory database is used by default. The database will be created and dropped when the engine boots and shuts down. When using this, probably no additional configuration is needed (except, for example, when using the job executor or mail capabilities).
  • org.camunda.bpm.engine.spring.SpringProcessEngineConfigurationTo be used when the process engine is used in a Spring environment. See the Spring integration section for more information.
  • org.camunda.bpm.engine.impl.cfg.JtaProcessEngineConfigurationTo be used when the engine runs in standalone mode, with JTA transactions.

    Bootstrap a Process Engine Using the Java API

You can configure the process engine programmatically by creating the right ProcessEngineConfiguration object or by using some pre-defined one:

  1. ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
  2. ProcessEngineConfiguration.createStandaloneInMemProcessEngineConfiguration();

Now you can call the buildProcessEngine() operation to create a Process Engine:

  1. ProcessEngine processEngine = ProcessEngineConfiguration.createStandaloneInMemProcessEngineConfiguration()
  2.   .setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_FALSE)
  3.   .setJdbcUrl("jdbc:h2:mem:my-own-db;DB_CLOSE_DELAY=1000")
  4.   .setJobExecutorActivate("true")
  5.   .buildProcessEngine();

Configure Process Engine Using Spring XML

The easiest way to configure your Process Engine is through an XML file called camunda.cfg.xml. Using that you can simply do:

  1. ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine()

The camunda.cfg.xml must contain a bean that has the id processEngineConfiguration, select the ProcessEngineConfiguration class best suited to your needs:

  1. <bean id="processEngineConfiguration" class="org.camunda.bpm.engine.impl.cfg.StandaloneProcessEngineConfiguration">

This will look for a camunda.cfg.xml file on the classpath and construct an engine based on the configuration in that file. The following snippet shows an example configuration:

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  5.   <bean id="processEngineConfiguration" class="org.camunda.bpm.engine.impl.cfg.StandaloneProcessEngineConfiguration">
  7.     <property name="jdbcUrl" value="jdbc:h2:mem:camunda;DB_CLOSE_DELAY=1000" />
  8.     <property name="jdbcDriver" value="org.h2.Driver" />
  9.     <property name="jdbcUsername" value="sa" />
  10.     <property name="jdbcPassword" value="" />
  12.     <property name="databaseSchemaUpdate" value="true" />
  14.     <property name="jobExecutorActivate" value="false" />
  16.     <property name="mailServerHost" value="mail.my-corp.com" />
  17.     <property name="mailServerPort" value="5025" />
  18.   </bean>
  20. </beans>

Note that the configuration XML is in fact a Spring configuration. This does not mean that the Camunda engine can only be used in a Spring environment! We are simply leveraging the parsing and dependency injection capabilities of Spring internally for building up the engine.

The ProcessEngineConfiguration object can also be created programmatically using the configuration file. It is also possible to use a different bean id:

  1. ProcessEngineConfiguration.createProcessEngineConfigurationFromResourceDefault();
  2. ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(String resource);
  3. ProcessEngineConfiguration.createProcessEngineConfigurationFromResource(String resource, String beanName);
  4. ProcessEngineConfiguration.createProcessEngineConfigurationFromInputStream(InputStream inputStream);
  5. ProcessEngineConfiguration.createProcessEngineConfigurationFromInputStream(InputStream inputStream, String beanName);

It is also possible to not use a configuration file and create a configuration based on defaults (see the different supported classes for more information).

  1. ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
  2. ProcessEngineConfiguration.createStandaloneInMemProcessEngineConfiguration();

All these ProcessEngineConfiguration.createXXX() methods return a ProcessEngineConfiguration that can further be tweaked if needed. After calling the buildProcessEngine() operation, a ProcessEngine is created as explained above.

Configure Process Engine in the bpm-platform.xml

The bpm-platform.xml file is used to configure the Camunda BPM platform in the following distributions:

  • Apache Tomcat
  • IBM WebSphere Application Server
  • Oracle WebLogic Application Server
    The <process-engine … /> xml tag allows you to define a process engine:
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <bpm-platform xmlns="http://www.camunda.org/schema/1.0/BpmPlatform"
  3.               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.               xsi:schemaLocation="http://www.camunda.org/schema/1.0/BpmPlatform http://www.camunda.org/schema/1.0/BpmPlatform">
  6.   <job-executor>
  7.     <job-acquisition name="default" />
  8.   </job-executor>
  10.   <process-engine name="default">
  11.     <job-acquisition>default</job-acquisition>
  12.     <configuration>org.camunda.bpm.engine.impl.cfg.StandaloneProcessEngineConfiguration</configuration>
  13.     <datasource>java:jdbc/ProcessEngine</datasource>
  15.     <properties>
  16.       <property name="history">full</property>
  17.       <property name="databaseSchemaUpdate">true</property>
  18.       <property name="authorizationEnabled">true</property>
  19.     </properties>
  21.   </process-engine>
  22. </bpm-platform>

See the Deployment Descriptor Reference for complete documentation of the syntax of the bpm-platform.xml file.

Configure Process Engine in the processes.xml

The process engine can also be configured and bootstrapped using the META-INF/processes.xml file. See Section on processes.xml file for details.

See the Deployment Descriptor Reference for complete documentation of the syntax of the processes.xml file.

原文: https://docs.camunda.org/manual/7.9/user-guide/process-engine/process-engine-bootstrapping/