Introduction à Spring Statemachine 2.2.0

Spring Statemachine 2.2.0 est un framework officiel conçu par l'équipe Spring pour faciliter l'implémentation de machines à états dans les applications Spring. Cette solution permet aux développeurs de gérer efficacement des logiques d'état complexes tout en s'intégrant harmonieusement avec l'écosystème Spring.

Fonctionnalités principales

La version 2.2.0 offre un ensemble complet de fonctionnalités :

• Hiérarchie d'états : Prise en charge des sous-états et structures hiérarchiques pour gérer des configurations complexes
• Machines à états parallèles : Support des flux parallèles, fourches et jointures pour les scénarios concurrents
• Mécanisme piloté par événements : Transitions déclenchées par des événements avec support des déclencheurs, gardes et actions
• Configuration typée : Adaptateurs sécurisés pour réduire les erreurs de configuration
• Intégration Spring : Compatibilité avec Spring Boot, Spring MVC et autres modules du framework

Cas d'utilisation typiques

Ce framework s'applique particulièrement bien aux scénarios suivants :

• Gestion des commandes : États de commande e-commerce (création, paiement, expédition, livraison)
• Moteurs de workflow : Gestion des processus métiers complexes (approbations, planification de tâches)
• Contrôle d'équipements : États des dispositifs IoT (démarrage, fonctionnement, arrêt)

Démarrage rapide

Ajout des dépendances

Intégrez Spring Statemachine dans votre projet Maven :

<dependency>
    <groupId>org.springframework.statemachine</groupId>
    <artifactId>spring-statemachine-core</artifactId>
    <version>2.2.0.RELEASE</version>
</dependency>

Définition des énumérations

Créez vos énumérations d'états et d'événements :

public enum EtatsCommande {
    EN_ATTENTE, PAYEE, EXPEDIEE, LIVREE
}

public enum EvenementsCommande {
    PAIEMENT_EFFECTUE, COLIS_EXPEDIE, COMMANDE_LIVREE
}

Configuration de la machine

Configurez votre machine à états via une classe de configuration :

@Configuration
@EnableStateMachine
public class ConfigurationMachineEtats extends EnumStateMachineConfigurerAdapter<EtatsCommande, EvenementsCommande> {
    
    @Override
    public void configure(StateMachineStateConfigurer<EtatsCommande, EvenementsCommande> configEtats) throws Exception {
        configEtats
            .withStates()
            .initial(EtatsCommande.EN_ATTENTE)
            .states(java.util.EnumSet.allOf(EtatsCommande.class));
    }

    @Override
    public void configure(StateMachineTransitionConfigurer<EtatsCommande, EvenementsCommande> configTransitions) throws Exception {
        configTransitions
            .withExternal()
            .source(EtatsCommande.EN_ATTENTE).target(EtatsCommande.PAYEE)
            .event(EvenementsCommande.PAIEMENT_EFFECTUE)
            .and()
            .withExternal()
            .source(EtatsCommande.PAYEE).target(EtatsCommande.EXPEDIEE)
            .event(EvenementsCommande.COLIS_EXPEDIE);
    }
}

Utilisation dans les services

Injectez et utilisez la machine dans vos services métier :

@Service
public class ServiceGestionCommande {
    
    @Autowired
    private StateMachine<EtatsCommande, EvenementsCommande> machineEtats;

    public void traiterEvenement(EvenementsCommande evenement) {
        machineEtats.sendEvent(evenement);
    }
    
    public EtatsCommande obtenirEtatCourant() {
        return machineEtats.getState().getId();
    }
}

Points critiques à considérer

• Sécurité des threads : Les instances de Spring Statemachine sont stateful et donc non thread-safe. Utilisez un pattern factory pour créer des instances indépendantes
• Optimisation des performances : Pour les environnements haute performance, envisagez une machine distribuée (implémentation basée sur Zookeeper)
• Compatibilité des versions : Nécessite Spring Framework 5.x et Java 8 ou supérieur

Avantages du framework

Les machines à états sont puissantes car elles garnatissent toujours un comportement cohérent, facilitant ainsi le débogage. Les règles opérationnelles sont figées au démarrage de la machine. L'idée fondamentale est que votre application peut exister dans un nombre fini d'états, et certains déclecnheurs prédéfinis peuvent amener votre application d'un état à un autre. Ces déclencheurs peuvent être basés sur des événements ou des minuteurs.

Il est beaucoup plus facile de définir une logique de haut niveau en dehors de votre application, puis de compter sur la machine à états pour gérer les états. Vous pouvez interagir avec la machine à états en envoyant un événement, en écoutant les changements ou simplement en demandant l'état actuel.