Selasa, 24 April 2012

Modul 1 - Creational Pattern (Abstract Factory Pattern, Builder Pattern, Factory Method)


1.1. Abstract Factory Pattern
Abstract Factory Pattern  merupakan salah satu jenis Creational Pattern yang menangani mekanisme penciptaan obyek secara adaptif. Abstract Factory Pattern memberikan kemampuan pengenkapsulasian sekelompok factory dimana masing-masing factory memiliki “motif” khasnya. Abstract Factory Pattern menjadi sentral penentuan factory yang akan diinisialisasi sehingga product yang diciptakan dapat mewarisi behaviour yang sesuai dengan motif yang dipilih. Keistimewaan lain adalah product yang diciptakan terbebas dari pernyataan penciptaan concrete class secara langsung. Hal ini memberikan keuntungan yaitu Abstract Factory Pattern dapat mencegah coupling problem yang pasti terjadi apabila penciptaan obyek memakai operator new dalam bahasa OOP. Abstract Factory Pattern menyediakan sebuah interface untuk membangun family yang berkaitan atau bergantung pada objek tanpa menspesifikasikan kelas nyata nya.
Prinsip dasar dari Abstract Factory pattern adalah:
1.    Terdapat kelas Abstract Factory (sebuah interface), dimana Abstract Factory merupakan sebuah interface yang mendefinisikan bagaimana cara untuk, membuat objek dari Abstract Product. Intent dari Abstract Factroy adalah menciptakan family dari objek yang berkaitan tanpa harus bergantung pada concrete class-nya.
2.    Terdapat kelas Concrete Factory, dimana kelas ini akan mengimplementasikan semua metode pada AbstractFactory untuk membuat objek dari concrete Product.
3.    Terdapat kelas Abstract Product, dimana kelas ini merupakan sebuah interface untuk  mendefinisikan tipe dari masing-masing objek produk.
4.    Terdapat kelas Product, merupakan kelas yang akan mengimplementasikan semua metode pada AbstractProduct.
5.    Terdapat Client, adalah kelas yang akan terhubung dengan kelas Abstrac tFactory dan Abstract Product.
Berikut ini adalah contoh program sederhana yang mengimplementasikan konsep factory pattern. Program ini sebenarnya merupakan tugas kelas yang diberikan oleh dosen desain pattern saya, saya sengaja mempublishkan hasil tugas ini agar bisa membantu teman-teman yang juga belajar tentang konsep factori pattern.
  Source Code Program   
          1. Karakter.java
              public abstract class Karakter {
              protected  int peluru;
              protected  String nama;
              public String getNama() {
                   return nama;
                   }
              public void setNama(String nama) {
                   this.nama = nama;
                   }
              public int getPeluru() {
                   return peluru;
                  }
               public void setPeluru(int peluru) {
                  this.peluru = peluru;
                  }
              public abstract void Tembak();
              }


          2. Army.java
              public class Army extends Karakter{
              public Army() {
              nama="army";
              peluru=100;
              }
              @Override
               public void Tembak() {
                  if(peluru>1){
                        peluru=peluru-2;
                        System.out.println("tembak");
                        System.out.println("sisa peluru ="+peluru);
                    }else{
                        System.out.println("reload");
                        }
                     }
                  }

             3. Civilian.java
                 public class Civilian extends Karakter {
                 public Civilian(){
                 nama="Civilian";
                 peluru=100;
                 }
                 @Override
                 public void Tembak() {
                    if(peluru>1){
                         peluru=peluru-3;
                         System.out.println("tembak");
                         System.out.println("sisa peluru ="+peluru);
                      }else{
                         System.out.println("hide");
                      }
                     }
                   }

              4. Factory.java
                  public class Factory {
                  public static Karakter getKarakter(String name) {
                       if  (name.equalsIgnoreCase("a")) {
                           return new Army();
                       }   else if (name.equalsIgnoreCase("c")) {
                            return new Civilian();
                       }    else {
                            return null;
                            }
                     }
                     public static void main(String[] args) {
                         Karakter k=getKarakter("a");
                              for (int i = 0; i < 51; i++) {
                                 k.Tembak();
                                }
                          }
                      }
