Kali ini, kita ingin meng-explore lagi Singleton Pattern. Soalnya, kita baru saja menemukan buku online yang bagus tentang design pattern. Judulnya Design Patterns Java Companion. Bisa dilihat di sini. Kita cari-cari bab tentang Singleton Pattern dan menemukan implementasi Singleton Pattern yang berbeda dengan implementasi sebelumnya.

Pada postingan lalu, kita menggunakan static method getInstance() untuk mengontrol pembuatan instance. Tetapi, di buku tersebut digunakan Exception ketika Singleton di-instance lebih dari satu. Wah, menarik juga nih. Apalagi memakai contoh Print Spooler. Kita sudah menyebutkan Print Spooler di postingan sebelumnya.

Let’s start …

Pertama-tama, dibuat dulu kelas exception kita seperti ini:

public class SingletonException extends RuntimeException { 

   //Tipe exception untuk kelas Singleton
   public SingletonException() {
      super();
   } 

   public SingletonException(String s) {
      super(s);
   }
}

Kelas exception ini memanggil parent class lewat method super(). Tetapi selain itu, kelas ini tidak melakukan sesuatu yang khusus. Kelas ini dibuat supaya kita mempunyai tipe exception sendiri yang harus kita catch ketika mencoba membuat instance dari PrintSpooler.

Selanjutnya, kita buat kelas PrintSpooler.

public class PrintSpooler { 

   // true jika terdapat satu instance
   static boolean instance_flag=false; 

   public PrintSpooler() throws SingletonException { 

   	if (instance_flag) {
      		throw new SingletonException("Hanya satu spooler yang diijinkan");
   	} else {
      		instance_flag = true;
      		System.out.println("spooler di-open");
   	}
   }	

   //-------------------------------------------
   public void finalize() {
      instance_flag = false;
   }
}

Kelas PrintSpooler menggunakan static flag untuk mengecek apakah sudah ada instance atau belum. Bila sudah ada, maka akan men-throw exception. Bila belum, maka instance spooler bisa dibuat.

Di kelas tersebut, tidak diikutsertakan method-method printing. Kita cuma lihat implementasi Singleton-nya saja. Kita tidak berniat membuat Print Spooler betulan hi..hi..hi

Sekarang, seperti biasa, kita coba kelas PrintSpooler dengan menggunakan kelas tester singleSpooler. Kita lihat apakah dapat memunculkan efek singleton.

public class singleSpooler {

      static public void main(String argv[]) {

      PrintSpooler pr1, pr2; 

      // open satu spooler
      // pasti berhasil
      System.out.println("Open satu spooler");
      try {
      	pr1 = new PrintSpooler();
      } catch (SingletonException e) {
	      System.out.println(e.getMessage());
      } 

      // open spooler yang lain
      // harusnya tidak bisa
      System.out.println("Open dua spooler");

      try {
      	pr2 = new PrintSpooler();
      } catch (SingletonException e) {
	      System.out.println(e.getMessage());
      }
   }
}

Kita compile, jalankan, dan hasilnya …

Baris terakhir mengindikasikan exception di-throw ketika kita mencoba membuat instance baru, padahal sudah ada instance PrintSpooler sebelumnya. Mission Accomplished! hi..hi..hi

Kita sudah melihat kelas Singleton pada postingan sebelumnya. Tapi, kelas Singleton tersebut masih berupa template. Kita belum melihat bagaimana konsep Singleton digunakan untuk sesuatu yang bermanfaat.

Dalam prakteknya, Singleton pattern digunakan ketika kita membutuhkan hanya satu objek, tidak boleh lebih. Sebagai contoh, print spooler. Di dalam suatu sistem komputer, kita harus memastikan hanya ada satu print spooler. Bila lebih dari satu, dapat menyebabkan printer tidak bekerja dengan baik. Bisa-bisa, dokumen yang berbeda dari print spooler yang berbeda tercetak pada halaman yang sama. Kita bisa saja mempunyai lebih dari satu printer, tetapi print spooler tetap satu.

Contoh yang lain adalah registry. Bila terdapat lebih dari satu registry, bisa menyebabkan ketidakkonsistenan data-data di registry. Dan kalau tidak konsisten, system bisa crash. Contoh yang lain lagi adalah kotak dialog Find pada microsoft word. Ketika kita mengetikkan shortcut ctrl+f, muncul dialog Find. Kita ketikkan ctrl+f lagi, ternyata dialog Find tidak bertambah. Masih terdapat satu dialog Find di word. Kita tidak bisa lagi membuat instance dari frame dialog Find. Singleton pattern digunakan di sini. Dan.., masih banyak lagi contoh lainnya.

… Sekarang, andaikan kita mempunyai program untuk me-maintain buku alamat. Tetapi kita mempunyai masalah. Program tersebut berjalan terlalu lambat. Di dalam program kita ada objek BukuAlamat. Karena menampung jumlah data yang amat banyak, objek BukuAlamat tersebut berukuran cukup besar. Performa program kurang bagus karena kita terlalu banyak menginstance-kan objek BukuAlamat di dalam kode program sehingga membutuhkan memori yang besar.

Kali ini, kita coba memecahkan masalah performa dengan menerapkan policy BukuAlamat hanya boleh di-instance sekali sehingga hanya terdapat satu buku alamat aktif saja. Dengan kata lain, kita menerapkan Singleton Pattern. Bila kita ingin membuat buku alamat yang lain, instance BukuAlamat harus di-null-kan terlebih dahulu. Ada kalanya kita lupa dengan policy ini, dengan membuat instance baru BukuAlamat meskipun sudah ada instance sebelumnya. Kalau begini, Singleton pattern akan mencegahnya.

