23 Patrones de diseño Capítulo 19: Modelo de cadena de responsabilidad de Java
Definición: permite que múltiples objetos tengan la oportunidad de procesar la solicitud, evitando así la relación de acoplamiento entre el remitente y el receptor de la solicitud. Conecte estos objetos en una cadena y pase la solicitud a lo largo de la cadena hasta que un objeto la procese.
Tipo: Patrón de comportamiento
Diagrama de clases:
Veamos primero un código:
Public void test (int i, solicitud de solicitud) {if (i == 1) {handler1.Response (solicitud); } else if (i == 2) {handler2.Response (solicitud); } else if (i == 3) {Handler3.Response (solicitud); } else if (i == 4) {Handler4.Response (solicitud); } else {Handler5.Response (solicitud); }}La lógica comercial del código es la siguiente: el método tiene dos parámetros: el entero I y una solicitud de solicitud. De acuerdo con el valor de I, quién manejará la solicitud, si i == 1, Handler2 la manejará, si I == 2, será manejado por Handler2, y así sucesivamente.
En la programación, este tipo de método de procesamiento comercial es muy común. Todas las clases de las solicitudes de proceso incluyen si ... de lo contrario ... declaraciones de juicio condicional conectadas a una cadena de responsabilidad para procesar la solicitud. Creo que todos lo usan a menudo. Las ventajas de este método son que es muy intuitiva, simple y clara y relativamente fácil de mantener, pero este método también tiene varios dolores de cabeza:
Código hinchado: en las aplicaciones reales, las condiciones del juicio generalmente no son tan simples de determinar si es 1 o 2. Puede requerir cálculos complejos, tal vez consultar la base de datos, etc. Esto tendrá mucho código adicional. Si hay muchas condiciones de juicio, entonces esto si ... de lo contrario ... la declaración es básicamente imposible de leer.
Grado de acoplamiento alto: si queremos continuar agregando clases que procesen solicitudes, debemos continuar agregando más si el juicio se condiciones; Además, el orden de esta condición también se escribe a los muertos. Si queremos cambiar el pedido, solo podemos modificar esta declaración de condición.
Como ya hemos entendido las deficiencias, necesitamos encontrar una manera de resolverlas. La lógica comercial de este escenario es muy simple: si se cumple la condición 1, Handler1 la procesará, y si no se cumple, se transmitirá; Si se cumple la condición 2, Handler2 la procesará, y si no se cumple, se transmitirá, y así sucesivamente hasta el final de la condición. De hecho, el método de mejora también es muy simple, que es poner la parte de las condiciones del juicio en la clase de procesamiento. Este es el principio del modelo de conexión de responsabilidad.
La estructura del modelo de cadena de responsabilidad
El diagrama de clases del patrón de la cadena de responsabilidad es muy simple, consiste en una clase procesada abstracta y su conjunto de clases de implementación:
Clase de procesamiento abstracto: la clase de procesamiento abstracto incluye principalmente un nextandler variable miembro que apunta a la siguiente clase de procesamiento y una requería de mano de método que maneja la solicitud. La idea principal del método de requisito de manos es que si se cumplen las condiciones de procesamiento, esta clase de procesamiento será procesada, de lo contrario, Nexthandler lo procesará.
Clase de procesamiento específica: la clase de procesamiento específica implementa principalmente la lógica de procesamiento específica y las condiciones aplicables para el procesamiento.
Después de comprender la idea general del modelo de cadena de responsabilidad, será más fácil de entender al mirar el código:
nivel de clase {private int nivel = 0; nivel público (nivel int) {this.level = nivel; }; public boolean arriba (nivel de nivel) {if (this.level> = nivel.level) {return true; } return false; }} solicitud de clase {nivel de nivel; Solicitud pública (nivel de nivel) {this.level = nivel; } nivel público getLevel () {nivel de retorno; }} Respuesta de clase {} Handler de clase abstracta {Handler privado Nexthandler; HandLerequest de respuesta final pública (solicitud de solicitud) {Respuesta de respuesta = nulo; if (this.gethandlerLevel (). arriba (request.getLevel ())) {respuesta = this.Response (request); } else {if (this.nexthandler! = null) {this.nexthandler.handlerequest (solicitud); } else {System.out.println ("----------"); }} Respuesta de retorno; } public void setNexThandler (Handler Handler) {this.nexthandler = handler; } nivel abstracto protegido gethandlerLevel (); Respuesta de respuesta de resumen público (solicitud de solicitud); } clase ConcreteHandler1 extiende el controlador {nivel protegido gethandlerLevel () {return new nivel (1); } Respuesta de respuesta pública (solicitud de solicitud) { System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ class ConcreteHandler2 extiende el manejo {nivel protegido GethandlerLevel () {return new Level (3); System.out.println ("------ Las solicitudes se procesan por el procesador 3 -----"); Handler1.SetNexThandler (Handler2);En el código, la clase de nivel simula las condiciones de determinación; La solicitud y la respuesta corresponden a solicitudes y respuestas respectivamente; El controlador de clase abstracto juzga principalmente las condiciones, y aquí se simula un nivel de procesamiento. Solo el nivel de procesamiento de la clase de procesamiento es más alto que el nivel de la solicitud se puede procesar, de lo contrario se entregará al próximo procesador para su procesamiento.
Establezca la relación de ejecución delantera y posterior de la cadena en la clase del cliente y entregue la solicitud a la primera clase de procesamiento durante la ejecución. Este es el patrón de cadena de responsabilidad. La función que completa es la misma que la declaración if ... else ... en el artículo anterior.
Pros y contras del modelo de cadena de responsabilidad
En comparación con si ... de lo contrario ..., el patrón de cadena de responsabilidad tiene una capacidad de acoplamiento más baja porque distribuye los juicios condicionales en varias clases de procesamiento, y el orden de procesamiento de prioridad de estas clases de procesamiento se puede establecer a voluntad. El modelo de cadena de responsabilidad también tiene sus desventajas, que es lo mismo que la declaración if ... else ..., es decir, antes de encontrar la clase de procesamiento correcta, todas las condiciones de juicio deben ejecutarse. Cuando la cadena de responsabilidad es relativamente larga, el problema de rendimiento es más grave.
Escenarios aplicables para el modelo de cadena de responsabilidad
Al igual que el ejemplo inicial, si se siente abrumado al usar la declaración if ... de lo contrario ... para organizar una cadena de responsabilidad y el código se ve mal, puede usar la cadena de responsabilidad para refactorizarla.
Resumir
El modelo de cadena de responsabilidad es en realidad una versión flexible de la declaración if ... else ... Pone estas condiciones de juicio en cada clase de procesamiento. La ventaja de esto es que es más flexible, pero también trae riesgos. Por ejemplo, al establecer la relación entre la clase de procesamiento antes y después de la clase de procesamiento, debe tener mucho cuidado de juzgar la relación entre la lógica condicional antes y después de la clase de procesamiento, y tener cuidado de no tener referencias circulares en la cadena.
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.