« Patrons de conception/Chaîne de responsabilité » : différence entre les versions

Contenu supprimé Contenu ajouté
imported>Alecs.bot
m robot Ajoute: zh:责任链模式
imported>Helorem
Aucun résumé des modifications
Ligne 1 :
{{ébauche|informatique}}
En [[génie logiciel]], le [[patron de conception]] '''Chaîne de responsabilité''' permet à un nombre quelconque de classes d'essayer de répondre à une requête sans connaître les possibilités des autres classes sur cette requête. Cela permet de diminuer le couplage entre objets. Le seul lien commun entre ces objets étant cette requête qui passe d'un objet à l'autre jusqu'à ce que l'un des objets puisse répondre.
 
== Utilisation ==
Un exemple d'utilisation de ce patron est le système d'aide où n'importe quelle partie de l'écran peut faire l'objet d'un message d'aide. Supposons que l'on sélectionne l'aide d'un bouton. Une requête avec un id "bouton" va être levée. Cette requête va passer d'un objet à un autre jusqu'à être la classe possédant le texte d'aide de ce bouton.
 
Dès lors qu'une information doit recevoir plusieurs traitement, ou juste se passer entre différents objets.
 
== Un exemple en langage C++ ==
 
L'exemple ci-dessous présente un système de log. Lors de la réception d'un message, ce dernier va passer d'un Logger a l'autre, déclenchant ou non le traitement associé.
 
<source lang="cpp">
class Logger
{
protected:
int level;
Logger* next;
 
public:
enum
{
ERR,
NOTICE,
DEBUG
};
Logger* setNext(Logger* next)
{
this->next = next;
return (this->next);
}
 
void message(string msg, int priority)
{
if (priority <= this->level)
this->writeMessage(msg);
if (this->next != NULL)
this->next->message(msg, priority);
}
 
virtual void writeMessage(string msg) = 0;
};
class DebugLogger : public Logger
{
public:
DebugLogger(int level)
{
this->level = level;
this->next = NULL;
}
 
void writeMessage(string msg)
{
cout << "Message de debug : " << msg << endl;
}
};
class EmailLogger : public Logger
{
public:
EmailLogger(int level)
{
this->level = level;
this->next = NULL;
}
 
void writeMessage(string msg)
{
cout << "Notification par email : " << msg << endl;
}
};
class ErrorLogger : public Logger
{
public:
ErrorLogger(int level)
{
this->level = level;
this->next = NULL;
}
 
void writeMessage(string msg)
{
cerr << "Erreur : " << msg << endl;
}
};
int main()
{
// Construction de la chaine de responsabilite
DebugLogger logger = new DebugLogger(Logger::DEBUG);
EmailLogger logger2 = new EmailLogger(Logger::NOTICE);
ErrorLogger logger3 = new ErrorLogger(Logger::ERR);
logger->setNext(logger2);
logger2->setNext(logger3);
 
logger->message("Entering function y.", Logger::DEBUG); // Utilisé par DebugLogger
logger->message("Step1 completed.", Logger::NOTICE); // Utilisé par DebugLogger et EmailLogger
logger->message("An error has occurred.", Logger::ERR); // Utilisé par les trois Loggers
return (0);
}
</source>
 
== Voir aussi ==
=== Liens externes===
* [http://en.wikipedia.org/wiki/Chain_of_responsibility_pattern Chain-of-responsibility pattern, Wikipedia (en)]
 
 
 
{{Portail informatique}}
 
[[Catégorie:Patron de conception]]