Sekarang, kita coba wrap BukuAlamat dengan template kelas Singleton yang telah kita buat sebelumnya. Kira-kira akan menjadi begini (BukuAlamat.java):

import java.util.*;

public class BukuAlamat {
	//instance Singleton
	private static BukuAlamat myInstance;

	//atribut buku alamat
	private ArrayList<String> buku;
	private String namaBukuAlamat;
	private int jumlahEntry;

	// private constructor
	private BukuAlamat(String nama) {
		buku = new ArrayList<String>();
		namaBukuAlamat = nama;
		jumlahEntry = 0;
	}

	public static BukuAlamat getInstance(String nama) {

		if (myInstance == null) {
			myInstance = new BukuAlamat(nama);
		}
		return myInstance;
	}

	public String getNamaBukuAlamat() {
		return namaBukuAlamat;
	}

	// Method buku alamat
	public void addEntry(String entry) {
		if (entry != null) {
			buku.add(entry);
			jumlahEntry++;
		}
	}

}

Kelas testernya seperti ini (SingletonTester.java):

public class SingletonTester {

	public static void main(String args[]) { 

		BukuAlamat bukuAlamat = BukuAlamat.getInstance("Teman SD"); 

		System.out.println("Buku Alamat:  " + bukuAlamat.getNamaBukuAlamat()); 

		// Buat instance baru BukuAlamat
		BukuAlamat bukuAlamatBaru = BukuAlamat.getInstance("Teman SMP"); 

		System.out.println("Buku Alamat: " + bukuAlamatBaru.getNamaBukuAlamat()); 

	}
}

Kita lihat apakah kelas kita ini mempan menerapkan Singleton pattern…

Dilihat dari output di atas, ternyata kita tidak bisa membuat instance baru dari BukuAlamat. Kita ingin membuat BukuAlamat “Teman SMP“, tetapi karena sudah ada BukuAlamat “Teman SD“, kita gagal membuatnya.
Ok, kali ini kita mendapatkan hasil seperti yang kita inginkan. Jadi, Singleton pattern bekerja.

And one more thing, ilustrasi ini merupakan salah satu contoh bagaimana Singleton pattern digunakan untuk mencegah penggunaan system resources yang terlalu besar.

Welcome back, pattern kita selanjutnya adalah Singleton Pattern. Pattern ini merupakan pattern yang paling sederhana di antara pattern-pattern yang lain. Hanya membutuhkan satu kelas pada class diagram. Ok, langsung saja. Ini definisi dari Singleton Pattern:

Singleton Pattern memastikan suatu kelas hanya terdapat satu instance dan kelas tersebut menyediakan akses ke instance itu.

Hah? Hanya satu instance? Satu objek? Kita capek-capek membuat kelas, hanya bisa di-instance sekali?

Yap. Ada banyak situasi dimana kita hanya membutuhkan satu objek. Misalnya, objek yang berfungsi sebagai driver dari suatu device seperti printer. Apa jadinya bila lebih dari satu? Pernah lihat pesan yang menampilkan drivers conflict. Yeah, sort of it.

Faktanya, banyak lagi tipe objek yang jika di-instance-kan lebih dari satu menyebabkan terjadinya masalah seperti penggunaan resource yang tidak normal, behavior program yang tidak benar, dan hasil yang tidak konsisten.

Sekarang, kita lihat saja kelas Singleton berikut:

public class Singleton {
	private static Singleton myInstance;

	// atribut yang lain

	private Singleton() {	

	}

	public static Singleton getInstance() {
		if (myInstance == null) {
			myInstance = new Singleton();
		}
		return myInstance;
	}

	// method yang lain
}

Sekarang, pertanyaannya, apa artinya kode di atas? Kenapa kode tersebut bisa memunculkan efek Singleton?

Kita coba uraikan kode di atas. Dimulai dengan constructor berikut:

private Singleton() {

}

Hmmm…private constructor? Di Java, kita buat objek baru minimal dengan menuliskan statement new SomeObject(). Nah, tanda kurung di belakang SomeObject menyatakan: sebelum membuat objek baru, kita panggil constructor-nya.

Tapi…, bagaimana kalau kelas kita tidak punya constructor? See, I don’t have a constructor, so I don’t need to invoke constructor. Meskipun kelas kita tidak mempunyai constructor, JVM menambahkan default-nya untuk kita:

public SomeObject() {

}

Jadi, kelas kita pasti ada constructor-nya, biarpun kita tidak menuliskannya secara eksplisit.

Sekarang, apa artinya modifier private pada constructor? Yap, memang tidak seperti constructor kebanyakan yang menggunakan public. Private di sini berarti hanya kode yang sekelas dengan constructor yang dapat mengakses constructor ini. Tidak ada yang bisa mengaksesnya di luar kelas. Dengan kata lain, tidak ada yang bisa mengeksekusi statement “new” di luar kelas, karena kita tidak bisa mengakses constructor-nya.

Jadi, kelas Singleton di atas tidak bisa di-instance-kan?

Nope, bisa, asal di-instance-kan di dalam kelas Singleton.

Sekarang, kita telusuri lagi kelas Singleton, dan menemukan snippet kode seperti ini:

public static Singleton getInstance() {
		if (myInstance == null) {
			myInstance = new Singleton();
		}
		return myInstance;
	}

Method getInstance() di atas bertipe static. Dengan bertipe static menjadikan method tersebut hanya terdapat satu saja di antara instance-instance. Karena static method hidup di kelas, dan bukan di instance-instance. Berbeda dengan constructor yang private, method ini bersifat public sehingga bisa dipanggil di luar kelas Singleton. Dan karena bertipe static, method tersebut kita panggil dengan mengkualifikasikan nama kelas dan nama method seperti ini:

Singleton.getInstance()

Method getInstance() menyediakan cara bagi kita untuk meng-instance-kan kelas Singleton dan mengembalikan instance tersebut.

Jika myInstance null, artinya kita belum membuat instance. Kemudian, kita meng-instance-kan Singleton melalui private constructor-nya dan meng-assign instance ini ke myInstance. Ini bisa dilakukan karena kita meng-instance-kan di dalam kelas Singleton. Atribut myInstance ini bertipe static juga, karena instance kita merupakan satu-satunya instance kelas Singleton.

Jika myInstance tidak null, artinya kita sudah mempunyai instance, dan instance tersebut yang akan dikembalikan ke kita.

Jadi, kita masih bisa membuat instance dari kelas Singleton. Tapi, hanya satu. Tidak lebih! Karena itulah yang kita harapkan dari Singleton pattern ini.

Cool…

Sebelum membahas pattern yang lain, saya ingin mem-post-kan dulu, sebenarnya apa sih yang dimaksud dengan design pattern? Saya memperoleh penjelasan yang bagus di buku Head First Design Pattern.

Cerita tentang design pattern dimulai dari kutipan percakapan berikut.
Di sebuah restoran fast-food:

Anto: Aku mau pesan 2 ayam, 1 nasi putih, 1 french fries, 1 coca-cola. Terus pesan 1 burger, 1 french fries, 1 coca-cola. Pesan juga spaghetti, 1 french fries, 1 coca-cola. Aku juga pesan 1 coca-cola yang diberi es krim di atasnya.

Joni (customer di samping Anto): 1 paket A, 1 paket B, 1 paket C, dan 1 cokefloat.

Kedua pesanan tersebut sama. Namun, Anto membutuhkan kata-kata yang lebih banyak daripada Joni untuk menyampaikan pesanannya. Dan lagi, penerima order harus mengingat lebih banyak.

Kenapa bisa begini? Joni dan penerima order memiliki kosakata dari pesanan-pesanan yang ada di restoran tersebut. Mereka sama-sama sudah mempunyai shared vocabulary. Hal ini membuat komunikasi menjadi lebih lancar. Penerima order tidak perlu banyak mengingat karena sudah mempunyai pattern pesanan di kepalanya.

Hubungannya dengan design pattern? Analogi di atas juga berlaku pada design pattern. Design pattern memberikan kita shared vocabulary dengan developer lain. Dengan memiliki vocabulary ini, kita lebih mudah berkomunikasi dan juga menginspirasi bagi yang belum tahu untuk mempelajarinya. Kita bisa berpikir tentang arsitektur di tingkatan pattern, dan bukan di tingkatan objek yang terlalu detil.

So, bagaimana kita menggunakan design pattern? Kita sudah biasa menggunakan library dan framework, right?! Kita biasa menulis kode dengan menggunakan API dan mengikutsertakannya di program kita. Ambil contoh, Java API memberikan segala fungsionalitas dari GUI, IO, sampai network. Kita bisa memilih komponen-komponen dan memasukkannya ke aplikasi kita. Tetapi, semuanya tidak membantu menstrukturkan aplikasi kita supaya lebih mudah dibaca, lebih mudah di-maintain, dan lebih fleksibel.

….Oleh karena itu, design pattern ada. Design pattern tidak langsung muncul di kode, tetapi ada di otak kita terlebih dahulu. Setelah otak kita ter-load oleh pengetahuan tentang pattern, kita dapat mengaplikasikannya di desain baru atau merevisi kode menjadi kode yang fleksibel.

So, design patterns are so great. Cool!

Anto: Gw udah bikin kelas broadcast. Kelas ini mendaftar semua objek-objek yang mendengarkannya. Tiap kali ada data baru, kelas ini akan ngirimin pesan ke masing-masing listener. Nah, bagian yang paling keren noh, listener bisa join ke broadcast setiap saat dan juga bisa out dengan sendirinya. Keren kan. Sistem ini dinamik banget dan loosely-coupled.

Joni: Tok, kenapa Lu nggak bilang aja, Lu gunain Observer Pattern?!!!!!

Postingan ini membahas salah satu cara bagaimana melakukan printing di Java. Ok, seperti biasa, kita buat contoh spesifiknya.

Setelah melakukan sorting entry alamat, kita ingin melakukan hal yang lebih keren lagi. What’s that? Mencetak entry alamat. Jadi, dari kumpulan entry alamat yang kita punyai, kita ingin mencetaknya ke dalam label alamat. Cool?! Really Cool?! he..he..he

Sekarang, bagaimana kita melakukannya? Darimana kita memulainya? Oh, tentu saja dari javadocs. Kita cari-cari java printing. Akhirnya kita menemukannya. Tapi… duh, kita baca jadi pusing. Akhirnya kita memutuskan mencari info lewat mesin pencarian kesayangan kita, Google. Kita ketikkan keyword java printing. Akhirnya kita terdampar di site ini:
http://java.sun.com/docs/books/tutorial/2d/printing/index.html

Halah, ternyata di situs java-nya sendiri terdapat tutorial bagaimana menggunakan java printing. Di sana terdapat beberapa contoh yang bisa kita pakai untuk keperluan kita. Tapi ada satu contoh yang tampaknya cocok dengan masalah kita, yaitu PaginationExample.java. Di contoh tersebut, didemonstrasikan bagaimana mencetak array dari Strings. Wah, ini bisa dipakai. Tapi kita perlu memodifikasinya. Alih-alih mem-feed-kan array dari string “This is line …”, kita feed-kan dengan string dari kita, yaitu info entry alamat. Done…

