TOC

Configuration ProcessEngine dans Activiti

ProcessEngine Configuration dans Activiti

1. Vue d'ensemble

Dans notre précédent article d'introduction deActiviti with Java, nous avons vu l'importance desProcessEngine et en avons créé un via l'API statique par défaut fournie par le framework.

Au-delà de la valeur par défaut, il existe d'autres façons de créer unProcessEngine - que nous allons explorer ici.

2. Obtention d'une instanceProcessEngine

Il existe deux façons d'obtenir une instance deProcessEngine:

  1. en utilisant la classeProcessEngines

  2. par programmation, via lesProcessEngineConfiguration

Examinons de plus près des exemples de ces deux approches.

3. ObtenirProcessEngine avec la classeProcessEngines

En règle générale, leProcessEngine est configuré à l'aide d'un fichier XML appeléactiviti.cfg.xml, avec ce que le processus de création par défaut utilisera également.

Voici un exemple rapide de ce à quoi cette configuration peut ressembler:

Notez comment l'aspect de persistance du moteur est configuré ici.

Et maintenant, nous pouvons obtenir lesProcessEngine: 

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

4. ObtenirProcessEngine en utilisantProcessEngineConfiguration

En dépassant l'itinéraire par défaut pour obtenir le moteur - il existe deux façons de créer lesProcessEngineConfiguration:

  1. Utilisation de la configuration XML

  2. Utiliser Java Config

Commençons par la configuration XML.

Comme mentionné dans la section 2.1. - nous pouvons définir lesProcessEngineConfiguration par programmation, et construire lesProcessEngine en utilisant cette instance: 

@Test
void whenCreateDefaultConfiguration_thenGotProcessEngine() {
    ProcessEngineConfiguration processEngineConfiguration
      = ProcessEngineConfiguration
        .createProcessEngineConfigurationFromResourceDefault();
    ProcessEngine processEngine
      = processEngineConfiguration.buildProcessEngine();

    assertNotNull(processEngine);
}

La méthodecreateProcessEngineConfigurationFromResourceDefault() recherchera également le fichieractiviti.cfg.xml, et maintenant nous n'avons plus qu'à appeler l'APIbuildProcessEngine().

Dans ce cas, le nom du bean par défaut qu'il recherche estprocessEngineConfiguration. Si nous voulons changer le nom du fichier de configuration ou le nom du bean, nous pouvons utiliser d'autres méthodes disponibles pour créer lesProcessEngineConfiguration.

Jetons un coup d'œil à quelques exemples.

Tout d'abord, nous allons modifier le nom du fichier de configuration et demander à l'API d'utiliser notre fichier personnalisé: 

@Test
void whenGetProcessEngineConfig_thenGotResult() {
    ProcessEngineConfiguration processEngineConfiguration
      = ProcessEngineConfiguration
        .createProcessEngineConfigurationFromResource(
          "my.activiti.cfg.xml");
    ProcessEngine processEngine = processEngineConfiguration
      .buildProcessEngine();

    assertNotNull(processEngine);
}

Maintenant, changeons également le nom du bean: 

@Test
void whenGetProcessEngineConfig_thenGotResult() {
    ProcessEngineConfiguration processEngineConfiguration
      = ProcessEngineConfiguration
        .createProcessEngineConfigurationFromResource(
          "my.activiti.cfg.xml",
          "myProcessEngineConfiguration");
    ProcessEngine processEngine = processEngineConfiguration
      .buildProcessEngine();

    assertNotNull(processEngine);
    assertEquals("root", processEngine.getProcessEngineConfiguration()
      .getJdbcUsername());
}

Bien sûr, maintenant que la configuration attend des noms différents, nous devons modifier le nom de fichier (et le nom du bean) afin qu'il corresponde, avant d'exécuter le test.

Les autres options disponibles pour créer le moteur sontcreateProcessEngineConfigurationFromInputStream(InputStream inputStream),createProcessEngineConfigurationFromInputStream(InputStream inputStream, String beanName).

