Pola Desain - Panduan cepat untuk pola Pengamat.

Pola pengamat adalah pola yang sangat umum digunakan. Bahkan, sangat umum bahwa standar di banyak bahasa pemrograman / perpustakaan. Di Jawa, ia ada di injava.util.Observer (tidak digunakan lagi di Jawa 9). Dalam Python itu sedekat apip menginstal pengamat-pola. Di C ++, kadang-kadang kita bisa menggunakan boost library, lebih tepatnya #include . Namun, ini banyak digunakan dalam industri sebagai solusi custom-made. Untuk dapat menggunakannya dengan benar dan memahami kerumitannya, kita perlu menyelam dan menjelajahinya.

Pola pengamat diklasifikasikan di antara pola desain perilaku. Pola desain perilaku paling khusus berkaitan dengan komunikasi antara kelas / objek. [menurut Pola Desain dijelaskan secara sederhana]

Apa itu pola pengamat? Terlepas dari monitor berjalan yang menyiarkan televisi analog (seperti pada gambar). Tujuan pola adalah untuk menentukan hubungan satu-ke-banyak sehingga ketika satu objek berubah keadaan, yang lain diberitahu dan diperbarui secara otomatis. Lebih tepatnya, ia ingin diberi tahu tentang peristiwa yang terjadi dalam sistem. Mari kita mengumpulkan potongan-potongan teka-teki dalam tiga langkah.

Langkah 1 - Kata kunci

Menentukan kata kunci adalah resep rahasia dalam rangkaian panduan cepat ini. Metode ini membantu saya benar-benar memahami pola desain, memasukkannya dalam pikiran saya dan memahami perbedaan di antara pola desain lainnya.

  1. Subjek: Ini dianggap sebagai penjaga informasi, data atau logika bisnis.
  2. Daftar / Lampirkan: Pengamat mendaftarkan diri ke subjek karena mereka ingin diberitahu ketika ada perubahan.
  3. Peristiwa: Peristiwa bertindak sebagai pemicu dalam subjek sehingga semua pengamat diberitahu.
  4. Beri tahu: Bergantung pada implementasinya, subjek dapat "mendorong" informasi kepada pengamat, atau, pengamat dapat "menarik" jika mereka membutuhkan informasi dari subjek.
  5. Pembaruan: Pengamat memperbarui negara mereka secara independen dari pengamat lain namun keadaan mereka dapat berubah tergantung pada peristiwa yang dipicu.

Langkah 2 - Diagram

Mari kita bagi desain ini menjadi beberapa kelas yang berbeda untuk menyederhanakan ini sedikit.

  • ConcreteObservers adalah kelas yang berisi informasi khusus untuk instance saat ini. Fungsi pembaruan disebut oleh operasi notifikasi subjek (). Pengamat memperbarui secara independen berdasarkan kondisi mereka saat ini.
  • Pengamat adalah kelas induk dari pengamat konkret. Ini berisi contoh subjek. Ketika seorang pengamat diinisialisasi, register / melampirkan dirinya pada subjek.
  • Kelas Subjek memiliki daftar atau koleksi pengamat. Ketika suatu peristiwa dipicu itu memanggil operasi notify () yang loop melalui semua pengamat dengan memanggil fungsi pembaruan mereka.

Langkah 3 - Kode dengan Contoh

Saya akan menyarankan untuk menyalin kelas kode berdasarkan kelas dari repositori git saya "Andreas Poyias" atau potongan di bawah ini (sesuai urutan yang disediakan) dan menempelkannya di salah satu editor C ++ online yang tersedia seperti c ++ shell, jdoodle, onlineGDB, dan jalankan untuk mengamati output. Kemudian baca komentar atau deskripsi di bawah ini. Luangkan waktu Anda, bacalah dengan seksama (itu berarti satu menit, tidak kurang dan tidak lebih).

Contoh: Pertimbangkan permainan sepakbola. Banyak pendukung menonton pertandingan. Kami membagi pendukung menjadi dua kategori berdasarkan usia, muda dan tua. Ketika tim mereka mencetak gol, para pendukung bereaksi berbeda sesuai dengan usia dan tingkat kegembiraan mereka.
Sekarang, mari kita bicara dengan istilah yang digunakan untuk pola pengamat:

  • Permainan adalah subjek dan pendukungnya adalah pengamat.
  • Semua pengamat dilampirkan / terdaftar pada subjek dan mereka diberitahu ketika skor tim sepak bola mereka (pemicunya adalah jika skor tim mereka).
  • Pengamat memperbarui perilaku mereka tergantung pada notifikasi yang diterima.