Sekarang, kodenya bagaimana?
Kita modifikasi kelas entry alamat kita dengan mengubah reprentasi string dari entry alamat. Ini untuk keperluan tampilan di label. Ok, that’s easy…

import java.util.*;

public class EntryAlamat implements Comparable<EntryAlamat> {

	private String nama;
	private String alamat;

	public EntryAlamat(String nama, String alamat) {
		this.nama = nama;
		this.alamat = alamat;
	}

	public String getNama() {
		return nama;
	}

	public String getAlamat() {
		return alamat;
	}

	public int compareTo(EntryAlamat lain) {
		return nama.compareTo(lain.getNama());
	}

	public String toString() {
		StringBuffer buffer = new StringBuffer();
		buffer.append("=================================\n");
		buffer.append(nama);
		buffer.append('\n');
		buffer.append(alamat);
		buffer.append("\n=================================\n");
		return buffer.toString();
	}
}

Selanjutnya, kita modifikasi PaginationExample.java menjadi seperti listing kode di bawah. Kita ubah namanya menjadi PrintingAlamat.java. Kemudian, kita isi initTextLines dengan array string milik kita. Ok, that’s also easy…

/*
 * Copyright (c) 1995 - 2008 Sun Microsystems, Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Sun Microsystems nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */ 

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.awt.print.*;
import java.util.*;

public class PrintingAlamat implements Printable, ActionListener {

    int[] pageBreaks;  // array of page break line positions.

    String[] textLines;  

    private void initTextLines() {

    	ArrayList<EntryAlamat> BukuAlamat = new ArrayList<EntryAlamat>();

		// Sampel
		BukuAlamat.add(new EntryAlamat("Yayak", "Gedongkuning no. 419 Yogyakarta"));
		BukuAlamat.add(new EntryAlamat("Paijo", "Babadan RT. 1 RW. 1 Banguntapan Bantul"));
		BukuAlamat.add(new EntryAlamat("Andi", "Janti no. 1 Yogyakarta"));
		BukuAlamat.add(new EntryAlamat("Budi", "Tegalrejo RT. 16 RW. 16 Banguntapan Bantul"));
    	StringBuffer buffer = new StringBuffer();
    	for (EntryAlamat entry: BukuAlamat) {
    	        buffer.append(entry);
    	        buffer.append('\n');
    	}
		textLines = buffer.toString().split("\n");
    }

    /* Synthesise some sample lines of text */
    //private void initTextLines() {
    //    if (textLines == null) {
    //        int numLines=200;
    //        textLines = new String[numLines];
    //        for (int i=0;i<numLines;i++) {
    //            textLines[i]= "This is line number " + i;
    //        }
    //    }
    //}

    public int print(Graphics g, PageFormat pf, int pageIndex)
             throws PrinterException {

        Font font = new Font("Serif", Font.PLAIN, 10);
        FontMetrics metrics = g.getFontMetrics(font);
        int lineHeight = metrics.getHeight();

        if (pageBreaks == null) {
            initTextLines();
            int linesPerPage = (int)(pf.getImageableHeight()/lineHeight);
            int numBreaks = (textLines.length-1)/linesPerPage;
            pageBreaks = new int[numBreaks];
            for (int b=0; b<numBreaks; b++) {
                pageBreaks[b] = (b+1)*linesPerPage;
            }
        }

        if (pageIndex > pageBreaks.length) {
            return NO_SUCH_PAGE;
        }

        /* User (0,0) is typically outside the imageable area, so we must
         * translate by the X and Y values in the PageFormat to avoid clipping
         * Since we are drawing text we
         */
        Graphics2D g2d = (Graphics2D)g;
        g2d.translate(pf.getImageableX(), pf.getImageableY());

        /* Draw each line that is on this page.
         * Increment 'y' position by lineHeight for each line.
         */
        int y = 0;
        int start = (pageIndex == 0) ? 0 : pageBreaks[pageIndex-1];
        int end   = (pageIndex == pageBreaks.length)
                         ? textLines.length : pageBreaks[pageIndex];
        for (int line=start; line<end; line++) {
            y += lineHeight;
            g.drawString(textLines[line], 0, y);
        }

        /* tell the caller that this page is part of the printed document */
        return PAGE_EXISTS;
    }

    public void actionPerformed(ActionEvent e) {
         PrinterJob job = PrinterJob.getPrinterJob();
         job.setPrintable(this);
         boolean ok = job.printDialog();
         if (ok) {
             try {
                  job.print();
             } catch (PrinterException ex) {
              /* The job did not successfully complete */
             }
         }
    }

    public static void main(String args[]) {

        try {
            String cn = UIManager.getSystemLookAndFeelClassName();
            UIManager.setLookAndFeel(cn); // Use the native L&F
        } catch (Exception cnf) {
        }
        JFrame f = new JFrame("Printing Entry Alamat");
        f.addWindowListener(new WindowAdapter() {
           public void windowClosing(WindowEvent e) {System.exit(0);}
        });
        JButton printButton = new JButton("Print Pages");
        printButton.addActionListener(new PrintingAlamat());
        f.add("Center", printButton);
        f.pack();
        f.setVisible(true);
    }
}

Ok, now hope and pray.

Yess, akhirnya tampilan printer dialog muncul. Ini pertanda bagus.

Dan, hasilnya seperti ini.

How’s that? Cool?

