Java Design Pattern – Factory

Repost dari artikel saya di PC Mild 04/2011

Munculnya OOP (Object Oriented Programming) memberi banyak kemungkinan solusi untuk masalah-masalah pemrograman. Dalam masalah-masalah tersebut, ternyata ditemukan juga suatu pola penyelesaian yang bisa secara baku namun fleksibel digunakan dalam masalah lain yang serupa. Pola tersebut biasa disebut dengan “Design Pattern”.

Seperti yang telah dijelaskan pada edisi sebelumnya, dalam ilmu Software Engineering, design pattern adalah suatu pola solusi umum yang digunakan pada masalah-masalah yang sering muncul pada desain software (sumber: Wikipedia.org). Tetapi design pattern bukanlah solusi akhir dari suatu masalah yang spesifik. Design pattern hanyalah pola bagaimana menyelesaikan suatu masalah yang bisa digunakan dalam berbagai situasi.

Setelah penulis membahas design pattern Singleton di edisi sebelumnya, kali ini akan dijelaskan salah satu design pattern lain yang cukup sering dipakai di dunia software engineering, yaitu Factory Pattern.

Seperti namanya (factory = pabrik), mekanisme factory pattern adalah berupa sebuah class yang membuatkan object dari suatu class, tanpa perlu menggunakan keyword “new” untuk membuat object tersebut. Ide pembuatan class factory ini adalah untuk mempermudah proses pembuatan object dengan parameter tertentu. Salah satu keuntungannya adalah ketika program yang cukup besar, yang sebagian besar kodenya bergantung pada beberapa class utama.

UML Factory Pattern

Misalnya, ada class User yang membutuhkan parameter akses ke sebuah file. Seluruh program menginisiasi class tersebut dalam object, kemudian satu-persatu menentukan parameter tersebut. Ketika Anda ingin mengubah agar class User menggunakan akses database, maka Anda harus mengedit seluruh baris yang berkaitan dengan itu. Tetapi jika Anda menggunakan class Factory untuk class User tersebut, maka Anda cukup mengubahnya di class Factory, tanpa perlu melihat seluruh kode program.

Untuk lebih jelasnya, Anda bisa mempraktekkan contoh sederhana berikut ini.

  1. Pertama-tama, buat sebuah class yang akan menjadi entity yang akan dibuat dengan Factory.
    public class User {
      // *******variables area****** //
      private String username;
      private boolean useFile;
      // *****constructors area***** //
      public User(String username) {
        this.username = username;
      }
      // ********methods area******* //
      public String getUsername() {
        return username;
      }
      public void setUsername(String username) {
        this.username = username;
      }
      public boolean getUseFile() {
        return useFile;
      }
      public void setUseFile(boolean useFile) {
        this.useFile = useFile;
      }
    }
  2. Berikutnya adalah membuat class yang berfungsi seperti factory. Method dari factory pattern sebaiknya dapat langsung diakses tanpa melalui inisiasi object dari class factory tersebut. Karena itu, berikan modifier “static” pada method create() yang tersedia. Tentu saja nilai yang dikembalikan bertipe class User.
    public class UserFactory {
      public static User create(String username) {
        User u = new User(username);
        u.setUseFile(true);
        return u;
      }
    }
  3. Untuk mencobanya, Anda bisa membuat sebuah main method sederhana seperti berikut.
    public class FactoryTest {
      public static void main(String[] args) {
        // contoh tanpa factory pattern
        User a = new User("haqqi");
        a.setUseFile(true);
        User b = new User("fauzil");
        b.setUseFile(true);
    
        // contoh dengan factory pattern
        User user1 = UserFactory.create("haqqi");
        User user2 = UserFactory.create("fauzil");
        System.out.println("Use file?");
        System.out.println(user1.getUsername() + " : " + user1.getUseFile());
        System.out.println(user2.getUsername() + " : " + user2.getUseFile());
      }
    }

    Dengan demikian, ketika ada perubahan arsitektur ketika user diharuskan untuk menggunakan resource selain file, maka hal tersebut dapat diatasi dengan mengubahnya pada satu baris saja, tidak perlu mengubah di semua baris seperti pada contoh di atasnya. Hal ini akan terasa dampaknya ketika ada banyak baris dari class tersebut yang perlu diinisialisasi secara serentak dan sama. Tentu saja metode seperti ini bisa diatasi lebih baik dengan menggunakan teknik konfigurasi yang lebih advance.

  4. Untuk menghemat jumlah class dan mempermudah pembacaan, method untuk factory pattern bisa diletakkan langsung dalam class yang bersangkutan. Dalam hal ini adalah class user yang akan di-generate.
    public class User {
      // *******variables area****** //
      private String username;
      private boolean useFile;
      // *****constructors area***** //
      public User(String username) {
        this.username = username;
      }
    
      // ..
      // kode lainnya
      // . .
    
      public static User create(String username) {
        User u = new User(username);
        u.setUseFile(true);
        return u;
      }
    }
  5. Kemudian, pada penggunaannya bisa langsung dipanggil:
    User a = User.create("username");
  6. Factory pattern sebenarnya menggunakan pola kerja yang mirip dengan prototype pattern, di mana banyak inisialisasi nilai property yang sama untuk semua instance dari sebuah class. Bedanya, prototype pattern tidak membuat class factory, melainkan class turunan dari class asli yang akan menginisialisasi beberapa property yang diperlukan. Class prototype tersebut harus mengimplementasikan cloneable, sehingga dapat digandakan secara langsung dalam program.

Hasil percobaan

Download source code secara keseluruhanArtikel ini telah dipublikasikan di media cetak tabloid PC Mild edisi 04 tahun 2011 lalu.

Leave a Comment.