Definición de la cadena de responsabilidad: la cadena de responsabilidad (COR) es una serie de clases que intentan procesar una solicitud. En otras palabras, cuando llega una solicitud, primero se procesa la clase A.
Cómo usar el modelo de cadena de responsabilidad
Aunque este párrafo usa COR, también demuestra qué es COR.
Hay una interfaz de controlador:
La copia del código es la siguiente:
manejador de interfaz pública {
Public Void Handlerequest ();
}
Este es un ejemplo de solicitudes de manejo.
◆ La primera solución que viene a la mente es: agregar múltiples solicitudes a la interfaz:
La copia del código es la siguiente:
manejador de interfaz pública {
public void handleHelp ();
public void handlePrint ();
public void handleFormat ();
}
Específicamente, es un código para implementar la interfaz:
La copia del código es la siguiente:
Handler de implementos de implementos de clase pública {
sucesor de manejador privado;
Public ConcreteHandler (Sucesor de Handler) {
this.successor = sucesor;
}
public void handleHelp () {
// Código específico para procesar la solicitud de ayuda ...
}
public void handlePrint () {
// Si es una impresión, recurra a la impresión del proceso
sucesor.handlePrint ();
}
public void handleFormat () {
// Si es formato, vaya al formato de proceso
sucesor.handleformat ();
}
}
Hay tres clases de implementación específicas, anteriores, que son la ayuda de procesamiento y el formato de impresión y procesamiento de procesamiento, que son probablemente nuestras ideas de programación más utilizadas.
Aunque la idea es simple y clara, hay un problema de extensión.
◆ La segunda solución: convierta cada solicitud en una interfaz, por lo que tenemos el siguiente código:
La copia del código es la siguiente:
interfaz pública HelpHandler {
public void handleHelp ();
}
Printandler de interfaz pública {
public void handlePrint ();
}
interfaz pública formathandler {
public void handleFormat ();
}
clase pública ConcreteHandler
Implementa HelpHandler, Printhandler, Formathandlet {
Helphandler privado HelpingCcessor;
Printhandler Privintler PrintSuccessor;
Formathandler privado Formatsuccessor;
Public ConcreteHandler (HelpHandler HelpingCessor, Printhandler PrintSuccessor, Formathandler Formatsuccessor)
{
this.helpSuccessor = HelpingUccessor;
this.printSuccessor = printSuccessor;
this.FormatSuccessor = FormatSuccessor;
}
public void handleHelp () {
.........
}
public void handlePrint () {this.printsuccessor = printSuccessor;}
public void handleFormat () {this.FormatSuccessor = FormatSuccessor;}
}
Al agregar una nueva solicitud de solicitud, este método solo guarda la cantidad de modificación de la interfaz, y la implementación de la interfaz del ConcreteHandler también debe modificarse. Y el código obviamente no es simple y hermoso.
◆ Solución 3: Solo se utiliza un método de parametrización en la interfaz del controlador:
La copia del código es la siguiente:
manejador de interfaz pública {
public void handlerequest (solicitud de cadena);
}
Entonces el código de implementación del controlador es el siguiente:
Handler de implementos de implementos de clase pública {
sucesor de manejador privado;
Public ConcreteHandler (Sucesor de Handler) {
this.successor = sucesor;
}
public void handlerequest (solicitud de cadena) {
if (request.equals ("ayuda")) {
// Aquí está el código específico para manejar la ayuda} más
// pasar al siguiente sucesor.handle (solicitud);
}
}
}
Primero asumamos que la solicitud es de tipo de cadena. Por supuesto que podemos crear una solicitud de clase especial
◆ La solución final: el código del controlador de interfaz es el siguiente:
La copia del código es la siguiente:
manejador de interfaz pública {
Public void Handlerequest (solicitud de solicitud);
}
Definición de clase de solicitud:
Solicitud de clase pública {
tipo de cadena privada;
Solicitud pública (tipo de cadena) {this.type = type;}
public String getType () {type de retorno;}
public void ejecute () {
// Código de comportamiento específico real de la solicitud}
}
Entonces el código de implementación del controlador es el siguiente:
La copia del código es la siguiente:
Handler de implementos de implementos de clase pública {
sucesor de manejador privado;
Public ConcreteHandler (sucesor de controlador) {
this.successor = sucesor;
}
public void handlerequest (solicitud de solicitud) {
if (solicitar instancia de ayuda de ayuda) {
// Aquí está el código específico para manejar ayuda} else if (solicitar instancia de prinTequest) {
request.exCute ();
}demás
// pasar al siguiente sucesor.handle (solicitud);
}
}
}
Esta solución es cor.
1. Ventajas de COR: Debido a que es imposible predecir a qué tipo de solicitudes del mundo exterior pertenecen, si cada clase encuentra una solicitud que no puede procesar, simplemente se rinda. Esto indudablemente reduce el acoplamiento entre clases.
2. La desventaja de COR es su ineficiencia, porque la finalización de una solicitud puede ser atravesada hasta el final antes de que pueda completarse. En Java AWT1.0, el manejo de los botones del mouse es usar COR.
La escalabilidad es pobre porque en COR, debe haber un controlador de interfaz unificado.