Pada postingan Sorting Bagian 1, kita sudah lihat bagaimana men-sort entry alamat berdasarkan nama. Waktu itu, kita gunakan kelas EntryAlamat yang mengimplementasikan interface Comparable, kemudian meng-override method compareTo(). Kali ini, kita tidak hanya men-sort berdasarkan nama, tetapi juga berdasarkan alamat. Tetapi ada sedikit problem. Kita sudah menggunakan method compareTo() untuk men-sort berdasarkan nama sehingga kita tidak bisa lagi menggunakan method compareTo() untuk men-sort berdasarkan alamat.

So, bagaimana kita melakukannya? Oh gampang. Kita gunakan saja variable boolean pada kelas EntryAlamat, dan kemudian menggunakan pengetesan if-else pada method compareTo(). Selanjutnya, kita berikan return value yang berbeda, tergantung dari variable boolean yang di-set di kelas EntryAlamat.

Ya, ya, ya, itu bisa dilakukan. Tetapi solusi tersebut rasanya kurang elegan dan tidak terlalu OO Kita akan menggunakan cara lain untuk kasus ini.

Sekarang, darimana kita mulai? Ya, di mana lagi selain lihat java docs. Kita lihat dokumentasi kelas Collections API lagi. Kita menemukan ini.

Ternyata, terdapat method sort yang kedua. Method ini membutuhkan dua argumen, satu berupa list, dan satu lagi berupa Comparator. What? Again? Yep, kita harus melihat apa itu Comparator. Kita lihat javadocs dan menemukan ini.

Ternyata Comparator juga berupa interface, sama seperti Comparable. Tetapi ada bedanya. Suatu elemen pada list dapat membandingkan dirinya dengan elemen yang lain dengan menggunakan method compareTo() pada interface Comparable. Sedangkan, Comparator merupakan kelas terpisah dan di luar dari tipe-tipe element yang kita bandingkan. Ia semacam custom comparator. Artinya, kita dapat mempunyai comparator sebanyak yang kita mau. Ingin men-sort berdasarkan alamat, gunakan AlamatComparator. Ingin men-sort berdasarkan umur, gunakan UmurComparator. Ingin men-sort berdasarkan nomor Telepon, gunakan NoTeleponComparator. Anyway, you get the idea.

Kemudian, yang perlu kita lakukan adalah memanggil method sort yang kedua tadi dan mem-pass-kan list kita serta Comparator. Comparator akan membantu method Sort mengurutkan elemen-elemen pada list.

Sekarang, bagaimana kita menulis Comparator kita. Ingat, selain berdasarkan nama, kita ingin men-sort berdasarkan alamat. Jadi kita perlu menulis kelas AlamatComparator. How we do it?

Ok, pertama, kita menulis suatu inner class yang mengimplementasikan Comparator, sebut saja inner class-nya AlamatComparator. Di inner class AlamatComparator, kita override method compare(). Di method compare(), kita lakukan sama seperti ketika kita menulis method compareTo(). Hanya diperlukan sedikit modifikasi. Kita akan lihat listing kodenya sebentar lagi. Selanjutnya, kita buat instance dari inner class AlamatComparator, dan kita pass-kan ke method sort yang kedua (Atau istilahnya overloaded method sort(), method sort yang sama tetapi beda argumennya).

Ini dia listing lengkapnya.

import java.util.*;

public class EntryAlamat implements Comparable<EntryAlamat> {

	private String nama;
	private String alamat;

	public EntryAlamat(String nama, String alamat) {
		this.nama = nama;
		this.alamat = alamat;
	}

	public String getNama() {
		return nama;
	}

	public String getAlamat() {
		return alamat;
	}

	public int compareTo(EntryAlamat lain) {
		return nama.compareTo(lain.getNama());
	}

	public String toString() {
		return "["+ nama + ", " + alamat + "]";
	}
}

import java.util.*;

public class SortingEntryAlamat {

       public static void main(String[] args) {
	       new SortingEntryAlamat().test();
       }

       public void test() {
	       ArrayList<EntryAlamat> listAlamat = new ArrayList<EntryAlamat>();       

	       // Sampel
	       listAlamat.add(new EntryAlamat("Yayak", "Gedongkuning"));
	       listAlamat.add(new EntryAlamat("Paijo", "Babadan"));
	       listAlamat.add(new EntryAlamat("Andi", "Janti"));
	       listAlamat.add(new EntryAlamat("Budi", "Tegalrejo"));

	       System.out.println("Sebelum di-sort:");
	       System.out.println(listAlamat);

	       // Sort entry berdasarkan nama
	       Collections.sort(listAlamat);
	       System.out.println("\nSetelah di-sort berdasarkan nama:");
	       System.out.println(listAlamat);

	       // Sort entry berdasarkan alamat
	       Collections.sort(listAlamat, new AlamatComparator());
	       System.out.println("\nSetelah di-sort berdasarkan alamat:");
	       System.out.println(listAlamat);
       }

       // inner class yang mengimplementasikan Comparator
       class AlamatComparator implements Comparator<EntryAlamat> {
	       public int compare(EntryAlamat a, EntryAlamat b) {
		       return a.getAlamat().compareTo(b.getAlamat());
	       }
       }

}

Dan outputnya:

What do you think? Cool? he..he..he..

Oh yeah, one more thing. Untuk keterangan lebih lanjut, baca saja Head First Java.

Pada postingan kali ini, akan dibahas bagaimana melakukan sorting di java. Kita ingin men-sort suatu list yang distrukturkan dalam ArrayList. Kenapa ArrayList? Tidak ada alasan khusus sih. Kita bisa menggunakan struktur data yang lain, asal berupa list. Namun untuk contoh kita pakai saja ArrayList.

Ok, begini saja. Kita mulai contoh spesifik-nya. Andaikan kita ingin men-sort list yang berupa entry alamat. Tiap entry alamat terdiri dari nama dan alamat. Kita ingin men-sort list entry alamat tersebut berdasarkan nama. How is that? Cool? he..he..he (ok ,ok , not cool enough)