Subyek
Untuk kelas ini, kita perlu akses ke daftar pengamat. Ketika pengamat hendak mendaftar, mereka memanggil fungsi theattach (ini) untuk menambahkan diri ke daftar yang tersedia (ini adalah contoh pengamat). Ketika suatu peristiwa dipicu, wenotify () semua pengamat untuk secara independen memperbarui negara mereka. Dalam contoh ini, pemicunya adalah jika tim sepak bola pengamat mencetak gol.

#termasuk 
#sertakan 
menggunakan namespace std;
Subjek kelas {
    pengamat vektor ;
    skor bool; // pemicu, acara
publik:
    // daftarkan pengamat
    batal pasang (Pengamat * obs) {
        obserers.push_back (obs);
    }
   
   // Ini ACARAnya
   // atur skor jika dan beri tahu SEMUA pengamat
   batal setScored (Skor bool) {
      Score = Skor;
      memberitahu();
   }
bool getScored () {
      skor kembali;
   }
   // beri tahu implementasi lebih jauh ke bawah
   // agar skrip mengkompilasi dan menjalankan
   batal memberi tahu ();
};

Pengamat
Kelas ini tergantung pada subjek yang didaftarkan. Ketika pengamat konkret diinisialisasi mereka menempelkan diri ke Subjek. Dalam contoh ini, keadaan setiap pengamat adalah kegembiraannya.

Pengamat kelas
{
    Subjek * subj;
    tingkat kegembiraan; // negara
  publik:
    Pengamat (Subjek * mod, int excLevel)
    {
        subj = mod;
        excitementLevel = excLevel;
        // Pengamat mendaftar / melampirkan diri dengan Subjek
        Subjek> melampirkan (ini);
    }
    pembaruan virtual void () = 0;
  terlindung:
    Subjek * getSubject () {
       mengembalikan subj;
    }
    membatalkan setExcitementLevel (int excLevel) {
       excitementLevel = excLevel;
    }
    int getExcitementLevel () {
       mengembalikan kegembiraan Tingkat;
    }
};

Ini adalah deklarasi Subjek :: notify () dan seperti yang kami sebutkan sebelumnya, tugasnya adalah memberi tahu semua pengamat untuk memperbarui status mereka.