Si nous ne voulons pas utiliser la configuration XML,we can also set things up using Java config only.

Nous allons travailler avec quatre classes différentes; chacun d'eux représente un environnement différent:

  1. org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration – leProcessEngine est utilisé de manière autonome, soutenu par la base de données

  2. org.activiti.engine.impl.cfg.StandaloneInMemProcessEngineConfiguration – par défaut, une base de données en mémoire H2 est utilisée. La base de données est créée et supprimée au démarrage et à l'arrêt du moteur. Ce style de configuration peut donc être utilisé pour les tests.

  3. org.activiti.spring.SpringProcessEngineConfiguration – à utiliser dans l'environnement Spring

  4. org.activiti.engine.impl.cfg.JtaProcessEngineConfiguration – le moteur fonctionne en mode autonome, avec des transactions JTA

Jetons un œil à quelques exemples.

Voici un test JUnit pour créer une configuration de moteur de processus autonome: 

@Test
void whenCreateProcessEngineConfig_thenCreated() {
    ProcessEngineConfiguration processEngineConfiguration
      = ProcessEngineConfiguration
        .createStandaloneProcessEngineConfiguration();
    ProcessEngine processEngine = processEngineConfiguration
      .setDatabaseSchemaUpdate(ProcessEngineConfiguration
        .DB_SCHEMA_UPDATE_TRUE)
      .setJdbcUrl("jdbc:h2:mem:my-own-db;DB_CLOSE_DELAY=1000")
      .buildProcessEngine();

    assertNotNull(processEngine);
    assertEquals("sa", processEngine.getProcessEngineConfiguration()
      .getJdbcUsername());
}

De même, nous allons écrire un scénario de test JUnit pour créer la configuration du moteur de processus autonome à l'aide de la base de données en mémoire: 

@Test
void whenCreateInMemProcessEngineConfig_thenCreated() {
    ProcessEngineConfiguration processEngineConfiguration
      = ProcessEngineConfiguration
      .createStandaloneInMemProcessEngineConfiguration();
    ProcessEngine processEngine = processEngineConfiguration
      .buildProcessEngine();

    assertNotNull(processEngine);
    assertEquals("sa", processEngine.getProcessEngineConfiguration()
      .getJdbcUsername());
}

5. Configuration de la base de données

Par défaut, l'API Activiti utilisera la base de données H2 en mémoire, avec le nom de base de données «activiti» et le nom d'utilisateur «sa».

Si nous devons utiliser une autre base de données, nous devrons configurer les choses de manière explicite - en utilisant deux propriétés principales.

databaseType - les valeurs valides sonth2, mysql, oracle, postgres, mssql, db2. Ceci peut également être déterminé à partir de la configuration de la base de données mais sera utile en cas d'échec de la détection automatique.

databaseSchemaUpdate – cette propriété nous permet de définir ce qu'il advient de la base de données lorsque le moteur démarre ou s'arrête. Il peut avoir ces trois valeurs:

  1. false (par défaut) - cette option valide la version du schéma de base de données par rapport à la bibliothèque. Le moteur lèvera une exception si elles ne correspondent pas

  2. true - lorsque la configuration du moteur de processus est construite, une vérification est effectuée sur la base de données. La base de données sera créée / mise à jour créer-déposer en conséquence

  3. «–» - cela créera le schéma de base de données lorsque le moteur de processus est créé et le supprimera lorsque le moteur de processus s'arrêtera.

Nous pouvons définir la configuration de la base de données en tant que propriétés JDBC:

Alternativement, si nous utilisonsDataSource:

6. Conclusion

Dans ce rapide tutoriel, nous nous sommes concentrés sur plusieurs façons différentes de créer desProcessEngine dans Activiti.

Nous avons également vu différentes propriétés et approches pour gérer la configuration de la base de données.

Comme toujours, le code des exemples que nous avons vus peut être trouvéover on GitHub.

Related