memperkenalkan
Mode Mediator (Mediator) menggunakan objek mediator untuk merangkum serangkaian interaksi objek. Perantara membuat objek tidak perlu secara eksplisit direferensikan satu sama lain, sehingga secara longgar menggabungkannya dan dapat secara mandiri mengubah interaksi mereka.
Konten utama berasal dari: http://www.addyosmani.com/resources/essentialjsdesignpatterns/book/#mediatorpatternjavascript
teks
Dalam pengembangan perangkat lunak, perantara adalah pola desain perilaku yang memungkinkan berbagai bagian sistem berkomunikasi dengan menyediakan antarmuka terpadu. Secara umum, jika sistem memiliki banyak submodul yang perlu dikomunikasikan secara langsung, titik kontrol pusat harus dibuat untuk setiap modul untuk berinteraksi melalui titik kontrol pusat. Model perantara memungkinkan submodul ini untuk mencapai tujuan decoupling tanpa komunikasi langsung.
Misalnya, sistem kontrol lalu lintas bandara yang umum, menara adalah perantara, yang mengendalikan lepas landas dan pendaratan pesawat (submodule), karena semua komunikasi diselesaikan dari pesawat yang melaporkan ke menara, daripada berkomunikasi satu sama lain sebelum pesawat. Sistem kontrol pusat adalah kunci sistem, yaitu peran perantara dalam desain perangkat lunak.
Pertama-tama mari kita pahami menggunakan pseudo-code:
Salinan kode adalah sebagai berikut:
// Kode berikut adalah pseudo-code, tolong jangan terlalu memperhatikan kode
// Di sini aplikasi namespace setara dengan memainkan peran perantara
var app = app || {};
// membuat permintaan ajax melalui perantara aplikasi
app.sendRequest = function (options) {
return $ .Ajax ($. Extend ({}, opsi);
}
// Setelah meminta URL, tampilkan tampilan
app.populateView = function (url, view) {
$ .when (app.sendRequest ({url: url, metode: 'get'})
.then (function () {
// Tunjukkan konten
});
}
// Hapus konten
app.resetView = function (view) {
view.html ('');
}
Dalam JavaScript, perantara sangat umum, setara dengan bus pesan dalam pola pengamat. Namun, mereka tidak diimplementasikan dengan menelepon pub/sub seperti pengamat, tetapi dikelola oleh perantara dengan cara yang disatukan. Mari kita beri contoh berdasarkan pengamat:
Salinan kode adalah sebagai berikut:
var mediator = (function () {
// Berlangganan suatu acara dan berikan fungsi panggilan balik setelah acara dipicu
var Subscribe = function (channel, fn) {
if (! mediator.channels [channel]) mediator.channels [channel] = [];
mediator.channels [channel] .push ({Context: this, callback: fn});
kembalikan ini;
},
// Acara siaran
publish = function (channel) {
if (! Mediator.Channels [channel]) Return false;
var args = array.prototype.slice.call (argumen, 1);
untuk (var i = 0, l = mediator.channels [channel] .length; i <l; i ++) {
Var Sumbangan = Mediator.Channels [saluran] [i];
langganan.callback.apply (langganan.context, args);
}
kembalikan ini;
};
kembali {
saluran: {},
Publikasikan: Publikasikan,
Berlangganan: Berlangganan,
installto: function (obj) {
obj.subscribe = berlangganan;
obj.publish = publikasi;
}
};
} ());
Memanggil kode relatif sederhana:
Salinan kode adalah sebagai berikut:
(fungsi (mediator) {
fungsi initialize () {
// nilai default
mediator.name = "dudu";
// Berlangganan acara namechange acara
// Fungsi panggilan balik menampilkan informasi sebelum dan sesudah modifikasi
mediator.subscribe ('namechange', function (arg) {
console.log (this.name);
this.name = arg;
console.log (this.name);
});
}
function updateName () {
// acara pemicu siaran, parameter adalah data baru
mediator.publish ('namechange', 'tom'); // Dudu, Tom
}
inisialisasi (); // inisialisasi
UpdateName (); // Panggilan
})(penengah);
Perantara dan pengamat
Pada titik ini, semua orang mungkin bingung. Perantara dan pengamat tampaknya serupa. Apa bedanya? Ini sebenarnya agak mirip, tapi mari kita lihat deskripsi spesifik:
Pola pengamat, objek tunggal yang tidak merangkum kendala. Sebaliknya, pengamat pengamat dan subjek kelas konkret bekerja bersama untuk mempertahankan kendala. Komunikasi berinteraksi melalui beberapa pengamat dan beberapa kelas konkret: setiap kelas konkret biasanya mengandung banyak pengamat, dan kadang -kadang satu pengamat di kelas konkret juga merupakan kelas konkret dari pengamat lain.
Apa yang dilakukan model perantara bukan hanya distribusi, tetapi juga memainkan peran mempertahankan kendala ini.
Pola perantara dan penampilan
Banyak orang mungkin juga bingung tentang perbedaan antara pola perantara dan penampilan. Mereka berdua abstrak modul yang ada, tetapi ada beberapa perbedaan halus.
Apa yang dilakukan perantara adalah berkomunikasi antar modul, yang multidirectional, tetapi mode penampilan hanya mendefinisikan antarmuka sederhana untuk modul atau sistem tertentu tanpa menambahkan fungsionalitas tambahan. Konsep modul lain dalam sistem tidak memiliki koneksi langsung dengan mode penampilan dan dapat dipertimbangkan satu arah.
Berikut adalah contoh lengkap lainnya:
Salinan kode adalah sebagai berikut:
<! Doctype html>
<html lang = "en">
<head>
<Title> pola javascript </iteme>
<meta charset = "UTF-8">
</head>
<body>
<Div id = "hasil"> </div>
<script>
function player (name) {
this.points = 0;
this.name = name;
}
Player.prototype.play = function () {
this.points += 1;
mediator.played ();
};
var skor papan = {
// wadah untuk menampilkan konten
Elemen: document.geteLementById ('hasil'),
// Perbarui tampilan skor
UPDATE: function (skor) {
var i, msg = '';
untuk (saya dalam skor) {
if (score.hasownproperty (i)) {
msg + = '<p> <strong>' + i + '<// strong>:';
msg += skor [i];
msg += '<// p>';
}
}
this.element.innerhtml = msg;
}
};
var mediator = {
// semua pemain
Pemain: {},
// Inisialisasi
setup: function () {
vaR player = this.players;
pemain.home = pemain baru ('home');
pemain.guest = pemain baru ('tamu');
},
// Setelah bermain, perbarui skor
bermain: function () {
var player = this.players,
skor = {
Beranda: pemain.home.points,
Tamu: pemain.guest.points
};
SCOREBOARD.UPDATE (SCORE);
},
// Tangani interaksi kunci pengguna
Keypress: function (e) {
E = E || window.event; // yaitu
if (e.WHich === 49) {// Kunci nomor "1"
mediator.players.home.play ();
kembali;
}
if (e.WHich === 48) {// Kunci nomor "0"
mediator.players.guest.play ();
kembali;
}
}
};
// pergi!
mediator.setup ();
window.onkeypress = mediator.keypress;
// akhiri setelah 30 detik
setTimeout (function () {
window.onkeypress = null;
Console.log ('Game Over!');
}, 30000);
</script>
</body>
</html>
Meringkaskan
Mode perantara umumnya digunakan dalam situasi di mana sekelompok objek telah didefinisikan dengan baik tetapi berkomunikasi dengan cara yang kompleks. Secara umum, mode perantara mudah digunakan dalam sistem, tetapi juga mudah disalahgunakan dalam sistem. Ketika kelompok objek yang kompleks dari interaksi banyak-ke-banyak muncul dalam sistem, jangan terburu-buru untuk menggunakan mode perantara terlebih dahulu, tetapi pikirkan apakah ada sesuatu yang salah dengan desain sistem.
Selain itu, karena model perantara mengubah kompleksitas interaksi menjadi kompleksitas perantara itu sendiri, objek perantara akan lebih kompleks daripada objek lainnya.