Cet article décrit l'utilisation du mode de la chaîne de responsabilités pour que les étudiants puissent prendre congé. Partagez-le pour votre référence, comme suit:
1. Définition du modèle
Dans le modèle de la chaîne de responsabilité, de nombreux objets sont connectés par des références à leur prochaine maison par chaque objet, formant une chaîne. La demande de demande client est transmise sur cette chaîne jusqu'à ce qu'un objet sur la chaîne décide de traiter la demande. Le client qui fait cette demande ne sait pas quel objet de la chaîne gère finalement la demande, ce qui permet au système de réorganiser dynamiquement la chaîne et d'attribuer des responsabilités sans affecter le client.
(1) Rôle du processeur abstrait: définir une interface pour les demandes de traitement. Si nécessaire, l'interface peut définir une méthode pour définir et renvoyer la référence à la maison suivante. Ce rôle est généralement mis en œuvre par une classe abstraite Java ou une interface Java.
(2) Rôle de traitement spécifique: Après avoir reçu la demande, le processeur spécifique peut choisir de traiter la demande ou de transmettre la demande à la maison suivante.
2. Exemples de modèle
1 analyse de modèle
Nous empruntons les étudiants à illustrer ce modèle
2 Diagramme de classe statique du modèle de chaîne de responsabilité
3 exemples de code
3.1 Interface étudiante ISTUDENT
package com.demo.chain.mesage; / ** * Interface étudiante * * @author * * / interface publique Istudent {/ ** * Obtenez le statut de condition de l'élève * * 0: Petites choses (le moniteur de classe peut le gérer) * * 1: Le moniteur de classe ne peut pas gérer les choses que l'enseignant peut gérer * * 2: l'enseignant ne peut pas gérer les choses que le principe peut gérer * * * * / / public int GetState (); / ** * Recevez le message de congé de l'élève * * @return * / public String getRequestMessage ();}3.2 Les étudiants réalisent un étudiant
package com.demo.chain.mesage; / ** * classe de mise en œuvre de l'étudiant * * @author * * / classe publique que l'étudiant implémente iStudent {// taille de la condition private int state = -1; // Message d'adieu Message de chaîne finale privée; Student public (int State, Message de chaîne) {this.state = state; this.Message = message; } / ** * Obtenez le statut de congé de l'élève * * 0: petites choses (le moniteur de classe peut gérer) * * 1: Le moniteur de classe ne peut pas gérer les choses que l'enseignant peut gérer * * * 2: l'enseignant ne peut pas gérer les choses que le directeur peut gérer * * * * / public int getState () {return this.state; } / ** * Get Student Leave Message * * @return * / public String getRequestMessage () {return this.Message; }}3.3 Interface de traitement abstrait-ihandler
package com.demo.chain.handle; import com.demo.chain.mesage.istudent; / ** * Interface de processeur abstrait * * @author * * / interface publique iHandler {// demande de processus public void handlerequest (isTudent Student); // Définit le prochain gestionnaire public void Sethandler (Handler iHandler);}3,4 abstracthandler
package com.demo.chain.handle; import com.demo.chain.mesage.istudent; / ** * Résumé Handler * * @author * * / public abstrait class Abstratracthandler implémente ihandler {// Next handler private ihandler handler; // Laissez le niveau privé int state = -1; // Niveau de réglage du constructeur AbstrAtTracThandler (Int State) {this.state = State; } // gérer les demandes à la sous-classe pour gérer le traitement spécifique du traitement abstrait public (étudiant iStudent); // gérer les demandes publiques void handleRequest (Istudent Student) {// Si l'objet étudiant existe if (étudiant! = Null) {if (this.state == Student.getState ()) {// Si le niveau de laisse est cohérent avec l'objet actuel, l'objet actuel sera traité ce.process (étudiant); } else {if (this.handler! = null) {System.out.println ("Demandez au leader supérieur à répondre!"); // Si l'objet actuel ne peut pas être traité, il sera remis au prochain processeur pour traiter ce.handler.handleRequest (étudiant); }}}}} // Définissez le processeur suivant public void Sethandler (iHandler Handler) {this.handler = mannequin; }}3,5 Squad LeaderHandler
package com.demo.chain.handle; import com.demo.chain.mesage.istudent; / ** * Résumé Handler * * @author * * / public abstrait class Abstratracthandler implémente ihandler {// Next handler private ihandler handler; // Laissez le niveau privé int state = -1; // Niveau de réglage du constructeur AbstrAtTracThandler (Int State) {this.state = State; } // gérer les demandes à la sous-classe pour gérer le traitement spécifique du traitement abstrait public (étudiant iStudent); // gérer les demandes publiques void handleRequest (Istudent Student) {// Si l'objet étudiant existe if (étudiant! = Null) {if (this.state == Student.getState ()) {// Si le niveau de laisse est cohérent avec l'objet actuel, l'objet actuel sera traité ce.process (étudiant); } else {if (this.handler! = null) {System.out.println ("Demandez au leader supérieur à répondre!"); // Si l'objet actuel ne peut pas être traité, il sera remis au processeur suivant pour traiter ce.handler.handleRequest (étudiant); }}}}} // Définissez le processeur suivant public void Sethandler (iHandler Handler) {this.handler = mannequin; }}3.6 enseignant-enseignant-personne
package com.demo.chain.impl; import com.demo.chain.handle.abstracthandler; import com.demo.chain.message.istudent; / ** * Handler de professeur * * @author * * / public class enseignhandler étend abstracthandler {public TeacherHandler () {super (1); } // Sous-classe Demande de traitement spécifique @Override public void Process (Istudent Student) {System.out.println ("Réponse de l'enseignant:" + Student.getRequestMessage ()); }}3.7 Principal-SchoolMasterHandler
Package com.demo.chain.impl; Import com.demo.chain.handle.abstracthandler; import com.demo.chain.message.istudent; / ** * Handler principal * * @Author * * / public class SchoolMasterHandler étend Abstracthandler {public SchoolMashandler () {super (2); } // Sous-classe Demande de traitement spécifique @Override public void Process (Istudent Student) {System.out.println ("Réponse du directeur:" + Student.getRequestMessage ()); }}3.8 Apparence Classe 1 ProcessHandler
Package com.demo.chain.process; import com.demo.chain.handle.ihandler; import com.demo.chain.impl.schoolmasterhandler; import com.demo.chain.impl.squadleaderhandler; import com.demo.chain.impl.teacherhandler; importe com.demo.chain.message.istude; Association * * @author * * / classe publique ProcessHandler {// Class Leader Handler Private Final iHandler sqmshandler; // Gestionnaire d'enseignants final privé IHandler TechHandler; // Principal Handler Private Final Ihandler SCMShandler; // Singleton Mode Private Static ProcessHandler ProcessHandler = new ProcessHandler (); / ** * Méthode du constructeur pour établir une chaîne de responsabilité pour le traitement des congés * / Private ProcessHandler () {// Créer un objet de traitement // leader de classe this.sqmshandler = new squadleaderHandler (); // professeur this.techHandler = new TeacherHandler (); // directeur this.scmshandler = new SchoolMasterHandler (); / ** * Établir une chaîne de responsabilité * / // définir le gestionnaire suivant du chef de classe: enseignant this.sqmshandler.sethandler (this.techhandler); // Définit le gestionnaire suivant de l'enseignant: directeur this.techhandler.sethandler (this.scmshandler); } / ** * Obtenez une instance d'objet singleton * * @return * / public static processHandler getInstance () {return processHandler; } / ** * Envoyer une demande de congé * * @param Message * / public void sendMessage (Istudent Student) {// Envoyer au premier gestionnaire: le chef de classe gère ce.sqmshandler.handlerequest (étudiant); }}3.9 client-client
Package com.demo; import java.util.random; import com.demo.chain.message.istudent; importer com.demo.chain.message.student; import com.demo.chain.process.processhandler; / ** * application principale * * @Author * * CLASSE PUBLICE {/ ** * @Param Args * / Public Static Void Main Client [] args) {// Obtenez l'objet d'apparence processHandler processHandler = processHandler.getInstance (); // Créer un objet de nombre aléatoire pour générer de manière aléatoire un objet étudiant aléatoire aléatoire = new random (); pour (int i = 0; i <3; i ++) {// obtenir un numéro aléatoire int radom = random.nextint (3); Étudiant istudent = nouveau étudiant (radom, "étudiant" + i + "Je suis malade, je veux prendre congé!"); System.out.println ("################################################################################################################# ########################################################################################################### ########################################################################################################### ##################################################X // traite le message processhandler.sendMessage (étudiant); System.out.println ("#########################################################################” ”); }}}4 Résultats en cours d'exécution
##########################################################
Demandez une réponse au leader supérieur!
Demandez une réponse au leader supérieur!
La réponse du directeur: l'étudiant 0 est malade et veut prendre congé!
##########################################################
##########################################################
Demandez une réponse au leader supérieur!
Demandez une réponse au leader supérieur!
La réponse du directeur: l'élève 1 est malade et veut prendre congé!
##########################################################
##########################################################
Le moniteur de classe approuvé: l'élève 2 est malade et veut prendre congé!
##########################################################
Iii. Les principes de conception de ce modèle
1 principe "de clôture ouverte"
2 principe de responsabilité unique
4. Utiliser des occasions
(1) Il existe plusieurs objets qui traitent la même demande. Il est toujours incertain lequel est utilisé pour le gérer. Il n'est déterminé qu'au moment de l'exécution quel objet le gère.
(2) Le message a plusieurs destinataires et l'objet récepteur n'est pas clair. Vous n'avez qu'à envoyer un message à l'un des objets et à le gérer en interne.
(3) Plusieurs objets de traitement du même message peuvent augmenter ou diminuer dynamiquement, et doivent être spécifiés dynamiquement.
5. Diagramme de classe statique du modèle de chaîne de responsabilité
Pour plus de contenu lié à Java, les lecteurs qui sont intéressés par ce site peuvent afficher les sujets: "Tutoriel de structure de données Java et d'algorithme", "Résumé des conseils de nœud de Dom Operation Java", "Résumé du fichier Java et des conseils d'opération de répertoire" et "Résumé des conseils d'opération Java Cache"
J'espère que cet article sera utile à la programmation Java de tous.