Design Pattern : Chaîne de responsabilité

Le pattern chaîne de responsabilité est un pattern comportemental permettant en plus d'un découplage entre un client et son comportement de donner une logique spécifique a ce comportement selon l’état éventuel courant (du client, de l’exécution, des types de traitement possible accessible a l'instant t)

Ainsi un Client va déléguer à un objet la responsabilité d’exécuter une action qui sera elle-même déléguée une fois réalisée a un autre objet qui poursuivra l'action en question.

Par exemple, on peut imaginer un besoin lié a la gestion de données vis a vis d'une base consistant a récupérer des données, les traiter, pour les réinjecter mis à jour dans la base.

La chaîne de responsabilité va permettre de modéliser ce processus voir de faciliter son évolution

En Groovy cela donnera un code pas optimiser similaire a celui ci:

abstract class Responsable
{
    Responsable suivant
   
    abstract def traitementReq()
}

class Client
{
    Responsable responsable=new RecuperationData();
   
    def mettreAjourData()
    {
        responsable.traitementReq();
    }
}

class RecuperationData extends Responsable
{
    def traitementReq()
    {
        println "recup"
        suivant=new TraiterData();
        suivant.traitementReq();
    }
}

class TraiterData extends Responsable
{
    def traitementReq()
    {
        println "traitement"
        suivant=new SauverData();
        suivant.traitementReq();
    }
}

class SauverData extends Responsable
{
    def traitementReq()
    {
        println "sauvegarde"
    }
}

def client=new Client();
client.mettreAjourData();

En Java 8 avec les lambda expression, on trouvera rapidement des écritures permettant de simplifier grandement l’implémentation de ce pattern. Ainsi, on résumera donc le pattern chaîne de responsabilité par le diagramme de classe suivant:



A noter que rien ne précise comment passer au suivant, ici dans l'exemple on l'instancie a la volée, mais les objets peuvent être fourni via une factory.