Sekarang darimana kita mulai? Bagaimana kalau kita mulai menulis kelas entry alamat-nya? Deal? deal….
Ini dia kelas entry alamat-nya (EntryAlamat.java):

import java.util.*;

public class EntryAlamat implements Comparable<EntryAlamat> {

	private String nama;
	private String alamat;

	public EntryAlamat(String nama, String alamat) {
		this.nama = nama;
		this.alamat = alamat;
	}

	public String getNama() {
		return nama;
	}

	public String getAlamat() {
		return alamat;
	}

	public int compareTo(EntryAlamat lain) {
		return nama.compareTo(lain.getNama());
	}

	public String toString() {
		return "["+ nama + ", " + alamat + "]";
	}
}

Kenapa kita bisa menulis seperti itu? Where the heck Comparable comes from? What is compareTo method?
Ok, you know what? Anggap saja sudah dari sananya, hi..hi..hi..

Sorry just kidding, ini penjelasan singkatnya. Mulanya kita ingin melakukan sorting, terus kita baca-baca di java docs, ada tidak method untuk sorting? NDilalah… kita menemukan dokumentasi yang ada di kelas Collections seperti ini:

Ternyata, di kelas Collections terdapat method sort. Method sort tersebut mengambil argumen List. Karena ArrayList mengimplementasikan interface List, maka ArrayList berupa List. Jadi ArrayList bisa di-pass-kan ke method sort. Tapi, sebagai orang yang selalu ingin tahu, kita bertanya-tanya: bagaimana method sort melakukan sorting terhadap entry alamat kita. Entry Alamat kita kan berupa objek, dan kita ingin men-sort-nya berdasarkan nama.

Kita scroll down lagi java docs-nya, dan melihat detil method sort. Hasilnya seperti ini.

Aneh memang artinya. Berhubungan dengan generics bla…bla…bla (Bisa dibaca di Head First Java ). Tapi untuk short-cut-nya, EntryAlamat kita harus mengimplementasikan interface Comparable dan meng-override method compareTo. Ini dokumentasi pada interface Comparable pada java.lang:

Jadi, method compareTo() akan dipanggil oleh salah satu objek EntryAlamat. Kemudian method compareTo() mem-pass-kan reference EntryAlamat yang lain. Objek EntryAlamat yang menjalankan method compareTo() harus memutuskan apakah EntryAlamat lain yang di-pass-kan kepadanya di-sort lebih tinggi, rendah, atau sama dalam list.

Sekarang pertanyaannya, apa yang membuat EntryAlamat yang satu lebih tinggi, rendah, atau sama dengan EntryAlamat yang lain? Inilah yang kemudian ditentukan oleh kita. Kita maunya berdasarkan apa. Kita ingin men-sort berdasarkan nama, maka kita meng-compare nama pada EntryAlamat yang satu dengan nama pada EntryAlamat yang lain. Terus, bagaimana membandingkan nama? Kita gunakan saja method compareTo yang dimiliki String. Nama kita kan berupa String, sehingga kita panggil nama dengan method compareTo(). Method ini tahu bagaimana membandingkan alphabet. Done….

Sekarang, kita coba test dengan kelas tester berikut yang didalamnya memanggil method sort pada kelas Collections (SortingEntryAlamat.java).

import java.util.*;

public class SortingEntryAlamat {

       public static void main(String[] args) {
	       new SortingEntryAlamat().test();
       }

       public void test() {
	       ArrayList<EntryAlamat> listAlamat = new ArrayList<EntryAlamat>();       

	       // Sampel
	       listAlamat.add(new EntryAlamat("Yayak", "Gedongkuning"));
	       listAlamat.add(new EntryAlamat("Paijo", "Babadan"));
	       listAlamat.add(new EntryAlamat("Andi", "Janti"));
	       listAlamat.add(new EntryAlamat("Budi", "Tegalrejo"));

	       System.out.println("Sebelum di-sort:");
	       System.out.println(listAlamat);

	       // Sort entry berdasarkan nama
	       Collections.sort(listAlamat);
	       System.out.println("\nSetelah di-sort berdasarkan nama:");
	       System.out.println(listAlamat);
       }
}

Outputnya:

Yeepp, inilah yang kita inginkan.
Bagaimana, keren tidak? Ya,ya,ya lumayan …..

Kemudian, kita ingin tidak hanya sort berdasarkan nama, tapi juga berdasarkan alamat. Kita akan melihat cara men-sort-nya di postingan berikutnya di Sorting Bagian 2…

Setelah membaca dan mem-postkan Strategy Pattern, saya ingin intermezzo dulu. Capek juga euy baca topik tentang design pattern.

Beberapa hari lalu saya melihat postingan mengenai masalah Producer Consumer di sini. Teman saya yang mem-post-kan. Ternyata merupakan implementasi dari pseudocode soal di ujian sistem operasinya. Wah rajin banget euy!

Di situ, terdapat kode producer consumer dalam bahasa java. Katanya, pseudocode-nya tidak aman. Dan benar juga, ketika dijalankan, outputnya menyatakan terjadi buffer overflow. Ini dia tampilannya saat saya jalankan di komputer.

Perkiraan awal saya, mungkin ini ada variabel yang di-share bersama. Jadi kalau tidak dilindungi, bisa gawat. Kemudian saya trace program-nya. Oh, di situ ada variabel count. Mungkin ini yang jadi masalah, karena diakses oleh producer dan consumer. Kemudian di java ada modifier synchronized untuk mencegah ada lebih dari satu objek mengakses method secara bersamaan. Saya coba synchronize-kan saja method yang menggunakan variabel count.

