Patrón de cadena de responsabilidad: múltiples objetos se conectan a una cadena mediante referencias correspondientes a la próxima casa de sus objetos, y la solicitud se pasa en esta cadena hasta que un objeto receptor en la cadena procesa la solicitud. Debido a que el cliente solicitante no sabe quién eventualmente manejará la solicitud en la cadena, el sistema puede reorganizar y asignar dinámicamente las responsabilidades sin afectar al cliente, evitando así el acoplamiento entre el remitente de solicitud y el controlador de solicitudes.
Hay tres roles involucrados en la cadena de responsabilidad:
1. Rol de procesador abstracto
2. Rol de controlador específico
3. Pequeño ejemplo del remitente de solicitud: suponga que va a comprar una casa y debe negociar al comprar una casa. Las posiciones de la persona que vende la casa son diferentes, y los precios con descuento también son diferentes. Las diferentes posiciones pueden formar una cadena para procesar la solicitud. Establecimos tentativamente: * Los vendedores de base solo pueden ofrecer 3% de descuento * Gerente de ventas: 5% Descuento * Director de ventas: 8% Descuento * Jefe: 10% Descuento
Instancia de Java
Diagrama de clases:
/ *** Responsabilidad abstracta*/ clase public abstract Ifilter {private ifilter sucesor; public Ifilter getSuccessor () {return Sucesor; } public void setSuccessor (ifilter Sucesor) {this.successor = sucesor; } public abstract void maneFilter (); Public Abstract Void MANTANGILTER2 (); } / *** Responsabilidades específicas*/ public class ConcreteFilter extiende ifilter {nombre de cadena privada; public ConcreteFilter (nombre de cadena) {this.name = name; } @Override public void manefilter () { / * * manejarlo primero, si hay un sucesor, luego manejarlo una vez * / system.out.println (nombre + "solicitud procesada"); if (getSuccessor ()! = NULL) {getSuccessor (). manejador (); }} @Override public void manefilter2 () { / * * Si hay un sucesor, entonces el sucesor será manejado por usted mismo. De lo contrario, lo manejará usted mismo*/ if (getSuccessor ()! = NULL) {getSuccessor (). HandleFilter2 (); } else {system.out.println (nombre + "solicitud procesada"); }}} Prueba de clase pública {public static void main (string [] args) {ifilter filtre1 = new ConcreteFilter ("permiso-filter"); // Filtro de permiso Ifilter Filter2 = New ConcreteFilter ("Suffix-Filter"); // Filter Affix Ifilter3 = nuevo Concretefilter ("Style-Filter"); // Style Filter1.Setsetsetsetsetsetsetsetsetsetsets (Filter2); filtre2.setsuccessor (filtro3); System.out.println ("----- Lo siguiente es manejado por cada procesador (incluidos los sucesores), el pedido también es un pase nivelado por nivel ------"); filtre1.handlefilter (); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Imprimir:
------ El siguiente es el proceso de cada procesador (incluidos los sucesores), y el pedido también es un nivel después de otro ----- El filtro de permiso maneja la solicitud de sufijo de filtro de sufijo el filtro de estilo de solicitud maneja la solicitud ------- El siguiente es el proceso de la última successor---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------