23 Modos de diseño 20: Modelo intermediario de Java
Definición: Encapsular una serie de interacciones de objetos con un objeto mediador. El mediador hace que cada objeto interactúe sin visualización, aflojando así el acoplamiento y cambiando de forma independiente la interacción entre ellos.
Tipo: Patrón de comportamiento
Diagrama de clases:
La estructura del modelo intermediario
El modo intermediario también se llama modo mediador. Del diagrama de clases, se divide en 3 partes:
Mediador abstracto: defina la interfaz entre los objetos de clase colega y los objetos mediadores, y se utiliza para la comunicación entre cada clase de colega. En general, incluye uno o varios métodos de eventos abstractos y es implementado por subclases.
Clase de implementación intermedia: heredado de mediadores abstractos e implementos métodos de eventos definidos en mediadores abstractos. Reciba mensajes de una clase de colega e influye en otras clases simultáneas a través del mensaje.
Clase colega: si un objeto afecta a otros objetos y también se ve afectado por otros objetos, entonces estos dos objetos se llaman clases de colega. En el diagrama de clases, solo hay una clase de colega, que en realidad es una omisión de la realidad. En aplicaciones prácticas, la clase de colega generalmente se compone de múltiples, e influyen y dependen entre sí. Cuantos más colegas hay, más complicadas son las relaciones. Además, la clase colega también puede representarse como un conjunto de implementaciones que heredan la misma clase abstracta. En el modelo intermediario, el mensaje debe transmitirse a través de intermediarios entre colegas.
Por qué usar el modelo intermediario
En términos generales, la relación entre las clases de colega es relativamente compleja. Cuando se correlacionan múltiples clases de colega, su relación aparecerá como una estructura de malla compleja. Esta es una arquitectura demasiado acoplada, es decir, no es propicio para la reutilización de clases y no es estable. Por ejemplo, en la figura a continuación, hay seis objetos similares a colegos. Si el objeto 1 cambia, 4 objetos se verán afectados. Si el objeto 2 cambia, entonces 5 objetos se verán afectados. En otras palabras, el diseño de la correlación directa entre colegas no es bueno.
Si se introduce el modelo intermediario, la relación entre las clases de colega se convertirá en una estructura estrella. De la figura, podemos ver que los cambios en cualquier clase solo afectarán la clase misma y el intermediario, lo que reducirá el acoplamiento del sistema. Un buen diseño definitivamente no encapsulará toda la lógica de procesamiento de la relación de objetos en esta clase, pero utilizará una clase especial para administrar comportamientos que no le pertenecen.
Usemos un ejemplo para ilustrar qué es una clase de colega: hay dos clases A y B, cada una de las cuales tiene un número, y debemos asegurarnos de que los números en la clase B siempre sean 100 veces los números en la clase A. es decir, al modificar el número de clase A, multiplicar el número por 100 y asignarlo a la Clase B, y al modificar la clase B, dividir el número por 100 y asignarlo a la Clase A. El código es el siguiente:
Abstract Class AbstractColleague {Número de int protegido; public int getNumber () {número de retorno; } public void setNumber (int número) {this.number = number; } // Método de resumen, modifique el objeto asociado al mismo tiempo al modificar los números públicos abstracts void setNumber (int number, abstractcolleague coll); } Class ColleaGea extiende AbstractColleague {public void setNumber (int number, abstractColleague Coll) {this.number = number; coll.setNumber (número*100); }} Class ColleagueB extiende AbstractColleague {public void setNumber (int número, abstractcolleague coll) {this.number = number; coll.setNumber (número/100); }} Cliente de clase pública {public static void main (string [] args) {abstractColleague colla = new colleaGea (); AbstractColleague collb = new ColliegueB (); System.out.println ("================================================ =================================================================== =================================================================== ===================================================================== =================================================================== =================================================================== =================================================================== ===================================================================== System.out.println ("Valor de número de Collb:"+collb.getNumber ()); En el código anterior, la clase A y B están relacionadas a través de la asociación directa. Si queremos usar el modelo intermediario, la clase A y B no pueden estar directamente relacionadas. Deben usar un intermediario para lograr el propósito de la asociación.
Abstract Class AbstractColleague {Número de int protegido; public int getNumber () {número de retorno; } public void setNumber (int número) {this.number = number; } // Tenga en cuenta que los parámetros aquí ya no son colegas, sino un intermediario público de abstracto público setNumber (int number, abstractMediator am); } Class ColleaGea extiende AbstractColleague {public void setNumber (int number, abstractMediator am) {this.number = number; AM.AaffectB (); }} Class ColleagueB extiende AbstractColleague {@Override public void setNumber (int number, abstractMediator am) {this.number = number; am.baffecta (); }} Clase abstracta AbstractMediator {ProveyColleague protegido A; abstracto de abstracto protegido B; Public AbstractMediator (AbstractCollesague A, AbstractCollesague b) {a = a; B = b; } public abstract void aAffectB (); Public Abstract void baffecta (); } El mediador de clase extiende AbstractMediator {Public Mediator (AbstractCollesague A, AbstractColleague B) {Super (A, B); } // manejar el impacto de A en B public void aaffectb () {int number = a.getNumber (); B.SetNumber (número*100); } // manejar el impacto de B en un público vacío público () {int number = B.getNumber (); A.SetNumber (número/100); }} Cliente de clase pública {public static void main (string [] args) {abstractColleague colla = new colleaGea (); AbstractColleague collb = new ColliegueB (); AbstractMediator AM = nuevo mediador (cola, collb); System.out.println ("======================== Efecto al establecer A ========================================================================================================================================================= =========================================================================================================================================================== =========================================================================================================================================================== ============================================================================================================================================================== ¡ System.out.println ("El valor del número de cola es:"+colla.getNumber ()); B ============================================================================================================================================================================================================================================================= ¡ =====================================================================================================================================================================================================================================================. ==================================================================================================================================================================================================================================================== ¡ =====================================================================================================================================================================================================================================================. System.out.println ("El valor del número de Collb es:"+collb.getNumber ());Aunque el código es relativamente largo, sigue siendo relativamente fácil de entender. De hecho, es volver a empaquetar el código que originalmente maneja las relaciones de objetos en una clase de mediación y manejar la relación entre los objetos a través de esta clase de mediación.
Ventajas del modelo intermediario
1. El uso apropiado del modelo intermediario puede evitar un acoplamiento excesivo entre las clases de colega, de modo que cada clase de colega se pueda usar de manera relativamente independiente.
2. El uso del patrón de mediador puede transformar las relaciones de uno a muchos entre objetos en relaciones uno a uno, lo que hace que las relaciones entre objetos sean fáciles de entender y mantener.
3. El uso del modelo intermediario puede abstraer el comportamiento y la colaboración de los objetos, y puede manejar las interacciones entre los objetos de manera más flexible.
Escenarios aplicables
En la programación orientada a objetos, una clase dependerá inevitablemente de otras clases, y las clases completamente independientes no tienen sentido. También es bastante común que una clase confíe en múltiples clases al mismo tiempo. Dado que tal situación existe, significa que la dependencia de uno a muchos tiene su racionalidad. El uso apropiado del patrón de mediador puede aclarar la relación de objetos originalmente desordenada, pero si se abusa, puede traer efectos negativos. En términos generales, el modelo mediador se considera solo para la relación entre las clases de compañeros de trabajo donde hay una estructura de malla. La estructura de la malla se puede transformar en una estructura estrella para aclarar la relación entre los colegas.
El modelo intermediario es un modelo relativamente común y un modelo abusado relativamente fácil de ser. En la mayoría de los casos, la relación entre las clases de colega no será complicada para una estructura de malla caótica. Por lo tanto, en la mayoría de los casos, está bien encapsular las dependencias entre objetos dentro de la clase de colega, y no es necesario introducir el modelo intermediario. El abuso del modelo intermediario solo hará las cosas más complicadas.
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.