Este artículo describe el uso del modo de cadena de responsabilidad para que los estudiantes se demuestren. Compártelo para su referencia, como sigue:
1. Definición de patrones
En el modelo de cadena de responsabilidad, muchos objetos están conectados por referencias a su próximo hogar por cada objeto, formando una cadena. La solicitud de solicitud del cliente se pasa en esta cadena hasta que un objeto en la cadena decide procesar la solicitud. El cliente que realiza esta solicitud no sabe qué objeto en la cadena finalmente maneja la solicitud, lo que permite al sistema reorganizar dinámicamente la cadena y asignar responsabilidades sin afectar al cliente.
(1) Rol de procesador abstracto: Defina una interfaz para las solicitudes de procesamiento. Si es necesario, la interfaz puede definir un método para establecer y devolver la referencia al siguiente hogar. Este rol generalmente es implementado por una clase abstracta Java o interfaz Java.
(2) Rol de procesamiento específico: después de recibir la solicitud, el procesador específico puede optar por procesar la solicitud o pasar la solicitud al siguiente hogar.
2. Ejemplos de modelo
1 análisis de patrones
Tomamos prestado el permiso de los estudiantes para ilustrar este modelo
2 Diagrama de clase estática del patrón de cadena de responsabilidad
3 ejemplos de código
3.1 Interfaz de estudiante Istudent
paquete com.demo.chain.message;/** * Interfaz estudiantil * * @author * */pública interfaz istudent {/** * Obtener el estado de condición del alumno * * 0: las cosas pequeñas (el monitor de clases puede manejarlo) * * 1: el monitor de clase no puede manejar cosas que el maestro puede manejar * * 2: el maestro no puede manejar cosas que el director puede manejar * * */público int getstate (); / ** * Obtenga el mensaje de licencia del estudiante * * @return */ public String getRequestMessage ();}3.2 Los estudiantes se dan cuenta de un estudiante
paquete com.demo.chain.message;/** * Clase de implementación del estudiante * * @author * */public class Student implementa istudent {// tamaño de la condición privada int state = -1; // Mensaje de despedida Mensaje de cadena final privada; Estudiante público (int State, String Message) {this.state = state; this.message = Mensaje; } / ** * Obtenga el estado de licencia del estudiante * * 0: cosas pequeñas (el monitor de clase puede manejar) * * 1: El monitor de clase no puede manejar cosas que el maestro puede manejar * * * 2: el maestro no puede manejar cosas que el principal puede manejar * * * * / public int getState () {return this.state; } / ** * Obtener mensaje de licencia de estudiante * * @return * / public String getRequestMessage () {return this.message; }}3.3 Interfaz de procesamiento abstracto-IHANDLER
paquete com.demo.chain.handle; import com.demo.chain.message.istudent;/** * Interfaz de procesador abstracto * * @author * */public interfaz ihandler {// Solicitud de proceso Public void HandLerequest (Istudent Student); // Establecer el próximo manejador público Void Sethandler (iHandler Handler);}3.4 Abstráctil
paquete com.demo.chain.handle; import com.demo.chain.message.istudent;/** * manejador abstracto * * @author * */public abstract class abstractthandler implementa ihandler {//próximo manejador privado iHandler manejador; // dejar nivel de nivel privado int state = -1; // nivel de configuración de constructor abstractthandler (int state) {this.state = state; } // manejar las solicitudes a la subclase para manejar el procesamiento específico del proceso de vacío de abstracto público (estudiante istudent); // manejar las solicitudes public void handLerequest (istudent student) {// Si el objeto estudiantil existe si (student! = Null) {if (this.state == student.getState ()) {// Si el nivel de licencia es consistente con el actual, el objeto actual se procesará this.process (student); } else {if (this.handler! = null) {system.out.println ("¡Solicite al líder superior para que responda!"); // Si el objeto actual no se puede procesar, se entregará al siguiente procesador para procesar esto.handler.handlerequest (estudiante); }}}}} // Establezca el siguiente procesador public Void Sethandler (iHandler Handler) {this.handler = Handler; }}3.5 Líder Líder de escuadrón
paquete com.demo.chain.handle; import com.demo.chain.message.istudent;/** * manejador abstracto * * @author * */public abstract class abstractthandler implementa ihandler {//próximo manejador privado iHandler manejador; // dejar nivel de nivel privado int state = -1; // nivel de configuración de constructor abstractthandler (int state) {this.state = state; } // manejar las solicitudes a la subclase para manejar el procesamiento específico del proceso de vacío de abstracto público (estudiante istudent); // manejar las solicitudes public void handLerequest (istudent student) {// Si el objeto estudiantil existe si (student! = Null) {if (this.state == student.getState ()) {// Si el nivel de licencia es consistente con el actual, el objeto actual se procesará this.process (student); } else {if (this.handler! = null) {system.out.println ("¡Solicite al líder superior para que responda!"); // Si el objeto actual no se puede procesar, se entregará al siguiente procesador para procesar esto.handler.handlerequest (estudiante); }}}}} // Establezca el siguiente procesador public Void Sethandler (iHandler Handler) {this.handler = Handler; }}3.6 maestro-maestro-maestro
paquete com.demo.chain.impl; import com.demo.chain.handle.abstractthandler; import com.demo.chain.message.istudent;/** * manejador de maestros * * @author * */public class MaestroHandler extiende Abstractthandler {Public TeacherHandler () {Super (1); } // Subclase Solicitud de procesamiento específica @Override Public void Process (Istudent Student) {System.out.println ("Respuesta del maestro:" + student.getRequestMessage ()); }}3.7 Principal-SchoolMasterHandler
paquete com.demo.chain.impl; import com.demo.chain.handle.abstractthandler; import com.demo.chain.message.istudent;/** * manejador principal * * @author * */public class SchoolmasMasterHandler extiende Abstracthandler {public SchoolMasterHandler () {Super (2); } // Subclase Solicitud de procesamiento específica @Override Public Void Process (Istudent Student) {System.out.println ("Respuesta del principal:" + student.getRequestMessage ()); }}3.8 Apariencia Clase 1 PROCESO HANDLER
paquete com.demo.chain.process; import com.demo.chain.handle.ihandler; import com.demo.chain.impl.schoolmasterhandler; import com.demo.chain.impl.squadleaderHandler; import.demo.chain.Impl.ToacherHandler; Asociación * * @author * */public class ProcessHandler {// Líder de clase Handler Private Final Ihandler Sqmshandler; // Manejador de maestros Final Private Ihandler TechHandler; // Director principal Final Private Ihandler Scmshandler; // Singleton Mode privado ProcessHandler ProcessHandler = new ProcessHandler (); / *** Método del constructor para establecer una cadena de responsabilidad para dejar el procesamiento*/ privado ProcessHandler () {// Crear objeto de procesamiento // líder de clase this.sqmshandler = new SquadLeaderHandler (); // maestro this.techhandler = new TeacherHandler (); // principal this.scmshandler = new SchoolMasterHandler (); / *** Establecer una cadena de responsabilidad*/ // Establezca el próximo manejador del líder de la clase: maestro this.sqmshandler.sethandler (this.techhandler); // Establezca el siguiente manejador del maestro: Principal this.techhandler.sethandler (this.scmshandler); } / ** * Obtenga una instancia de objeto Singleton * * @return * / public static ProcessHandler getInstance () {return ProcessHandler; } / ** * Enviar una solicitud de licencia * * @param Mensaje * / public void sendMessage (estudiante istudent) {// Enviar al primer manejador: el líder de clase maneja esto.sqmshandler.handlerequest (estudiante); }}3.9 Cliente de cliente
paquete com.demo; import java.util.random; import com.demo.chain.message.istudent; import com.demo.chain.message.student; import com.demo.chain.process.processhandler;/** * principal aplicación * * @author * */public class Client {/ * @paramam */public stats stats (string string [ @@author * */public class Client {/ * @param Void void void void void win args) {// Obtener el objeto de apariencia ProcessHandler ProcessHandler = ProcessHandler.getInstance (); // Cree un objeto de número aleatorio para generar aleatoriamente el objeto estudiantil aleatoria aleatoria = new Random (); for (int i = 0; i <3; i ++) {// Obtener número aleatorio int radom = random.nextint (3); Istudent Student = New Student (Radom, "Estudiante" + I + "¡Estoy enfermo, quiero despedirme!"); System.out.println ("##############################################################################################################################################. ########################################################################################################################################################. ########################################################################################################################################################. ################################################################################################################. // Process el mensaje ProcessHandler.SendMessage (estudiante); System.out.println ("###########################################"); }}}4 Resultados de ejecución
######################################################.
¡Solicite una respuesta del líder superior!
¡Solicite una respuesta del líder superior!
La respuesta del director: ¡el estudiante 0 está enfermo y quiere despedirse!
######################################################.
######################################################.
¡Solicite una respuesta del líder superior!
¡Solicite una respuesta del líder superior!
La respuesta del director: ¡el estudiante 1 está enfermo y quiere despedirse!
######################################################.
######################################################.
El monitor de clase aprobado: ¡El estudiante 2 está enfermo y quiere despedirse!
######################################################.
Iii. Los principios de diseño de este patrón
Principio de 1 "cierre abierto"
2 Principio de responsabilidad única
4. Use ocasiones
(1) Hay múltiples objetos que procesan la misma solicitud. Todavía es incierto qué se usa para manejarlo. Solo se determina en tiempo de ejecución qué objeto lo maneja.
(2) El mensaje tiene múltiples destinatarios, y el objeto receptor no está claro. Solo necesita enviar un mensaje a uno de los objetos y manejarlo internamente.
(3) múltiples objetos de procesamiento del mismo mensaje pueden aumentar o disminuir dinámicamente, y deben especificarse dinámicamente.
5. Diagrama de clase estática del patrón de cadena de responsabilidad
Para obtener más contenido relacionado con Java, los lectores interesados en este sitio pueden ver los temas: "Estructura de datos de Java y tutorial de algoritmo", "Resumen de las puntas de nodo de operación de Java DOM", "Resumen de los archivos Java y consejos de operación de directorio" y "Summary of Java Cache Operation Tips" ".
Espero que este artículo sea útil para la programación Java de todos.