Pour intégrer Activiti dans une application Spring Boot, commencez par configurer les dépendances Maven nécessaires. Voici un exemple de fichier pom.xml modifié pour inclure les bibliothèques essentielles, avec des versions mises à jour et une structure simplifiée.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.0.RELEASE</version>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>processus-automatise</artifactId>
    <version>1.0.0</version>
    <properties>
        <java.version>1.8</java.version>
        <activiti.version>6.0.0</activiti.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-engine</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring-boot-starter-basic</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

Configurez ensuite le fichier application.yml pour connecter la base de données et désactiver le déploiemnet automatique des processus. Notez que le pilote de base de données pour MySQL 8 nécessite une classe spécifique.

spring:
  datasource:
    url: jdbc:mysql://localhost:3307/base_donnees?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
    username: utilisateur
    password: mot_de_passe
    driver-class-name: com.mysql.cj.jdbc.Driver
  activiti:
    check-process-definitions: false
server:
  port: 8080

Écrivez une interface de service pour gérer les opérations de processus, en utilisant des noms de méthodes descriptifs en français.

package com.example.service;

public interface ServiceGestionProcessus {
    boolean deployerModeleProcessus();
    boolean demarrerInstanceProcessus(String cle);
    boolean recupererTachesEnAttente();
    boolean completerTache(String idTache);
    boolean terminerInstanceProcessus(String idExecution);
}

Implémentez le service avec les services Activiti injectés, en modifiant la logique pour refléter une approche plus abstraite.

package com.example.service;

import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class ImplementationServiceGestion implements ServiceGestionProcessus {

    @Autowired
    private RuntimeService executionService;
    @Autowired
    private TaskService tacheService;
    @Autowired
    private RepositoryService depotService;

    @Override
    public boolean deployerModeleProcessus() {
        depotService.createDeployment()
            .addClasspathResource("modele_processus.bpmn")
            .deploy();
        return true;
    }

    @Override
    public boolean demarrerInstanceProcessus(String cle) {
        executionService.startProcessInstanceByKey(cle);
        return true;
    }

    @Override
    public boolean recupererTachesEnAttente() {
        List<Task> listeTaches = tacheService.createTaskQuery().list();
        for (Task tache : listeTaches) {
            System.out.println("ID Tâche : " + tache.getId() + ", Nom : " + tache.getName());
        }
        return true;
    }

    @Override
    public boolean completerTache(String idTache) {
        tacheService.complete(idTache);
        return true;
    }

    @Override
    public boolean terminerInstanceProcessus(String idExecution) {
        executionService.deleteProcessInstance(idExecution, "Terminé manuellement");
        return true;
    }
}

Créez un contrôleur REST pour exposer les endpoints de l'API, avec des chemins et des noms de paramètres ajustés.

package com.example.controller;

import com.example.service.ServiceGestionProcessus;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/processus")
public class ControleurProcessus {

    @Autowired
    private ServiceGestionProcessus serviceProcessus;

    @PostMapping("/deployer")
    public boolean deployer() {
        return serviceProcessus.deployerModeleProcessus();
    }

    @PostMapping("/demarrer")
    public boolean demarrer(@RequestParam String cle) {
        return serviceProcessus.demarrerInstanceProcessus(cle);
    }

    @GetMapping("/taches")
    public boolean listerTaches() {
        return serviceProcessus.recupererTachesEnAttente();
    }

    @PostMapping("/completer")
    public boolean completer(@RequestParam String idTache) {
        return serviceProcessus.completerTache(idTache);
    }

    @DeleteMapping("/terminer")
    public boolean terminer(@RequestParam String idExecution) {
        return serviceProcessus.terminerInstanceProcessus(idExecution);
    }
}

Dans la classe principale de l'application, excluez la configuration de sécurité automatique d'Activiti pour éviter les conflits.

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;

@SpringBootApplication(exclude = {SecurityAutoConfiguration.class})
public class ApplicationProcessus {

    public static void main(String[] args) {
        SpringApplication.run(ApplicationProcessus.class, args);
    }
}

Pour tester le flux, déployez d'abord le modèle de processus via l'endpoint /api/processus/deployer. Démarrez ensuite une instance avec une clé spécifique, par exemple /api/processus/demarrer?cle=processus_demo. Les tâches en attente peuvent être récupérées via /api/processus/taches, et soumises avec leur identifiant. Pour termnier prématurément une instanec, utilisez /api/processus/terminer?idExecution=xxx, où xxx est l'identifiant de l'exécution obtenu lors du démarrage.