1.2. Builder Pattern
Builder Pattern adalah sebuah software design pattern. Tujuannya adalah sebagai langkah-langkah abstract kerangka (kontruksi) object, jika suatu implementasi menggunakan langkah-langkah yang berbeda, maka akan membuat representasi object yang berbeda juga. Builder Pattern sering digunakan untuk membangun produk sesuai dengan sebuah pola struktur Composite Pattern, dengan cara memisahkan pembangunan kompleks object dari representation, sehingga proses konstruksi yang sama dapat membuat representation yang berbeda. Sebenarnya builder ini hampir sama dengan abstrack factory namun memiliki pengatur pembuat output yang bertugas mengambil urutan dari director dan mengkombinasikan dengan parameter yang ada di concrete builder.
Dalam Builder terapat beberapa istilah yaitu:
·      Builder : Iinterface abstract untuk membuat object /product (menetapkan sebuah interface abstract untuk membuat bagian dari sebuah object (product))
·      ConcreteBuilder
1.    menyediakan implementasi untuk Builder.
2.    membangun dan merakit bagian-bagian dari produk dengan menerapkan interface Builder untuk membangun banyak object
3.    mendefinisikan dan melacak yang mewakili ciptaanya (kreasinya)
4.    menyediakan interface untuk mengambil product
·      Director
1.    Class Director bertanggung jawab untuk mengatur urutan object kreasi yang benar.
2.    Menerima Concrete Builder sebagai  sebuah parameter dan menjalankan operasi yang diperlukan di atasnya.
·      Product
1.    Object terakhir yang akan diciptakan oleh Director menggunakan Builder.
2.    mewakili kompleks object dalam proses pembangunan. ConcreteBuilder membangun representasi product internal dan mendefinisikan proses yang menyebabkannya terkumpul.
3.    termasuk kelas yang menentukan bagian-bagian penyusunnya, juga interface untuk merakit bagian-bagian ke dalam hasil akhir.
Tips 
a.    Builder fokus pada membangun sebuah kompleks object setahap demi setahap. Abstract Factory menekankan suatu produk keluarga object (baik sederhana atau kompleks). Builder akan mengembalikan produk sebagai langkah terakhir, tetapi sejauh menyangkut Abstract Factory, produk akan kembali segera.
b.    Builder sering membangun sebuah Composite.
c.    Sering kali, desain awal dengan menggunakan Factory Method (sedikit rumit, lebih mudah disesuaikan, subclass berkembang banyak) dan berkembang ke arah Abstract Factory, Prototype, atau Builder (lebih fleksibel, lebih kompleks) sebagai perancang menemukan di mana fleksibilitas lebih dibutuhkan. 
d.   Kadang-kadang saling melengkapi pola penciptaan: Builder dapat menggunakan salah satu pola-pola (patterns) lain untuk menerapkan komponen yang dibangun. Abstract Factory, Builder, dan Prototype dapat menggunakan Singleton dalam implementasinya.
Contoh code program Builder pattern pada java:
/** "Product" */
class Pizza {
private String dough = "";
private String sauce = "";
private String topping = "";
public void setDough(String dough) {
this.dough = dough;
}
            public void setSauce(String sauce) {
            this.sauce = sauce;
            }
            public void setTopping(String topping) {
                        this.topping = topping;
            }
}
/** "Abstract Builder" */
abstract class PizzaBuilder {
protected Pizza pizza;
public Pizza getPizza() {
            return pizza;
            }
            public void createNewPizzaProduct() {
            pizza = new Pizza();
            }
            public abstract void buildDough();
            public abstract void buildSauce();
            public abstract void buildTopping();
           
/** "ConcreteBuilder" */
class HawaiianPizzaBuilder extends PizzaBuilder {
public void buildDough() {
            pizza.setDough("cross");
            }
            public void buildSauce() {
            pizza.setSauce("mild");
            }
            public void buildTopping() {
            pizza.setTopping("ham+pineapple");
            }
}
/** "ConcreteBuilder" */
class SpicyPizzaBuilder extends PizzaBuilder {
public void buildDough() {
            pizza.setDough("pan baked");
            }
            public void buildSauce() {
            pizza.setSauce("hot");
            }
            public void buildTopping() {
            pizza.setTopping("pepperoni+salami");
            }
}
/** "Director" */
class Cook {
private PizzaBuilder pizzaBuilder;
            public void setPizzaBuilder(PizzaBuilder pb) {
            pizzaBuilder = pb;
            }
public Pizza getPizza() {
            return pizzaBuilder.getPizza();
            }
            public void constructPizza() {
            pizzaBuilder.createNewPizzaProduct();
            pizzaBuilder.buildDough();
            pizzaBuilder.buildSauce();
            pizzaBuilder.buildTopping();  }
            }
 /** A given type of pizza being constructed. */
public class BuilderExample {
            public static void main(String[] args) {
            Cook cook = new Cook();
            PizzaBuilder hawaiianPizzaBuilder = new HawaiianPizzaBuilder();
            PizzaBuilder spicyPizzaBuilder = new SpicyPizzaBuilder();
            cook.setPizzaBuilder(hawaiianPizzaBuilder);
            cook.constructPizza();
            Pizza pizza = cook.getPizza();            }
            }



1.3. Factory method
Factory Method adalah pat­tern yang digunakan untuk memisahkan (decouple) proses pembuatan/instansiasi sebuah objek (produk) dari objek lain (klien) yang meng­gunakan­nya. Tujuan­nya supaya per­ubahan pada product class nggak menyebabkan kita harus meng­ubah kode pada client. Paling nggak akibat dari per­ubahan itu bisa diminimalisir. Dan juga supaya si factory bisa digunakan oleh banyak class.
Factory adalah objek yang ber­fungsi mem­buat objek lain (produk). Class ini menyem­bunyikan proses pem­buatan produk dari klien sehingga klien nggak perlu tahu proses pem­buatan­nya, bahkan klien juga nggak perlu tahu nama class dari produk yang dia minta. Dalam Factory Method, setiap con­crete factory ber­tugas mem­buat satu produk. Jadi ada pemetaaan 1–1 antara factory dan produk yang dibuat­nya. Klien meng­gunakan abs­tract factory untuk mem­buat objek tapi jenis objek itu diten­tukan oleh con­crete factory yang dipilih.
Cara kerja Factory method:
Cara kerja Factory method ialah mendefinisikan suatu interface untuk menciptakan objek, tetapi mengabaikan tipe dari subkelas-subkelasnya
Kelebihan Factory method:
  Memisahkan aplikasi dengan kelas, dimana couplingnya rendah yang mennyembunyikan kelas konkret dari aplikasi. Sehingga  kita dapat melakukan perubahan pada perangkat lunak, hanya dengan melakukan perubahan kecil saja dalam kodenya.
  Dapat melakukan customization. Dan customisasi pada objek pun akan menggantikan objek sebelumnya..
Kekurangan Factory method:
  Factory harus digunakan pada family dari objek. Sehingga jika kelas tidak memperluas kelas dasarnya atau interfacenya. Maka template factory design tidak dapat digunakan.
Cara kerja Factory Method:
Cara kerja factory method yaitu dengan membuat sebuah class abstract atau interface dan memungkinkan subclass atau class yg mengimplementasi class abstract / interface tersebut untuk menentukan class atau method mana yg harus dibuat instancenya atau dipanggil langsung, tergantung parameter yg diberikan.
Benefits Factory Pattern
§  Class konkret disembunyikan dari client.
§  Adanya konvensi penamaan sehingga pengembang selanjutnya dapat dengan mudah mengenali struktur kode.
§  Factory method dapat diberi parameter
Kesimpulan:
Factory method merupakan pola design yang paling sering digunakan dan paling kuat.  Jika kita berpikir  kita membutuhkan factory hanya untuk membuat objek, lebih baik tidak kita gunakan. Karena hanya akan membawa kompleksitas yang tidak diperlukan dalam aplikasi. Tapi jika kita berpikir kita butuh factory karena ada banyak objek dengan tipe dasar yang sama dan kita manipulasi sebagai abstrak objek, baru sebaiknya kita gunakan factory.

Contoh Studi kasus:
Untuk menggambarkan bagaimana cara menggunakan design pattern : factory, diberikan satu kasus. Ada sebuah perusahaan yang punya website untuk menampilkan hasil pengujian dari sebuah plain text file. Akhirnya perusahaan membeli sebuah mesin yg mnghasilkan data file binary, nah terus perusahaan beli lagi mesin lain yg outputnya ternyata file XML! terus belakangan beli lagi mesin baru yg outputnya lain lagi, trus dan terus seperti itu tiap beli mesin baru. padahal website perusahaan ini hanya perlu menampilkan data2 tersebut ke dalam satu format tertentu di tampilan websitenya.
Kasus: Bagaimana caranya membuat program yangg codenya bisa mengantisipasi perubahan tanpa harus duplicate pola yg sama untuk membaca output dari mesin yang berbeda?
Solusi: Silahkan-run file ini, silakan copy paste code dibawah ini dengan nama TestFactory.java, lalu compile dan run (dengan beri parameter (argumen) dengan range 1 mpe 3, misal ketik di command prompt : java TestFactory 1)
Hasilnya ://Let's say the interface is Display
interface Display {
 