Kemudian saya compile dan jalankan. Arrgh…. masih terjadi buffer overflow. Saya cek lagi program-nya. Terus saya lihat ternyata producer dan consumer tidak mengakses method yang sama. Ketika mengubah variabel count, producer menggunakan method incCount(). Sedangkan consumer menggunakan decCount(). Dengan begitu, tidak ada gunanya di-synchronize.

Saya trace lagi, dan menemukan bahwa pengaksesan variable tidak ada yang jadi masalah. Akhirnya pencerahan itu datang. Letak masalahnya ada di statement

if (buffer.getCount() == 0) {
                try {
                    Thread.sleep(tts);
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                }
            }

Saya sebelumnya mengira, statement ini menyatakan consumer akan terus sleep ketika buffer-nya masih kosong. Tapi asumsi saya salah. Ia hanya mengecek sekali, kemudian sleep beberapa lama, setelah itu wake dan melakukan remove item, meskipun bisa saja item pada buffer belum tersedia alias buffer-nya masih kosong. Mungkin di saat awal tidak terjadi masalah. Tapi beberapa cycle kemudian, timing-nya tidak bisa menjamin ketika consumer wake lagi, buffer-nya pasti ada item-nya.

Sebelum melakukan remove item dari buffer, consumer harus memastikan dulu buffer-nya ada item-nya. Ini bisa dilakukan dengan mengganti pengecekannya dengan

while( buffer.getCount()==0) { }.

Jadi selama masih kosong, do nothing. Cara itu untuk mencegah buffer underflow.
Untuk mencegah buffer overflow, pengecekan pada producer dapat diganti menjadi

while (buffer.getCount() == buffer.getBufferSize()) { }

Selama masih penuh, do nothing.

Yah, sebenarnya kurang efektif sih pengecekan seperti itu. Kalau bisa processor langsung pindah dari consumer ketika buffer masih kosong, dan bukan berada terus di consumer dengan tidak melakukan apa-apa. Menyia-nyiakan waktu quantum saja!

Tapi untuk sementara itu dulu solusinya. Yang penting tidak ada buffer overflow atau buffer underflow .

Ini dia listing kode yang sedikit saya modifikasi. Bedanya, dengan mengimplementasikan runnable, kemudian waktu main-nya membuat thread dari producer dan consumer. Nggak ada alasan khusus sih. Saya cuma tahu cara buat thread seperti ini.

import java.util.*;

public class Buffer {
    private Vector buffer;
    private int bufferSize;
    private int count;

    public Buffer(int bufferSize) {
        this.buffer = new Vector(bufferSize);
        this.bufferSize = bufferSize;
        this.count = 0;
    }

    public synchronized void enterItem(String item) {
        buffer.add(item);
        System.out.println(item + " added.");
        if (buffer.size()>bufferSize) {
            System.err.println("\tBuffer overflow!!...");
        }
    }

    public synchronized String removeItem() {
        Object result;
        try {
        result = buffer.remove(0);
        } catch (Exception e) {
            System.err.println("\tBuffer underflow!!...");
            return "";
        }

        System.out.println("" + result + " removed.");
        return "" + result;
    }

    public void incCount() {
        count++;
    }

    public void decCount() {
        count--;
    }

    public int getBufferSize() {
        return bufferSize;
    }

    public int getCount() {
        return count;
    }

    public synchronized String toString() {
        StringBuffer sb = new StringBuffer(buffer.size());
        for (Object o:buffer) {
            if (o!=null) {
                sb.append("# ");
            }
        }

        return "" + count + ": " + sb.toString();
    }
}

public class Producer implements Runnable {
    private Buffer buffer;
    private long tts;

    private Consumer consumer;

    //--
    String item;
    private int msgId = 0;

    public Producer(Buffer buffer, long tts) {
        this.buffer = buffer;
        this.tts = tts;

        //setDaemon(false);
    }

    public void setConsumer(Consumer consumer) {
        this.consumer = consumer;
    }

    public void run() {
        while (true) {
            item = "msg " + ++msgId;

//	    if (buffer.getCount() == buffer.getBufferSize()) {
//                try {
//                    Thread.sleep(tts);
//                } catch (InterruptedException e) {
//                    //e.printStackTrace();
//                }
//            }

	while (buffer.getCount() == buffer.getBufferSize())
			{
			}

            buffer.enterItem(item);
            buffer.incCount();

            if (buffer.getCount() == 1)
                synchronized (consumer) {
                    consumer.notifyAll();
                }
        }
    }
}

public class Consumer implements Runnable {

    private Buffer buffer;
    private long tts;

    private Producer producer;

    //--
    private String item;

    public Consumer(Buffer buffer, long tts) {
        this.buffer = buffer;
        this.tts = tts;

        //setDaemon(false);
    }

    public void setProducer(Producer producer) {
        this.producer = producer;
    }

    public void run() {
        while (true) {

//           if (buffer.getCount() == 0) {
//               try {
//                   Thread.sleep(tts);
//               } catch (InterruptedException e) {
//                   //e.printStackTrace();
//               }
//           }

	   while (buffer.getCount() == 0)
			{
			}

            item = buffer.removeItem();
            buffer.decCount();

            if (buffer.getCount() == buffer.getBufferSize() - 1) {
                synchronized (producer) {
                    producer.notifyAll();
                }
            }

            System.out.println("Consumer consumes " + item);
        }
    }
}

public class ProducerConsumerDemo {

