introduire
Le mode médiateur (médiateur) utilise un objet médiateur pour encapsuler une série d'interactions d'objets. L'intermédiaire fait que les objets n'ont pas besoin d'être explicitement référencés les uns aux autres, les couplant de manière lâche et peuvent changer indépendamment leurs interactions.
Le contenu principal vient de: http://www.addyosmani.com/resources/essidentialjsdesignpatterns/book/#mediatorpatternjavascript
texte
Dans le développement de logiciels, les intermédiaires sont un modèle de conception comportementale qui permet à différentes parties du système de communiquer en fournissant une interface unifiée. Généralement, si le système a de nombreux sous-modules qui doivent être communiqués directement, un point de contrôle central doit être créé pour chaque module pour interagir à travers le point de contrôle central. Le modèle intermédiaire permet à ces sous-modules d'atteindre le but du découplage sans communication directe.
Par exemple, le système de contrôle du trafic d'aéroport commun, la tour est un intermédiaire, qui contrôle le décollage et l'atterrissage de l'avion (sous-mo-module), car toutes les communications sont effectuées à partir de l'avion signalant la tour, plutôt que de communiquer entre eux avant l'avion. Le système de contrôle central est la clé du système, c'est-à-dire le rôle de l'intermédiaire dans la conception des logiciels.
Comprenons d'abord en utilisant le pseudo-code:
La copie de code est la suivante:
// Le code suivant est pseudo-code, veuillez ne pas accorder trop d'attention au code
// Ici, l'espace de noms de l'application équivaut à jouer le rôle d'un intermédiaire
var app = app || {};
// fait des demandes ajax via l'intermédiaire de l'APP
app.sendRequest = fonction (options) {
return $ .ajax ($. Extension ({}, options);
}
// Après avoir demandé l'URL, affichez la vue
app.populavieView = fonction (url, vue) {
$ .when (app.sendRequest ({url: url, méthode: 'get'})
.Then (function () {
// Afficher le contenu
});
}
// Contenu effacer
app.resetview = fonction (voir) {
View.html ('');
}
En JavaScript, les intermédiaires sont très courants, équivalents au bus de message dans le modèle d'observateur. Cependant, ils ne sont pas mis en œuvre en appelant des observateurs comme Pub / Sub, mais sont gérés par des intermédiaires de manière unifiée. Donnez un exemple basé sur l'observateur:
La copie de code est la suivante:
var médiateur = (function () {
// Abonnez-vous à un événement et fournissez une fonction de rappel après le déclenchement de l'événement
var abonnez-vous = fonction (canal, fn) {
if (! Mediator.Channels [canal]) Mediator.Channels [canal] = [];
mediator.channels [canal] .push ({context: this, rappel: fn});
retourner ceci;
},
// diffuser des événements
publier = fonction (canal) {
if (! mediator.channels [canal]) renvoie false;
var args = array.prototype.slice.call (arguments, 1);
pour (var i = 0, l = médiateur.Channels [canal] .length; i <l; i ++) {
Var abonnement = médiateur.Channels [canal] [i];
abonnement.callback.apply (abonnement.context, args);
}
retourner ceci;
};
retour {
canaux: {},
Publier: Publish,
Abonnez-vous: abonnez-vous,
installTo: function (obj) {
obj.Subscribe = abonnez-vous;
obj.publish = publier;
}
};
} ());
Appeler le code est relativement simple:
La copie de code est la suivante:
(fonction (médiateur) {
fonction initialize () {
// Valeur par défaut
médiateur.name = "dudu";
// Abonnez-vous à un événement namechange
// La fonction de rappel affiche des informations avant et après modification
Mediator.Subscribe ('nameChange', fonction (arg) {
console.log (this.name);
this.name = arg;
console.log (this.name);
});
}
fonction updateName () {
// Événement de déclenchement de diffusion, le paramètre est de nouvelles données
médiateur.publish («namechange», «tom»); // Dudu, Tom
}
initialiser(); // initialiser
UpdaTename (); // Appel
})(médiateur);
Intermédiaires et observateurs
À ce stade, tout le monde peut être confus. L'intermédiaire et l'observateur semblent similaires. Quelle est la différence? C'est en fait un peu similaire, mais jetons un coup d'œil à la description spécifique:
Modèle d'observateur, un seul objet qui n'encapsule pas les contraintes. Au contraire, l'observateur observateur et le sujet de classe concrète fonctionnent ensemble pour maintenir les contraintes. La communication interagit à travers plusieurs observateurs et plusieurs classes en béton: chaque classe de béton contient généralement plusieurs observateurs, et parfois un observateur dans la classe de béton est également la classe concrète d'un autre observateur.
Ce que fait le modèle intermédiaire n'est pas une simple distribution, mais il joue le rôle de maintenir ces contraintes.
Modèles d'intermédiaire et d'apparence
De nombreuses personnes peuvent également être confondues quant à la différence entre les modèles d'intermédiaire et d'apparence. Ils résument tous les deux les modules existants, mais il existe des différences subtiles.
Ce que fait l'intermédiaire, c'est communiquer entre les modules, qui est multidirectionnel, mais le mode d'apparence définit simplement une interface simple pour un certain module ou système sans ajouter de fonctionnalités supplémentaires. Le concept des autres modules du système n'a pas de connexion directe avec le mode d'apparence et peut être considéré comme unidirectionnel.
Voici un autre exemple complet:
La copie de code est la suivante:
<! doctype html>
<html lang = "en">
<adal>
<Title> Modèles JavaScript </TITAL>
<meta charset = "utf-8">
</ head>
<body>
<div id = "Results"> </div>
<cript>
Fonction Player (name) {
this.points = 0;
this.name = name;
}
Player.prototype.play = function () {
this.points + = 1;
médiateur.played ();
};
Var Scoreboard = {
// conteneur pour afficher le contenu
élément: document.getElementById («résultats»),
// Mettez à jour l'affichage du score
Mise à jour: fonction (score) {
var i, msg = '';
pour (i en score) {
if (score.hasownproperty (i)) {
msg + = '<p> <strong>' + i + '<// fort>:';
msg + = score [i];
msg + = '<// p>';
}
}
this.element.innerhtml = msg;
}
};
Var Mediator = {
// tous les joueurs
Joueurs: {},
// initialisation
configuration: function () {
var Players = this.players;
Players.Home = nouveau joueur ('home');
Players.Guest = nouveau joueur ('invité');
},
// Après le jeu, mettez à jour le score
joué: function () {
var joueurs = this.players,
score = {
Accueil: joueurs.home.points,
Invité: joueurs.Guest.points
};
Scoreboard.update (score);
},
// gérer l'interaction de la clé utilisateur
DES VIEUX: FONCTION (E) {
E = E || window.event; // c'est-à-dire
if (e.which === 49) {// Clé de numéro "1"
mediator.players.home.play ();
retour;
}
if (e.which === 48) {// clés de nombre "0"
mediator.players.guest.play ();
retour;
}
}
};
// aller!
Mediator.setup ();
window.onKeyPress = mediator.KeyPress;
// terminer après 30 secondes
setTimeout (function () {
window.onKeyPress = null;
Console.log («Game Over!»);
}, 30000);
</cript>
</docy>
</html>
Résumer
Le mode intermédiaire est généralement utilisé dans des situations où un groupe d'objets a été bien défini mais communique de manière complexe. D'une manière générale, le mode intermédiaire est facile à utiliser dans le système, mais il est également facile à abuser du système. Lorsqu'un groupe d'objets complexes d'interactions plusieurs à plusieurs apparaît dans le système, ne vous précipitez pas pour utiliser le mode intermédiaire en premier, mais réfléchissez à savoir s'il y a quelque chose qui ne va pas avec la conception du système.
De plus, puisque le modèle intermédiaire transforme la complexité d'interaction en complexité de l'intermédiaire lui-même, l'objet intermédiaire sera plus complexe que tout autre objet.