Modèle de chaîne de responsabilité: plusieurs objets sont connectés à une chaîne par références correspondant à la prochaine maison de leurs objets, et la demande est transmise sur cette chaîne jusqu'à ce qu'un objet récepteur sur la chaîne traite la demande. Étant donné que le client demandeur ne sait pas qui finira par traiter la demande sur la chaîne, le système peut réorganiser et allouer dynamiquement les responsabilités sans affecter le client, évitant ainsi le couplage entre l'expéditeur de demande et le gestionnaire de demande.
Il y a trois rôles impliqués dans la chaîne de responsabilité:
1. Rôle du processeur abstrait
2. Rôle de gestionnaire spécifique
3. Petit exemple de l'expéditeur de demande: Supposons que vous alliez acheter une maison et que vous devez négocier lors de l'achat d'une maison. Les postes de la personne qui vend la maison sont différents et les prix réduits sont également différents. Différentes positions peuvent former une chaîne pour le traitement de la demande. Nous avons provisoirement réglé: * Les vendeurs de base ne peuvent offrir que 3% de réduction * Directeur des ventes: 5% de réduction * Directeur des ventes: 8% de réduction * Boss: 10% de rabais
Instance java
Diagramme de classe:
/ ** * Résumé Responsabilité * / classe publique Résumé IFilter {private ifilter successeur; public ifilter getUCCessor () {return successeur; } public void setSucCessor (ifilter successeur) {this.successeur = successeur; } public abstract void mandeinsFilter (); abstrait vide manchefilter2 (); } / ** * Responsabilités spécifiques * / classe publique ConcreteFilter étend ifilter {nom de chaîne privée; public ConcreteFilter (String name) {this.name = name; } @Override public void handleFilter () {/ * * le gérer d'abord, s'il y a un successeur, alors gérez-le une fois * / system.out.println (name + "demande traitée"); if (getSucCessor ()! = null) {getSucCessor (). handleFilter (); }} @Override public void handleFilter2 () {/ * * S'il y a un successeur, le successeur sera géré par vous-même. Sinon, vous le gérerez vous-même * / if (getSucCessor ()! = Null) {getUCCessor (). HandleFilter2 (); } else {System.out.println (nom + "Demande traitée"); }}} Classe publique Test {public static void main (String [] args) {ifilter filter1 = new ConcreteFilter ("permission-filter"); // Filtre d'autorisation ifilter filter2 = new ConcreteFilter ("suffixe-filter"); // suffix filter ifilter filter3 = new ConcreteFilter ("style-filter"); // style Filter1.SetSuccessor (Filter2); filtre2.SetSuccessor (filtre3); System.out.println ("----- Ce qui suit est géré par chaque processeur (y compris les successeurs), l'ordre est également un laissez-passer de niveau de niveau ------"); filter1.handleFilter (); System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Imprimer:
------ Ce qui suit est le processus de chaque processeur (y compris les successeurs), et la commande est également un niveau après l'autre ----- Le filtre d'autorisation gère le filtre de suffixe de demande Le filtre de style de demande gère la demande ------- Ce qui suit est le processus du dernier successor---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------