Tutorial Design Pattern : Penerapan Design Pattern Proxy di PHP

Hari raya Nyepi kali ini saya gak bisa pulang ke kampung halaman, masih ada keperluan di pulau seberang. Salah satunya yaw postingan ini, tugas kuliah yang harus segera diselesaikan supaya yang lainnya bisa lanjut dikerjakan. Tak seperti hari raya Nyepi biasanya yang sunyi, sepi, tanpa polusi. Yaw maklumlah, saya sedang tidak berada di bali yang memang benar-benar menjalankan catur brata penyepian. Siang ini saya akan melanjutkan kembali postingan tentang tutorial design pattern, yaitu design pattern Proxy. Konsep kerja design pattern yang satu ini ialah mengakses suatu class yang lebih kompleks dan berada di tempat yang berbeda. Design pattern proxy digunakan ketika class kompleks hanya boleh ada 1 buah dan ketika class kompleks berada di tempat lain seperti PC, VM (virtual machine) dan proses lain.

Saya ambil contohnya seperti mesin ATM, nasabah bisa melakukan tarik tunai darimana saja asal punya kartu ATM (kalo gak, itu namanya nyolong duit orang XD). Mesin ATM dan server bank berada di tempat dan mesin yang berbeda, disinilah pattern proxy melakukan tugasnya. Proxy mirip dengan Singleton, yaitu tidak diperbolehkan inisialisasi lebih dari satu kali. Terdapat 2 buah class, yaitu Mesin_Token dan Proxy_Token. Dari user, kita buat sebuah class Nasabah yang akan mengakses class Mesin_Token melalui class Proxy_Token. Class Proxy_Token mempunyai method yang sama dengan class Mesin_Token. Kita langsung aja ke contoh penerapannya di PHP.

class Proxy_Token {
    private $token = NULL;
    function buat_token() {
        $this->token = new Mesin_Token();
    }
    function hitung_token() {
        if (NULL == $this->token) {
            $this->buat_token();
        }
        return $this->token->hitung_token();
    }
    function tambah_token($token) {
        if (NULL == $this->token) {
            $this->buat_token();
        }
        return $this->token->tambah_token($token);
    }
    function ambil_token($no_token) {
        if (NULL == $this->token) {
            $this->buat_token();
        }
        return $this->token->ambil_token($no_token);
    }
    function hapus_token($book) {
        if (NULL == $this->token) {
            $this->buat_token();
        }
        return $this->token->hapus_token($book);
    }
}

class Mesin_Token {
    private $token = array();
    private $jumlah_token = 0;
    public function hitung_token() {
        return $this->jumlah_token;
    }
    private function buat_token($hit) {
        $this->jumlah_token = $hit;
    }
    public function ambil_token($no_token) {
        return $this->token[$no_token];
    }
    public function tambah_token(Nasabah $in_nasabah) {
        $this->buat_token($this->hitung_token() + 1);
        $this->token[$this->hitung_token()] = $in_nasabah;
        return $this->hitung_token();
    }
    public function hapus_token() {
        $i = 0;
        while ($i <= $this->hitung_token()) {
          $this->buat_token($this->hitung_token() - 1);
		  $i++;
        }
      return $this->hitung_token();
    }
}

Pada class Proxy_Token object benar-benar hanya boleh dibuat sekali agar ketika ingin dihapus lebih mudah dan tidak boros resource.

class Nasabah {
    private $nama;
    private $no_rek;
    function __construct($in_nama, $in_no_rek) {
      $this->nama = $in_nama;
      $this->no_rek  = $in_no_rek;
    }
    function ambil_nama() {
        return $this->nama;
    }
    function ambil_no_rek() {
        return $this->no_rek;
    }
    function tampil() {
      return $this->ambil_no_rek().' - '.$this->ambil_nama();
    }
}

  $proxytoken = new Proxy_Token();
  $nasabah = new Nasabah('Gede Lumbung','1109100350');
  $proxytoken->tambah_token($nasabah);

  echo 'Token Key yang dibuat : '.$proxytoken->hitung_token();
  echo'<br><br>';

  $lihat_nasabah = $proxytoken->ambil_token(1);
  echo 'Informasi Nasabah : '. $lihat_nasabah->tampil();
  echo'<br><br>';

  $proxytoken->hapus_token($nasabah);
  echo 'Token setelah dihapus, sisa token : '.$proxytoken->hitung_token();

Kita ibaratkan class Nasabah di atas seperti nasabah yang datang ke mesin ATM. Nasabah ini mempunyai nama dan nomor rekening, inilah yang akan kita gunakan untuk mengakses Mesin_Token melalui Proxy_Token. Ketika telah selesai menggunakan token yang bersifat rahasia dan sensitif, maka token ini dihapus.

Design pattern Proxy ini digunakan untuk membangun aplikasi yang sudah ber-skala besar, apalagi yang sudah lintas platform dan OS. Ibaratnya seperti kita menggunakan web proxy ketika berselancar di internet, pasti akan dibuatkan sebuah token key yang kemudian dicatat ke dalam sebuah log. OK deh, sekian dulu postingan kali ini, semoga bermanfaat untuk rekan-rekan yang sedang belajar design pattern.

Sumber Refrensi : E-Book Gang of Four Design Pattern

Happy Blogging and Keep Coding

Cheerrrss….!!!!