Chaîne de responsabilité Définition: la chaîne de responsabilité (COR) est une série de classes qui essaient de traiter une demande. En d'autres termes, lorsqu'une demande vient d'abord les processus de classe A.
Comment utiliser le modèle de la chaîne de responsabilité
Bien que ce paragraphe utilise COR, il montre également ce qu'est le COR.
Il y a une interface de gestionnaire:
La copie de code est la suivante:
Handler d'interface publique {
public void handlerequest ();
}
Il s'agit d'un exemple de demandes de gestion.
◆ La première solution qui vient à l'esprit est: ajoutez plusieurs demandes à l'interface:
La copie de code est la suivante:
Handler d'interface publique {
public void handleHelp ();
Public Void Handleprint ();
public void handleformat ();
}
Plus précisément, il s'agit d'un code pour implémenter l'interface:
La copie de code est la suivante:
classe publique ConcreteHandler implémente le gestionnaire {
successeur du gestionnaire privé;
Public ConcreteHandler (Handler Successeur) {
this.successor = successeur;
}
public void handlehelp () {
// Code spécifique pour le traitement de la demande d'aide ...
}
public void mandeinsprint () {
// S'il s'agit d'une impression, tournez-vous pour traiter l'impression
successeur.handleprint ();
}
public void handleformat () {
// Si c'est le format, allez au format de processus
successeur.HandleFormat ();
}
}
Il existe trois classes de mise en œuvre spécifiques, ci-dessus, qui traitent de l'aide, et le format de traitement du traitement et du traitement, qui sont probablement nos idées de programmation les plus couramment utilisées.
Bien que l'idée soit simple et claire, il y a un problème d'extension.
◆ La deuxième solution: transformez chaque demande en interface, nous avons donc le code suivant:
La copie de code est la suivante:
Interface publique HelpHandler {
public void handleHelp ();
}
Interface publique Printhandler {
Public Void Handleprint ();
}
Interface publique Formathandler {
public void handleformat ();
}
classe publique en béton
implémente HelpHandler, Printhandler, Formathandlet {
HelpHandler privé aidedUccesseur;
Printhandler Printhandler privé;
format-format formidaire privé;
Public ConcreteHandler (HelpHandler HelpSuccesseur, imprimé Printhandler, formats de format-format) Formathandler)
{
this.helpsuccessor = aidedUCcesseur;
this.printSucCessor = imprimer;
this.formatsuccessor = formatSuccessor;
}
public void handlehelp () {
.........
}
public void handleprint () {this.printSuccessor = imprimersor;}
public void handleformat () {this.formatsuccessor = formatSuccessor;}
}
Lors de l'ajout d'une nouvelle demande de demande, cette méthode enregistre uniquement la quantité de modification de l'interface, et l'implémentation de l'interface du concret-handler doit également être modifiée. Et le code n'est évidemment pas simple et beau.
◆ Solution 3: Une seule méthode de paramétrage est utilisée dans l'interface du gestionnaire:
La copie de code est la suivante:
Handler d'interface publique {
public void handlerequest (demande de chaîne);
}
Ensuite, le code d'implémentation du gestionnaire est le suivant:
classe publique ConcreteHandler implémente le gestionnaire {
successeur du gestionnaire privé;
Public ConcreteHandler (Handler Successeur) {
this.successor = successeur;
}
public void handlerequest (string request) {
if (request.equals ("help")) {
// voici le code spécifique pour gérer l'aide} sinon
// passer au prochain successeur.handle (demande);
}
}
}
Supposons d'abord que la demande est de type de chaîne. Bien sûr, nous pouvons créer une demande de classe spéciale
◆ La solution finale: le code du gestionnaire d'interface est le suivant:
La copie de code est la suivante:
Handler d'interface publique {
public void handlerequest (demande de demande);
}
Définition de la classe de demande:
Demande de classe publique {
type de chaîne privé;
demande publique (type de chaîne) {this.type = type;}
public String getType () {return type;}
public void execute () {
// Code de comportement spécifique réel de la demande}
}
Ensuite, le code d'implémentation du gestionnaire est le suivant:
La copie de code est la suivante:
classe publique ConcreteHandler implémente le gestionnaire {
successeur du gestionnaire privé;
Public ConcreteHandler (Handler Successeur) {
this.successor = successeur;
}
public void handlerequest (demande de demande) {
if (demande instanceof helfRequest) {
// voici le code spécifique pour gérer l'aide} else if (demande d'instance de printReQuest) {
request.execute ();
}autre
// passer au prochain successeur.handle (demande);
}
}
}
Cette solution est Cor.
1. Avantages de COR: car il est impossible de prédire quel type de demandes du monde extérieur appartiennent, si chaque classe rencontre une demande qu'elle ne peut pas traiter, il suffit d'abandonner. Cela réduit sans aucun doute le couplage entre les classes.
2. L'inconvénient de COR est son inefficacité, car l'achèvement d'une demande peut devoir être traversé jusqu'à la fin avant qu'il ne puisse être terminé. Dans Java AWT1.0, la manipulation des boutons de la souris est d'utiliser Cor.
L'évolutivité est médiocre car dans COR, il doit y avoir un gestionnaire d'interface unifié.