void Subject :: notify () {
  untuk (int i = 0; i  pembaruan ();
}

Pengamat Beton
Pengamat konkret mewarisi dari kelas Observer dan mereka semua harus memiliki fungsi pembaruan. Dalam contoh ini, pengamat konkret dibedakan antara pendukung muda dan tua. Jika tingkat kegembiraan mereka menjadi terlalu tinggi, pendukung yang lebih tua memiliki risiko serangan jantung dan yang lebih muda memiliki risiko minum dan mengemudi. Status mereka diperbarui secara independen karena kami akan membuktikannya di fungsi utama lebih lanjut di bawah ini.

kelas Old_ConcreteObserver: Pengamat publik
{
   publik:
     // Memanggil konstruktor induk untuk mendaftar dengan subjek
     Old_ConcreteObserver (Subjek * mod, int div)
        : Pengamat (mod, div) {}
     // Untuk orang tua, jika tingkat kegembiraannya
     // adalah lebih dari 150 mereka berisiko serangan jantung
     membatalkan pembaruan ()
     {
        bool Score = getSubject () -> getScored ();
        setExcitementLevel (getExcitementLevel () + 1);
        if (skor && getExcitementLevel ()> 150)
        {
          cout << "Tim Old Observer mencetak gol !!"
               << "Level kegembiraannya adalah"
               << getExcitementLevel ()
               << "hati-hati terhadap serangan jantung!" << endl;
        }lain{
          Cout << "Tim tidak mencetak gol. Yeeeih tidak perlu khawatir"
               << endl;
        }
    } // akhiri pembaruan ()
};
class Young_ConcreteObserver: Pengamat publik
{
   publik:
     // Memanggil konstruktor induk untuk mendaftar dengan subjek
     Young_ConcreteObserver (Subjek * mod, int div)
       : Pengamat (mod, div) {}
     // Untuk orang tua, jika tingkat kegembiraannya
     // adalah lebih dari 100 mereka berisiko terkena serangan jantung
     membatalkan pembaruan ()
     {
        bool Score = getSubject () -> getScored ();
        setExcitementLevel (getExcitementLevel () + 1);
        if (skor && getExcitementLevel ()> 100)
        {
          cout << "Tim Pengamat Muda mencetak gol !!"
               << "Level kegembiraannya adalah"
               << getExcitementLevel ()
               << "Jangan minum dan menyetir !!" << endl;
        }lain{
          Cout << "Tim tidak mencetak gol. Yeeh tidak perlu khawatir tentang"
               << endl;
       }
    } // akhiri pembaruan ()
};

Fungsi utama
Pengamat konkret mendaftarkan diri ke instance Subjek. Keadaan mereka adalah tingkat kegembiraan yang merupakan parameter kedua. Ketika acara dipicu "subj.setScored (true)", thenSubject :: notify () dipanggil untuk memperbarui pengamat yang terdaftar. Dalam skenario di bawah ini, kami memiliki tiga pengamat, the youngObs1 overexcited dan menjalankan risiko minum dan mengemudi, the oldObs1is juga overexcited sebuah menjalankan risiko yang berbeda (serangan jantung). Akhirnya, youngObs2 yang juga muda sebagai yang pertama tidak perlu khawatir karena dia tidak terlalu bersemangat.

Penting untuk diperhatikan bahwa ketiga pengamat diperbarui secara independen berdasarkan keadaan mereka (tingkat kegembiraan) dan jenisnya (muda atau tua).
int main () {
   Subjek subjek;
   Young_ConcreteObserver youngObs1 (& subj, 100);
   Old_ConcreteObserver oldObs1 (& subj, 150);
   Young_ConcreteObserver youngObs2 (& subj, 52);
   subj.setScored (true);
}
// Keluaran
// Tim Pengamat Muda mencetak gol !! Tingkat kegembiraannya adalah 101
// jangan minum dan menyetir !!
// Tim Old Observer mencetak gol !! Tingkat kegembiraannya adalah 151 jam
// karena serangan jantung! Tim tidak mencetak gol.
// Yeeh tidak perlu khawatir

Ada beberapa manfaat untuk penggunaan pola Observer dan beberapa poin yang perlu diperhatikan ketika pola ini akan didekati [Learning Python Design Patterns].

  • Pola Observer menyediakan desain di mana Subjek dan Pengamat secara longgar digabungkan. Subjek tidak perlu tahu tentang kelas ConcreteObserver. Pengamat baru dapat ditambahkan kapan saja. Tidak perlu mengubah Subjek ketika Pengamat baru ditambahkan. Pengamat dan subjek tidak terikat dan tidak tergantung satu sama lain, oleh karena itu, perubahan pada Subjek atau Pengamat tidak akan saling mempengaruhi.
  • Tidak ada opsi untuk komposisi, karena antarmuka Pengamat dapat dipakai.
  • Jika Observer disalahgunakan, ia dapat dengan mudah menambah kompleksitas dan menyebabkan masalah kinerja.
  • Pemberitahuan dapat tidak dapat diandalkan dan dapat menyebabkan kondisi balapan atau ketidakkonsistenan.

Blog selanjutnya akan menjadi panduan cepat untuk pola desain Bridge. Ini adalah pola desain struktural yang digunakan cukup banyak di industri. Jangan lupa untuk suka / bertepuk tangan posting blog saya dan ikuti akun saya. Ini untuk memberi saya kepuasan karena saya membantu beberapa pengembang lain dan mendorong saya untuk terus menulis. Jika ada pola desain khusus yang ingin Anda pelajari maka beri tahu saya agar saya dapat menyediakannya untuk Anda di masa mendatang.

Panduan cepat lainnya tentang pola desain:

  1. Pola Desain - Panduan singkat untuk Pabrik Abstrak.
  2. Pola Desain - Panduan singkat untuk Pola Jembatan.
  3. Pola Desain - Panduan singkat untuk Pola Builder.
  4. Pola Desain - Panduan singkat untuk Pola Penghias.
  5. Pola Desain - Panduan singkat untuk Pola Fasad.
  6. Pola Desain - Panduan cepat untuk Pola Pengamat.
  7. Pola Desain - Panduan singkat untuk Pola Singleton.