introducir
El modo mediador (mediador) utiliza un objeto mediador para encapsular una serie de interacciones de objetos. El intermediario hace que los objetos no necesiten ser referenciados explícitamente entre sí, acoplándolos libremente y puede cambiar de forma independiente sus interacciones.
El contenido principal proviene de: http://www.addyosmani.com/resources/essentialjsdesignpatterns/book/#mediatorpatternjavaScript
texto
En el desarrollo de software, los intermediarios son un patrón de diseño de comportamiento que permite que diferentes partes del sistema se comuniquen proporcionando una interfaz unificada. En general, si el sistema tiene muchos submódulos que deben comunicarse directamente, se debe crear un punto de control central para que cada módulo interactúe a través del punto de control central. El modelo intermediario permite que estos submódulos logren el propósito de desacoplar sin comunicación directa.
Por ejemplo, el sistema común de control de tráfico del aeropuerto, la torre es un intermediario, que controla el despegue y el aterrizaje de la aeronave (submódulo), porque toda la comunicación se completa desde la aeronave que informa a la torre, en lugar de comunicarse entre sí antes que la aeronave. El sistema de control central es la clave del sistema, es decir, el papel del intermediario en el diseño de software.
Primero lo entendamos usando Pseudo-Code:
La copia del código es la siguiente:
// El siguiente código es pseudocódigo, no preste demasiada atención al código
// Aquí el espacio de nombres de la aplicación es equivalente a jugar el papel de un intermediario
VAR APP = APP || {};
// hacer solicitudes de Ajax a través de la aplicación intermediaria
app.sendRequest = function (options) {
devolver $ .AJAX ($. Extend ({}, opciones);
}
// Después de solicitar la URL, muestre la vista
app.populateView = function (url, ver) {
$ .When (app.sendRequest ({url: url, método: 'get'})
.Then (function () {
// Mostrar contenido
});
}
// Borrar contenido
app.resetView = function (ver) {
ver.html ('');
}
En JavaScript, los intermediarios son muy comunes, equivalentes al bus de mensajes en el patrón del observador. Sin embargo, no se implementan llamando a Pub/Sub como observadores, sino que son administrados por intermediarios de manera unificada. Damos un ejemplo basado en el observador:
La copia del código es la siguiente:
var mediador = (function () {
// Suscríbase a un evento y proporcione una función de devolución de llamada después de activar el evento
var suscripción = function (canal, fn) {
if (! Mediator.channels [canal]) mediator.channels [canal] = [];
mediator.channels [canal] .push ({contexto: this, devolución de llamada: fn});
devolver esto;
},
// transmitir eventos
publicar = function (canal) {
if (! Mediator.channels [canal]) return false;
var args = array.prototype.slice.call (argumentos, 1);
para (var i = 0, l = mediator.channels [canal] .length; i <l; i ++) {
suscripción var = mediator.channels [canal] [i];
suscription.callback.apply (suscription.context, args);
}
devolver esto;
};
devolver {
canales: {},
Publicar: publicar,
Suscríbete: suscribir,
installTo: function (obj) {
obj.subscribe = suscríbete;
obj.publish = publicar;
}
};
} ());
Llamar al código es relativamente simple:
La copia del código es la siguiente:
(función (mediador) {
función inicialize () {
// valor predeterminado
mediator.name = "dudu";
// Suscríbete a un evento Namechange
// La función de devolución de llamada muestra información antes y después de la modificación
Mediator.subScribe ('Namechange', function (arg) {
console.log (this.name);
this.name = arg;
console.log (this.name);
});
}
función updateName () {
// Evento de activación de transmisión, el parámetro son datos nuevos
mediator.publish ('namechange', 'tom'); // Dudu, Tom
}
inicializar(); // Inicializar
updateName (); // Llamar
})(mediador);
Intermediarios y observadores
En este punto, todos pueden estar confundidos. El intermediario y el observador parecen ser similares. ¿Cuál es la diferencia? En realidad es un poco similar, pero echemos un vistazo a la descripción específica:
Patrón de observador, un solo objeto que no encapsula las restricciones. Por el contrario, el observador del observador y el tema de la clase concreta trabajan juntos para mantener limitaciones. La comunicación interactúa a través de múltiples observadores y múltiples clases de concreto: cada clase concreta generalmente contiene múltiples observadores, y a veces un observador en la clase concreta también es la clase concreta de otro observador.
Lo que hace el modelo intermediario no es simplemente distribución, sino que juega el papel de mantener estas restricciones.
Patrones intermediarios y de apariencia
Muchas personas también pueden confundirse sobre la diferencia entre los patrones intermediarios y de apariencia. Ambos abstractan los módulos existentes, pero hay algunas diferencias sutiles.
Lo que hace el intermediario es comunicarse entre módulos, que es multidireccional, pero el modo de apariencia simplemente define una interfaz simple para un módulo o sistema determinado sin agregar funcionalidad adicional. El concepto de otros módulos en el sistema no tiene una conexión directa con el modo de apariencia y puede considerarse unidireccional.
Aquí hay otro ejemplo completo:
La copia del código es la siguiente:
<! Doctype html>
<html lang = "en">
<Evista>
<title> JavaScript Patterns </title>
<meta charset = "utf-8">
</ablo>
<Body>
<div id = "resultados"> </div>
<script>
Function Player (nombre) {
this.Points = 0;
this.name = name;
}
Player.prototype.play = function () {
this.Points += 1;
mediador.played ();
};
Var Scoreboard = {
// contenedor para mostrar contenido
elemento: document.getElementById ('resultados'),
// Actualizar la pantalla de puntuación
ACTUALIZACIÓN: FUNCIÓN (SUPTER) {
var i, msg = '';
para (i en puntaje) {
if (score.hasownproperty (i)) {
msg + = '<p> <strong>' + i + '<// strong>:';
msg += stork [i];
msg += '<// p>';
}
}
this.element.innerhtml = msg;
}
};
Var Mediator = {
// Todos los jugadores
Jugadores: {},
// Inicialización
configurar: function () {
Var Players = this.players;
jugadores.home = nuevo jugador ('casa');
jugadores.guest = nuevo jugador ('invitado');
},
// Después del juego, actualice el puntaje
jugado: function () {
Var Players = this.players,
puntaje = {
Inicio: jugadores.home.points,
Invitado: jugadores.guest.points
};
marcador.update (puntaje);
},
// manejar la interacción de la tecla de usuario
KeyPress: function (e) {
E = E || Window.event; // ES DECIR
if (E.which === 49) {// Clave de número "1"
mediator.players.home.play ();
devolver;
}
if (E.which === 48) {// Número de claves "0"
mediator.players.guest.play ();
devolver;
}
}
};
// ¡ir!
mediator.setup ();
Window.OnkeyPress = Mediator.KeyPress;
// finalizar después de 30 segundos
setTimeOut (function () {
Window.OnkeyPress = nulo;
console.log ('¡Juego Over!');
}, 30000);
</script>
</body>
</html>
Resumir
El modo intermediario se usa generalmente en situaciones en las que un grupo de objetos ha sido bien definido, pero se comunica de manera compleja. En términos generales, el modo intermediario es fácil de usar en el sistema, pero también es fácil de usar mal en el sistema. Cuando aparece un grupo de objetos complejo de interacciones de muchas a muchos en el sistema, no se apresure a usar el modo intermediario primero, pero piense si hay algo mal con el diseño del sistema.
Además, dado que el modelo intermediario convierte la complejidad de interacción en la complejidad del intermediario en sí, el objeto intermediario será más complejo que cualquier otro objeto.