	public static void main(String[] args) {
		// Contoh kasus
		// buffernya hanya berkapasitas
		// satu item
		Buffer buffer = new Buffer(1);

		Producer producer = new Producer(buffer, 500);
		Consumer consumer = new Consumer(buffer, 500);
		producer.setConsumer(consumer);
		consumer.setProducer(producer);

		Thread one = new Thread(producer);
		Thread two = new Thread(consumer);

		one.start();
		two.start();
	}
}

Tampilan outputnya:

Setelah message ke 7798, syukurlah tidak ada pesan buffer overflow atau buffer underflow.

Mungkin ada teman yang punya solusi yang lebih baik. Share dong!

Kali ini merupakan postingan terakhir dari cerita kita tentang Joe dan Bebek-Bebeknya. Karena judulnya Strategy Pattern, maka kita perlu menunjukkan kaitan antara apa yang telah kita lakukan dengan apapun itu yang bernama Strategy Pattern. Apakah ada kaitannya? Tentu ada. Kalau tidak, buat apa kita capek-capek bercerita!

Namun sebelum sampai ke arah situ, kita recap dulu apa yang telah kita lakukan. Saatnya kita melihat big picture-nya….

Gambar di atas merupakan struktur kelas secara keseluruhan yang telah kita gunakan. Di situ para duck meng-extend kelas Duck, kelas-kelas behavior mengimplementasikan interface FlyBehavior dan QuackBehavior. Ok, kita sudah tahu ceritanya.

Nah, sekarang, kita tidak lagi menyebut kelas-kelas behavior tetapi menyebutnya sebagai familiy dari algoritma-algoritma. Jadi, dari kelas-kelas behavior FlyBehavior menjadi sebuah familiy algoritma flying. Begitu juga, kelas-kelas behavior QuackBehavior menjadi sebuah family algoritma quacking. Dalam konteks game simulasi Duck ini, suatu algoritma merepresentasikan hal-hal yang dilakukan seekor duck (Cara terbang dan cara ber-kwek yang berbeda).

Client Duck menggunakan family algoritma ini untuk terbang dan ber-kwek-kwek.

………Dan itulah yang kita namakan Strategy Pattern.
Inilah definisi formalnya:

Strategy Pattern mendefinisikan sekumpulan family algoritma-algoritma, meng-enkapsulasi-kan satu sama lain, dan membuatnya bisa ditukar-tukar. Strategy ini membuat algoritma dapat berubah secara independen dari Client yang menggunakannya.

Gunakan definisi ini untuk mengesankan saudara, teman, mertua …

Ok, saya bohong. Postingan ini bukanlah akhir dari cerita kita. Kita akan bersenang-senang dulu. Setelah kita mempunyai behavior class dari FlyBehavior dan QuackBehavior, kenapa kita tidak memanfaatkannya untuk men-set behavior secara dinamik. Is that cool?!

Jadi, kita ingin men-set tipe behavior dari Duck lewat method setter, dan bukannya menginisialisasinya di constructor.

Ok, let’s start….

Kita buat kelas Duck seperti sebelumnya, tapi kali ini kita tambahkan dua method baru, yaitu setFlyBehavior dan setQuackBehavior. Ketika dipanggil, method ini akan men-set behavior.

public abstract class Duck {
	FlyBehavior flyBehavior;
	QuackBehavior quackBehavior;

	public Duck() {
	}

	public void swim() {
		System.out.println("Saya berenang....");
	}

	public abstract void display();

	public void performFly() {
		flyBehavior.fly();
	}

	public void performQuack() {
		quackBehavior.quack();
	}

	public void setFlyBehavior(FlyBehavior fb) {
		flyBehavior = fb;
	}

	public void setQuackBehavior(QuackBehavior qb) {
		quackBehavior = qb;
	}
}

Terus, kita tambahkan tipe Duck baru, ModelDuck, dengan menuliskan kelas ModelDuck.java.

public class ModelDuck extends Duck {
	public ModelDuck() {
		flyBehavior = new FlyNoWay();
		quackBehavior = new Quack();
	}

	public void display() {
		System.out.println("Saya adalah Model Duck");
	}
}

Mula-mula kita set ModelDuck, tidak dapat terbang.

Selanjutnya kita tambahkan satu tipe baru dari FlyBehavior, yaitu terbang dengan kekuatan roket. Kita tuliskan kelas FlyRocketPowered.java.

public class FlyRocketPowered implements FlyBehavior {
	public void fly() {
		System.out.println("Saya terbang dengan roket");
	}
}

Langkah terakhir, kita ubah kelas tester MiniDuckSimulator.java dengan menambahkan ModelDuck dan membuat ModelDuck terbang dengan kekuatan roket. Ini dia kelas testernya.

public class MiniDuckSimulator {
	public static void main(String[] args) {
		Duck mallard = new MallardDuck();
		mallard.performQuack();
		mallard.performFly();

		System.out.println("----------------");
		System.out.println("Model Duck");
		Duck model = new ModelDuck();
		model.performFly();

		// Kita ubah supaya dapat terbang
		// dengan roket
		model.setFlyBehavior(new FlyRocketPowered());
		model.performFly();
	}
}

Kita compile, jalankan, dan outputnya ….

Yayay! Yang semula ModelDuck tidak dapat terbang, akhirnya dapat terbang dengan kekuatan roket setelah kita men-set FlyRocketPowered. Dengan cara ini, kita dapat mengubah behavior dari Duck saat runtime. Tinggal panggil saja method setter untuk behavior tersebut.

Ok, now what?
kita akan benar-benar wrap-up cerita ini di Strategy Pattern Bagian 5. Di sana juga akan muncul definisi Strategy Pattern. Gunakan definisi itu untuk mengesankan teman-teman. So trust me, and stay tuned….