   //load a file
   public void load(String fileName);
 
   //parse the file and make a consistent data type
   public void formatConsistency();
 
}
 
//deal with plain text file
class CSVFile implements Display{
 
    public void load(String textfile) {
        System.out.println("load from a txt file");
    }
    public void formatConsistency() {
        System.out.println("txt file format changed");
    }
}
 
//deal with XML format file
class XMLFile implements Display {
 
    public void load(String xmlfile) {
        System.out.println("load from an xml file");
    }
    public void formatConsistency() {
        System.out.println("xml file format changed");
    }
}
 
//deal with binary format file
class DBFile implements Display {
 
    public  void load(String dbfile) {
        System.out.println("load from a db file");
    }
    public void formatConsistency() {
        System.out.println("db file format changed");
    }
}
 
//Test the functionality
class TestFactory {
 
    public static void main(String[] args) {
        Display display = null;
       
        //use a command line data as a trigger
        if (args[0].equals("1"))
           display = new CSVFile();
        else if (args[0].equals("2"))
           display = new XMLFile();
        else if (args[0].equals("3"))
           display = new DBFile();
        else
           System.exit(1);
 
        //converging code follows
        display.load("");
        display.formatConsistency();
   }   
}

//after compilation and run it
C:\>java TestFactory 1
load from a txt file
txt file format changed
C:\>java TestFactory 2
load from an xml file
xml file format changed
C:\>java TestFactory 3
load from a db file
db file format changed

0 komentar:

Posting Komentar