.::. Hendra Jaya .::.

December 1, 2008

1. Singleton Pattern

Filed under: Design Pattern — hjaya @ 6:00 am

Singleton Pattern adalah salah satu design pattern yang diperkenalkan oleh GoF (Gang of Four). Ide utama dari Singleton Pattern adalah membatasi suatu kelas sedemikian rupa sehingga kelas tersebut hanya mempunyai satu instans saja walau berkali-kali diinstans.

Tujuan dari singleton pattern adalah :
1. Menghemat penggunaan resource dengan menghemat jumlah object yang beredar
2. Memastikan bahwa suatu objek yang dipakai beramai-ramai berada dalam state yang konsisten

Ada dua jenis Singleton Pattern, yaitu Eager Instantiation dan Lazy Instantiation. Tetapi, untuk saat ini, perhatikan saja kode program di bawah ini :

public class SingletonClass{
  private static SingletonClass instance = null;
  private SingletonClass(){}
  public static SingletonClass getInstance(){
    if(instance == null) instance = new SingletonClass();
    return instance;
  }
}

Dalam kode program di atas, kelas SingletonClass memiliki konstruktor private dan object reference ke dirinya sendiri yang bersifat static. Penjelasannya adalah sebagai berikut:

  1. SingletonClass memiliki konstruktor yang private
    Tujuan pemberian visibility private adalah MELARANG kelas manapun untuk menginstans SingletonClass. Lantas, bagaimana caranya menginstans kelas SingletonClass? Untuk menginstans kelas SingletonClass, gunakan method getInstance yang tersedia dalam bentuk statik. Artinya, anda tidak perlu memanggilnya via objek, tetapi justru lewat kelasnya sendiri. Jelasnya, lihat potongan program berikut:

    public class Main{
      public static void main(String[] args){
      SingletonClass singletonObject = new SingletonClass();
      SingletonClass singletonObject = SingletonClass.getInstance();
      }
    }

  2. SingletonClass memiliki satu object reference static ke dirinya sendiri
    Ini adalah bagian paling tricky dari Singleton Pattern. Untuk menjamin bahwa SingletonClass hanya memiliki satu buah instans, maka kelas SingletonClass itu sendiri sudah mempersiapkan instansnya, yaitu object reference bernama instance. Nah, jika nanti ada pemanggilan ke method getInstance, maka SingletonClass akan memberikan instans yang tadi sudah dipersiapkan olehnya, yaitu instance. Keren kan??
    Dengan memberikan modifier static, maka desainer SingletonClass menjamin bahwa hanya ada satu buah object reference yang bernama instance dan hal ini akan berhadiah KONSISTENSI. Yap, dimanapun anda memanggil getInstance, maka anda akan memperoleh object yang sama. Dan seandainya saja, dilakukan perubahan pada object singletonClass, maka perubahan tersebut akan berpengaruh ke semua tempat yang menggunakan object tersebut. Brilian..!!

Oke.. sekarang saatnya mendiskusikan soal penggunaan Singleton Pattern. Misalkan anda mempunyai suatu kelas yang tugasnya membuka koneksi ke database, sebut saja MySQLConnector. Apa yang akan terjadi jika kelas ini anda biarkan diinstans sesuka hati? Whoa.. dalam kasus terbaik mungkin anda hanya akan menemui beberapa buah koneksi database dari program anda, tetapi dalam kasus terburuk mungkin database anda akan kolaps gara-gara ketiban ratusan koneksi dalam waktu berbarengan :)
Dalam urusan koneksi ke database, sebaiknya gunakan Singleton Pattern agar anda dapat menjamin bahwa software anda hanya menggunakan satu buah koneksi. Selain itu, jika setting koneksi ke database diubah di suatu tempat, baik statusnya, url-nya ataupun drivernya, maka anda akan mendapati di semua tempat bahwa koneksi tersebut sudah ter-update mengikuti setting terbaru. Konsisten.. :D

Topik terakhir yang akan didiskusikan adalah Lazy Instantiation dan Eager Instantiation. Contoh-contoh di atas adalah Lazy Instantiation dan contoh di bawah ini adalah Eager Instantiation:

public class SingletonClass{
  private static SingletonClass instance = new SingletonClass();
  private SingletonClass(){}
  public static SingletonClass getInstance(){return instance;}
}

Perbedaan antara Lazy dan Eager Instantiation terletak pada KAPAN object reference instance diinisiasi. Dalam Eager Instantiation, SingletonClass berani menginstans object reference instance pada saat compile-time, sedangkan Lazy Instantiation akan menunggu sampai saat pertama kali method getInstance dipanggil. Pada penggunaan Singleton Pattern sehari-hari, biasanya programmer menggunakan Lazy Instantiation untuk mempercepat start-up time, tetapi anda dapat menggunakan Eager Instantiation jika anda yakin bahwa kelas singleton yang anda buat hanya akan mengonsumsi sedikit resource.

Sebagai contoh kelas Singleton Pattern, silahkan pelajari kelas java.util.Calendar. Kelas Calendar menggunakan Singleton Pattern untuk memastikan bahwa kapan dan dimanapun kelas ini diinstans, maka hasil yang diberikan tetap konsisten.

Selamat mencoba :D

November 27, 2008

0. Pendahuluan

Filed under: Design Pattern — hjaya @ 1:29 pm

Dalam men-desain software, seringkali kita dihadapkan pada beberapa masalah. Tenang saja, bukan anda yang pertama kali menemukan masalah tersebut. Sebagian besar masalah-masalah yang anda temui itu telah ditemukan dan (mungkin) telah dipecahkan oleh orang lain. Hal inilah yang kita kenal dengan design pattern. Tetapi, perlu anda ingat bahwa design pattern hanya terbatas pada level design, tidak melebar pada level arsitektur apalagi coding.

Design pattern dipopulerkan oleh Gang of Four (GoF), yaitu Erich Gamma, Richard Helm, Ralph Johnson, dan John Vlissides dalam buku mereka Design Patterns: Elements of Reusable Object-Oriented Software. Menurut saya, buku tersebut sebaiknya dijadikan buku saku saja, jangan dijadikan buku awal untuk belajar. Untuk belajar, sebaiknya anda membaca buku Head First Design Pattern, karena buku ini sangat konseptual dan mudah dipahami.

Dalam mendesain software, dikenal terminologi “Over Engineering” dimana desainer menerapkan terlalu banyak design pattern sedemikian rupa sehingga desainnya malah menjadi rumit dan membingungkan developer. Khusus untuk hal ini, dibutuhkan pengalaman dari desainer untuk menentukan trade off-nya.

Prinsip-prinsip yang harus diingat dalam design pattern :

  1. KISS (Keep It Simple Stupid)
    Jika anda menemukan sesuatu yang sudah sangat ribet, sadarlah dan pikirkanlah kembali apa yang anda kerjakan. Dalam banyak hal, sesuatu yang sangat rumit biasanya dapat dikerjakan dengan cara yang jauh lebih mudah.
  2. DRY (Don’t Repeat Yourself)
    Dalam fase implementasi, biasanya developer akan menyadari bahwa mereka hanya mengulang-ulang sesuatu yang sebenarnya sudah pernah dikerjakan. Jika hal ini terjadi satu dua kali, ikhlaskan saja. Tetapi jika hal ini sering terjadi, maka sudah saatnya anda menerapkan suatu design pattern
  3. Parsimony (Less is Better)
    Camkan selalu bahwa dalam rekayasa perangkat lunak “Sedikit itu Lebih Baik”!!
    - Bukankah semakin pendek kode program semakin mudah dibaca?
    - Bukankah semakin sedikit file maka alur program akan lebih mudah dipahami?
    - Bukankah semakin sedikit method/procedure dalam suatu kelas/program maka kelas/program tersebut akan lebih mudah dipahami?

Elements of reusable (Cover)
Design Pattern : Elements of reusable (Cover)

Head First Design Pattern (Cover)
Head First Design Pattern (Cover)

Blog at WordPress.com.