Definición: El patrón de cadena de responsabilidad crea una cadena del objeto receptor para la solicitud. Este patrón proporciona el tipo de solicitud, desacoplando al remitente y receptor de la solicitud. Este tipo de patrón de diseño pertenece al patrón de comportamiento. En este modo, generalmente cada destinatario contiene una referencia a otro destinatario. Si un objeto no puede procesar la solicitud, pasa la misma solicitud al siguiente receptor, y así sucesivamente.
Características: 1. Reducir el grado de acoplamiento. Desacula el remitente y el receptor de la solicitud.
2. Simplificó el objeto. Esto hace que el objeto no sea necesario para conocer la estructura de la cadena.
3. Mejorar la flexibilidad para asignar responsabilidades al objetivo. Al cambiar los miembros en la cadena o movilizar su orden, permite la adición o eliminación dinámica de responsabilidades.
4. Es muy conveniente agregar nuevas clases de procesamiento de solicitudes.
Aplicaciones en desarrollo de nivel empresarial y marcos de uso común: primavera, interceptor de struts, filtro de servlet
Ejemplos específicos:
/** * Aquí hay un ejemplo de la licencia de una empresa: * 1. Alguien se lleva licencia (evento) *2. Aprobación del líder del equipo del proyecto: la aprobación puede aprobarse menos de tres días y solicita a los superiores más de tres días*3. Aprobación del supervisor del departamento: la aprobación puede aprobarse menos de diez días y solicita a los superiores más de diez días*4. Aprobación del gerente general: la aprobación puede aprobarse menos de 30 días, y no aprueba más de 30 días*/Demo de clase pública {public static void main (string [] args) {event event = new Event ("programador", 32, "regresa a la ciudad natal para visitar los familiares"); Líder a = nuevo Groupleader ("Zhang San"); Líder b = nuevo gerente ("li si"); Líder c = nuevo GeneralManager ("Wang Wu"); // especificar la cadena de modo de responsabilidad A.SetNextLeader (b); B.SetNextLeader (C); A.Handler (evento); }}/*** Objeto de evento, eventos de procesamiento específicos en la cadena de responsabilidad* Esta instancia es la cuestión de pedir el evento de licencia*/clase {nombre de cadena privada; Días privados int; razón de cadena privada; evento público (nombre de cadena, int days, string razon) {super (); this.name = name; this.days = días; this.Rason = Razón; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } public int getdays () {Return Days; } public void setdays (int days) {this.days = días; } public String getRason () {Return Razon; } public void setRason (string razon) {this.Rason = razon; }}/*** Objeto de cadena de responsabilidad abstracta, todos los objetos de cadena de responsabilidad real que siguen se heredan de este objeto*/líder de clase abstracta {nombre de cadena privada; Líder protegido NextLeader; // El siguiente objeto de responsabilidad en la cadena de responsabilidad, esta es la base para mantener la cadena de responsabilidad del líder público (nombre de cadena) {super (); this.name = name; } public void setNextLeader (líder NextLeader) {this.nextleader = nextleader; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } Handler void abstracto protegido (evento de evento);}/*** El primer objeto en el proceso de licencia, líder de grupo*/class Groupleader extiende líder {public Groupleader (nombre de cadena) {super (nombre); } controlador vacío protegido (evento de evento) {if (event.getdays () <3) { System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------- Razón de licencia: " + event.getRazon () +" | "); System.out.println ("aprobador:"+this.getName ()+"(líder de grupo), pase!"); System.out.println (); } else {System.out.println (this.getName ()+"(Supervisor), ¡sin permisos!"); this.nextleader.handler (evento); }}}/*** El segundo objeto en el proceso de licencia, el administrador del departamento*/class Manager extiende líder {public Manager (name de cadena) {super (nombre); } controlador vacío protegido (evento de evento) {if (event.getdays () <10) { System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- System.out.println (this.getName ()+"(General Manager), sin permisos!"); 30){ System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ offender: "+event.getName ()+" | "); System.out.println (" Número de días de licencia: "+event.getdays ()+" días "+" | "); system.out.println (" | Razón para la licencia: "+event.getRazon ()+" | "); system.out.println (" aprobador: "+this.getName ()+" gerente general) "); system.out.print (); System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- The leave requester: "+event.getName ()+" | "); System.out.println ();}}}El modelo de cadena de responsabilidad se utiliza principalmente para el desarrollo, como el control de procesos. En comparación con el modelo IF-ELSE, tiene una mayor eficiencia en la modificación e integración del código, que es más propicio para el mantenimiento del código. Además, cuando es necesario agregar objetos en la cadena de responsabilidad, necesitamos implementar una clase de cadena de responsabilidad específica, luego crear un objeto de responsabilidad y mantener la relación de la cadena de responsabilidad, sin una mayor sobrecarga. Además, en el diseño real, muchas veces, el mantenimiento de la cadena de responsabilidad se lleva a cabo en el archivo de configuración, lo que ahorrará más tiempo de desarrollo.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.