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: Diagrama de clase de patrón de clase de comportamiento:
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.
ejemplo
El siguiente es un ejemplo de código específico. En comparación con el diagrama de clase general, se agregan la clase de colega de resúmenes abstractos y el mediador de abstracto del mediador abstracto. Además, hay dos clases de colega específicas y un mediador específico. Hay muchos comentarios en el código, y el diagrama de clase correspondiente no se da, lo que no debería ser difícil de entender:
Colegas:
// colega colega clase resumen clase abstractcolleague {mediador de mediador de abstracto protegido; /** Dado que hay un intermediario, entonces cada colega específico debe tener contacto con el intermediario,*de lo contrario, no hay necesidad de existir en este sistema. El constructor aquí es equivalente a registrar un intermediario con el sistema para ponerse en contacto*/ public abstractcolleague (abstractMediator Mediator) {this.mediator = Mediator; } // Agregue un método para contactar al intermediario (es decir, registrarse) en el colega abstracto clase public void setMediator (resumen mediator) {this.mediator = mediator; }} // colega específico Una coleaguea de clase extiende abstractcolleague {// Cada colega específico contacta al mediador a través del constructor de clases matriz coleaguea (Mediator de Mediator) {super (mediador); } // Cada colega específico debe tener sus propias tareas, y no hay necesidad de asociarse con el Outsil World Public Void self () {System.out.println ("colleaguea -> Haz tus propias tareas ..."); } // Cada colega específico siempre necesita interactuar con el mundo exterior, manejar esta lógica y organizar el trabajo a través del mediador público Void out () {System.out.println ("colleaguea-> Solicite el colega B para hacer su trabajo a tiempo parcial ..."); super.mediator.execute ("colegueb", "yo"); }} // colega específico B ClassagueB extiende AbstractColleague {public CollegeB (Mediator de Mediator de Abstract) {Super (Mediator); } public void self () {system.out.println ("colega b-> haz tu trabajo a tiempo parcial ..."); } public void out () {System.out.println ("colega b-> solicitar colega A para hacer su trabajo a tiempo parcial ..."); super.mediator.execute ("colleaguea", "yo"); }} Categoría intermediaria:
// Abstract Intermediary Abstract Clase AbstractMediator {// El intermediario debe mantener la información de contacto de varios colegas protegidos con hashtable <String, AbstractColleague> colegues = new Hashtable <String, AbstractColleague> (); // El intermediario puede establecer dinámicamente el contacto con un colega público void addColleague (nombre de cadena, abstractcolleague c) {this.colleagues.put (nombre, c); } // El intermediario también puede cancelar dinámicamente el contacto con un colega public void deletecolleague (nombre de cadena) {this.colleagues.remove (nombre); } // El intermediario debe tener operaciones para manejar la lógica, asignar tareas y promover la comunicación entre colegas públicos abstracts void ejecute (nombre de cadena, método de cadena); } // El mediador de clase intermediaria específica extiende AbstractMediator {// La función más importante del intermediario es ejecutarse de un lado a otro entre colegas public void ejecute (name de cadena, método de cadena) {if ("self .equals (método) {// cada persona hace sus propios deberes si (" collectAguea ".equals (name)) {colleagea colleagueaGea = = (Colleaguea) super.oleagues.get ("colleaguea"); colega.self (); } else {colleagueb colleague = (colleagueb) super.colleagues.get ("colegueb"); colega.self (); }} else {// College con otros colegas if ("colleaguea" .equals (name)) {colleaguea colleague = (colleaguea) super.colleagues.get ("colleaguea"); colegue.out (); } else {colleagueb colleague = (colleagueb) super.colleagues.get ("colegueb"); colegue.out (); }}}}} Clase de prueba:
// Test Class Clase Public Class Client {public static void main (string [] args) {// crea un intermediario abstractMediator mediator = new Mediator (); // crear dos colegas colleaguea colleaguea = new colleaguea (mediador); Colegueb colegueb = nuevo colegueb (mediador); // El intermediario establece contacto con cada colega mediador.addcolleague ("colleaguea", colleaguea); mediador.addcolleague ("colegueb", colegueb); // colegas comienzan a trabajar coleaguea.self (); colleaguea.out (); System.out.println("========================================================================================================= ================================================================= ================================================================== ================================================================= ================================================================== ================================================================== ================================================================== Resultados de la prueba:
Colega A -> Haz tu parte en tus deberes ... colega A -> Pídale al colega B que haga tu parte en tus deberes ... colega B -> Haz tu parte en tus deberes ... ===================================================== ¡Happy Cooperation, la tarea se completa! Colega b -> Haz tu parte en tus deberes ... colega b -> pídale al colega A que haga tu parte en tus deberes ... colega A -> Haz tu parte en tus deberes ... ========================================================= ¡COOPERACIÓN HECHBE, la tarea se completa la tarea!
Aunque solo hay dos clases de colega específicas en el código anterior, y solo se crean dos colegas en la clase de prueba, podemos expandirlos de manera adecuada de acuerdo con el propósito del modelo intermediario, es decir, agregar clases de colegas específicas y luego el intermediario tiene que hombros con tareas más pesadas. ¿Por qué? Vemos que ahora hay un montón de largos códigos de juicio en el método Execute () en la clase de mediador anterior. Aunque puede descomponerse y agregar a otros métodos privados en la clase de mediador, la lógica comercial específica es indispensable.
Por lo tanto, mientras desacopla la conexión entre colegas, el intermediario en sí también es inconsistente con las tareas exageradas, porque casi toda la lógica comercial se explica al intermediario, que puede describirse como un papel "muy esperado". Estas son las deficiencias del modelo intermediario.
Además, el ejemplo de código anterior es bastante ideal. A veces no podemos extraer los puntos en común entre los "colegas" para formar una clase de colega abstracto abstracto de colegas, que aumenta en gran medida la dificultad de usar el modelo intermediario.
Revisar:
Dado que hay deficiencias en la implementación del código anterior de la "asociación bidireccional expuesta en la aplicación" propuesta por el senior Benjielin, de acuerdo con el método de mejora dado, modifique el código anterior de la siguiente manera:
Colegas modificados:
// Clase abstracta AbstractColegue {Mediator de Mediadores de Abstract Protected; // deja de establecer una conexión con el mediador en el constructor // public abstractcolleague (abstractMediator Mediator) {// this.mediator = Mediator; //} // Agregue un método a la clase de colega abstracto para contactar al mediador (es decir, registro) public void setMediator (resumen mediator) {this.mediator = mediator; }} // colega específico Una coleaguea de clase extiende abstractcolleague {// No establezca una conexión con el mediador en el constructor // collegea pública (resumen mediador) {// super (mediador); //} // Cada colega específico debe tener su propia parte de su propia parte, y no hay necesidad de asociarse con el Outsil World Public Void self () {System.out.println ("colleaguea -> Haz tu parte de su parte ..."); } // Cada colega específico siempre necesita interactuar con el mundo exterior, manejar esta lógica y organizar el trabajo a través del mediador público vacío () {system.out.println ("colleaguea -> solicitar al colega B que haga la parte de su parte de su parte ..."); super.mediator.execute ("colegueb", "yo"); }} // colega específico B colegueb extiende AbstractColleague {// Deja de establecer una conexión con el mediador en el constructor // colegueb público (Mediator de Mediator) {// Super (Mediator); //} public void self () {system.out.println ("colegueb -> haz tu parte ..."); } public void out () {System.out.println ("colegueb -> pídale al colega a que haga su parte ..."); super.mediator.execute ("colleaguea", "yo"); }}
Intermediario modificado:
// Abstract Intermediary Abstract Clase AbstractMediator {// El intermediario debe mantener la información de contacto de varios colegas protegidos con hashtable <String, AbstractColleague> colegues = new Hashtable <String, AbstractColleague> (); // El intermediario puede establecer dinámicamente el contacto con un colega público void addColleague (nombre de cadena, abstractcollegue c) {// ayudar a colegas específicos a establecer contactos del intermediario c.setMediator (esto); this.Collaagues.put (nombre, c); } // El intermediario también puede revocar dinámicamente el contacto con un colega public void deletecolleague (nombre de cadena) {this.oleagues.remove (nombre); } // El intermediario debe tener operaciones para manejar la lógica, asignar tareas y promover la comunicación entre colegas públicos abstracts void ejecute (nombre de cadena, método de cadena); } // El cliente de clase pública de clase de prueba {public static void main (string [] args) {// crea un mediador intermediario de medias de medias = new Mediator (); // El constructor se utiliza para registrar el intermediario para colegas específicos para ponerse en contacto // colleaguea colleaguea = new colleaguea (mediador); // colegueb colegueb = nuevo colegueb (mediador); Colleaguea colleaguea = new colleaguea (); Colegueb colegueb = new colleagueB (); // El intermediario establece contacto con cada colega mediador.addcolleague ("colleaguea", colleaguea); mediador.addcolleague ("colegueb", colegueb); // Los colegas comienzan a trabajar coleaguea.self (); colleaguea.out (); System.out.println ("================================================ =================================================================== =================================================================== ===================================================================== =================================================================== =================================================================== =================================================================== =====================================================================Los resultados después de la prueba son los mismos que antes de la modificación.