21 December 2008

Menggunakan Library Kapatcha sebagai Google Captcha dalam Validasi Form JSP

Pernahkah anda melihat gambar diatas? ya, gambar tersebut adalah sebuah gambar yang berisi kode-kode. Mungkin kita pernah melihat gambar ini ketika kita mendaftar pada layanan email seperti GoogleYahoo, atau mungkin ingin mengkomentari tulisan pada sebuah blog milik orang lain, dan lain-lain. Gambar ini dipakai sebagai sebuah teknik validasi form pada suatu aplikasi web. Teknik ini dipakai untuk sebagai sebuah cara oleh seorang developer aplikasi web untuk melindungi aplikasinya dari serangan spam.

Saat ini teknik ini sedang menjadi sebuah trend dalam pengembangan web aplikasi. Teknik ini dikenal luas dengan nama Google Captcha. Pada penggunaannya, kode-kode yang ada dalam gambar ini harus dimasukkan ke dalam input text yang disediakan oleh user agar ia terus bisa lanjut ke halaman berikutnya. Jika user salah memasukkan kode yang ada pada gambar tsb maka user tsb biasanya akan diminta kembali menginput kode dengan gambar yang berbeda.

Sekarang kita akan mencoba mengimplementasikan teknik ini pada percobaan kita kali ini. Untuk percobaan ini kita hanya akan membuat validasi form yang sederhana saja, dimana user diminta untuk menuliskan kode yang ada pada gambar, kemudian user mengklik tombol submit untuk pergi ke halaman berikutnya, nah dihalaman selanjutnya inilah kita akan memasukkan sintaks yang memeriksa validasi kode dari gambar yang diberikan pada halaman sebelumnya.

Pada percobaan ini kita akan menggunakan sebuah pustaka/ library, library tsb bernama kapatcha, silahkan anda mengunduhnya disini. Setelah selesai mengunduh jangan lupa meletakkan library ini pada folder WEB-INF/lib pada web aplikasi kita nanti. Cara kerja pustaka kapatcha ini sangat sederhana, dimana sebenarnya gambar yang diberikan pada sebuah form diciptakan oleh library kapatcha ini, sehingga kita tidak perlu membuat gambar-gambar yang berisi kode ini secara manual. Pendeknya, kapatcha akan membuatkannya secara on the fly.

Gambar yang nantinya akan di buat secara otomatis oleh library kapatcha ini, dibuat oleh sebuah kelas servlet dalam library kapatcha, servlet itu bernama KaptchaServlet terletak dalam package com.google.code.kaptcha.servlet. KapatchaServlet ini akan membuat secara otomatis sebuah gambar capthca dengan ekstensi .jpg setiap kali servlet ini dipanggil. Itu berarti kita harus meletakkan deklarasi servlet ini ke dalam file deployment descriptor. Kemudian dalam form kita kita tinggal memanggil gambar tersebut dengan tag html yaitu img. Perhatikan kode berikut ini:

<body>
<form name="kapatcha_form" action="validate_kaptcha.jsp" method="post">
Enter code shown on the picture <br>
<img src="kapatcha.jpg" width="200" id="kaptchaImage" onclick="document.location.reload()"/>
<br>
<small>if you cannot see the image, just click the image to reload the image</small>
<br>
<input type="text" name="kaptcha"><br>
<input type="submit" value="Submit">
</form>
</body>

Pada kode-kode form html diatas kita bisa melihat bahwa tag image(img) berisi sebuah gambar yang bernama 'kapatcha.jpg', dimana gambar ini sebenarnya tidak ada dalam folder web-aplikasi kita, namun gambar ini akan dibuat secara otomatis oleh servlet KaptchaServlet tadi pada saat kapatcha,jpg dipanggil, bagaimana cara memanggil servlet KapatchaServlet? Perhatikan kode-kode yang ada pada deployment-descriptor tomcat atau web.xml berikut ini :

<servlet>
<servlet-name>kapatcha</servlet-name>
<servlet-class>com.google.code.kaptcha.servlet.KaptchaServlet</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>kapatcha</servlet-name>
<url-pattern>/kapatcha.jpg</url-pattern>
</servlet-mapping>

dapat kita lihat disana bahwa KaptchaServlet di mapping ke sebuah url, yang url tsb adalah kapatcha.jpg, itu artinya ketika kapatcha.jpg dipanggil maka KapatchaServlet akan membuat sebuah gambar dan langsung di alokasikan sebagai kapatcha.jpg, sehingga dalam form kita akan terselip sebuah gambar yang tercipta dari pemanggilan servlet KaptchaServlet tsb. Sehingga form kita akan terlihat seperti gambar berikut:

Pada tag image yang ada pada form html kita tadi, kita juga bisa melihat ada sebuah fungsi java-script yang dipanggil yaitu : onclick=”document.location.reload();” dimana fungsi dari baris ini adalah me-reload halaman form dengan tujuan agar gambar yang mungkin tidak bisa dilihat oleh user bisa di buat lagi yang baru oleh KaptchaServlet agar user bisa melihat kode dalam gambar selanjutnya.

Sekarang bagaimana menangani validasi gambar tsb dalam halaman berikutnya, mari perhatikan kode-kode pada halaman validate_kaptcha.jsp berikut, dimana halaman ni juga tadi kita masukkan sebagai halaman tujuan dari form yang kita buat diatas:

<%@ page import="com.google.code.kaptcha.Constants" %>
<%
String kaptchaExpected = (String) request.getSession().getAttribute(Constants.KAPTCHA_SESSION_KEY);
String kaptchaReceived = request.getParameter("kaptcha");
String textResult = "";

if (kaptchaReceived == null || !kaptchaReceived.equalsIgnoreCase(kaptchaExpected)) {
textResult = "You're entered invalid code";
} else
textResult = "Congratulation you're entered correct code";

%>
<html>
<head>
<title>Validate Kapatcha</title>
</head>
<body>
<%=textResult%>
</body>
</html>

Dalam file validate_kapatcha.jsp diatas kita bisa melihat ada dua buah string inti yang di inisialisaikan sehubungan dengan validasi captha ini. Yaitu string kaptchaExpected yang menangkap session yang dibuat oleh servlet KaptchaServlet ketika gambar dibuat, kemudian ada juga string kaptchaReceieved yang nilainya di isi dari pengambilan nilai dari paramater kapctha yang dilempar oleh form sebelumnya.

Jangan lupa, baris pertama pada file validate_kaptcha.jsp ini ada sebuah kelas yang di import dari library kapatcha ini yaitu kelas Constants. Kemudian metode selanjutnya ada pemeriksaan antara String yang didapat dari Session yang dibuat oleh servlet KaptchaServlet dan String yang dimasukkan oleh user. Dari hasil pemeriksaan tsb kemudian kita menginisialiasi String textResult sebagai isi dari halaman validate_kaptcha.jsp kita.

Saya rasa mudah sekali implementasi Google Captcha pada percobaan kita kali ini. Dalam pengembangan selanjutnya anda bisa menggunakannya dalam web aplikasi anda sendiri.


Semoga Bermanfaat

Menteng, 22 Desember 2008

josescalia




14 December 2008

Membuat Http Post Client dengan Java

Apa sih yang terlintas di benak kita ketika kita membaca judul di atas?. Dalam teknologi internet kita sering kali menemukan interaksi yang terjadi antara user dengan sebuah website. Salah satu interaksi tsb misalnya adalah user diminta memasukkan suatu data dalam sebuah website untuk kepentingan website tsb. Ketika interaksi tersebut terjadi, kita bisa memahami bahwa dalam aplikasi web tersebut sebenarnya ada proses dimana ada data yang di masukkan ke server.

Ketika user memasukkan suatu data, terjadi sebuah proses posting ke dalam server. Dalam web programming kita mengenal dua metode untuk proses posting, metode tsb adalah metode post dan metode get. Metode get adalah suatu mekanisme posting data yang dalam prosesnya parameter-parameter yang diposting terlihat dalam address bar browser, sementara metode post adalah suatu mekanisme posting data yang paramater-parameter yang di posting tidak terlihat dalam address bar browser.

Dalam kesempatan kali ini kita akan mencoba membuat sebuah aplikasi java konsol, dimana aplikasi tsb mempunyai kemampuan untuk melakukan posting ke sebuah URL dengan metode HTTP POST. untuk percobaan kita kali ini, kita akan membutuhkan elemen server. Dimana Elemen server ini berguna untuk menangkap posting yang kita lakukan dengan menggunakan aplikasi java konsol kita. Kita akan membuat elemen servernya dengan menggunakan script PHP saja biar lebih simple dan mudah. Ok perhatikan script php dibawah ini, script ini kita buat untuk menangkap posting data yang dilemparkan.


 <?php
//define all param
$name = $_POST["name"];
$phone = $_POST["phone"];
$email = $_POST["email"];
$address = $_POST["address"];

//print our all posted param
echo "Name : ".$name."<br>";
echo "Phone : ".$phone."<br>";
echo "Email : ".$email."<br>";
echo "Address : ".$address."<br>";


//other method to go to next process goes here...!!!

?>

Sederhana saja script php di atas, pertama deklarasikan semua paramater yang dilempar ke script tersebut, kemudian print out semua paramater yang telah dilempar. Jika anda menginginkan proses lebih lanjut misalnya proses simpan ke database, silahkan saja buat proses selanjutnya seperti yang anda inginkan, yang penting lima baris definisi variabel yang menangkap posting ke file ini tetap ada. Dalam script php itu kita lihat, kita sengaja memakai $_POST untuk menangkap paramater yang dilempar karena aplikasi kita nanti akan menggunakan metode HTTP POST, jika aplikasi kita menggunakan metode http get, maka tidak seperti diatas deklarasi variabel yang menangkap parameter-parameter posting.

Script php ini kita beri nama test.php, kemudian kita buat sebuah folder dengan nama server_hit dalam folder htdocs instalasi apache, dan kita letakkan file test.php ini ke folder yang baru kita buat tadi. Langkah selanjutnya kita jalankan server apache kita dan kita tes url tersebut, dengan membuka sebuah browser dan mengetikkan http://localhost/server_hit/test.php pada address bar yang ada. Jika ada pada browser tsb terlihat seperti gambar dibawah ini, maka aplikasi server php kita telah siap:

Sekarang kita akan membuat sebuah aplikasi java konsol, dimana aplikasi ini akan menembak url tsb. Aplikasi java console kita kali ini akan melibatkan library dari koleksi apache.common.project yaitu library common-httpclient, silahkan download dahulu library tersebut disini. Library ini juga mempunyai dependency terhadap library lain yaitu library common-logging yang juga merupakan koleksi apache.common.project, silahkan download library common-logging tsb disini.

Jika semua library yang kita butuhkan telah tersedia, mari kita lakukan percobaan ini. Link ini adalah file source aplikasi kita yang sudah selesai. Kita akan membahas kode ini dengan seksama. Dalam source tsb kita memiliki tiga buah method yaitu:

  1. public static Hashtable defineParamToPost.

  2. public static sendUrlPost.

  3. public static void main.

Ketiga method dalam aplikasi kita ini adalah metode yang statik, dimana metode ketiga adalah metode utama dalam aplikasi kita, sedangkan metode yang lainya, dalam penggunaannya bisa kita panggil langsung dalam metode utama tanpa mendeklarasikan aplikasi kita sebagai sebuah objeck baru, karena kedua metode ini juga statik.

Sekarang kita lihat isi masing-masing metode tsb, perhatikan isi dari metode pertama seperti dibawah ini:

....
....
public static Hashtable defineParamToPost(String sParamName,
String sParamPhone,
String sParamEmail,
String sParamAddress) {
Hashtable hash = new Hashtable();
hash.put("name", sParamName);
hash.put("phone", sParamPhone);
hash.put("email", sParamEmail);
hash.put("address", sParamAddress);
return hash;

}

.....
.....

Metode ini mempunyai kembalian (return) berupa objeck Hashtable dan mempunyai 4 paramater yang bertipe String. Dalam metode ini semua paramater di mapping ke dalam sebuah Objeck Hashtable dan kemudian di kembalikan dalam bentuk objeck Hashtable.

Sekarang kita bahas metode ke dua, yaitu metode sendUrlPost. Mari perhatikan baris-baris awal pada metode ini seperti dibawah ini.


......
......
......
public static String sendUrlPost(String Url, Hashtable hash,
int connectionTimeout, int readTimeout) {

System.out.println("Url To Post: " + Url);
System.out.println("Timeout limit for Connection :" + connectionTimeout + " milisecond");
System.out.println("Timeout limit for Read Response :" + readTimeout + " milisecond ");
System.out.println("Params to be posted on Hashtable Object : " + hash);

String sResponse = "";

Enumeration paramList = hash.keys();
Vector requestParamKey = new Vector(1, 1);
Vector requestParamValue = new Vector(1, 1);

System.out.println("Converting Hashtable to Vector....");

while (paramList.hasMoreElements()) {
String name = (String) paramList.nextElement();
String value = (String) hash.get(name);
requestParamKey.addElement(name);
requestParamValue.addElement(value);
if (!paramList.hasMoreElements()) {
break;
}
}
System.out.println("Convert Hashtable to Vector done...");
......
......
......
}


Dalam baris-baris awal metode tsb, kita mencetak semua paramater yang di passing ke metode ini, kemudian setelah kita deklarasikan String sResponse, kita meng-inisialisasi beberapa objeck yaitu, objeck Enumeration, dan Objeck Vector. Kemudian proses selanjutnya kita melakukan looping untuk memapping isi dari Hashtable ke dalam masing-masing objeck Vector yang kita sudah inisialisasikan sebelumnya yaitu requestParamKey dan requestParamValue. Kemudian untuk proses selanjutnya silahkan kita lihat lagi beberapa baris selanjutnya dari metode ini.


public static String sendUrlPost(String Url, Hashtable hash,
int connectionTimeout, int readTimeout) {
......
......
......

//create new HttpClient Object
HttpClient client = new HttpClient();

//Set Timeout till connection established
client.setConnectionTimeout(connectionTimeout);

// Set Timeout waiting for data
client.setTimeout(readTimeout);

int responseCode = -1;

// Create a method instance.
PostMethod method = new PostMethod(Url);
method.setHttp11(false);

String req_name = null;
String req_value = null;
......
......
}


Dalam baris berikutnya seperti diatas kita bisa melihat, beberapa metode dari library common-httpclient mulai banyak di pakai disini. Step pertama kita bisa melihat ada pembuatan objeck HttpClient disana, kemudian objeck tersebut disetting beberapa property yaitu property Connection Time Out dan property Timeout dimana property Timeout adalah banyaknya waktu yang diperlukan untuk membaca hasil koneksi yang dilakukan.

Kemudian objeck baru yang juga dibuat diatas adalah objeck PostMethod, untuk objeck ini property yang di set hanya http11 saja yang di set menjadi false karena kita memang tidak memakai http11 ini. Kemudian ada deklarasi dua buah String disana yang langsung di beri nilai null sebagai inisialisasi awal variabel tsb. Mari perhatikan kode selanjutanya seperti dibawah ini:


public static String sendUrlPost(String Url, Hashtable hash,
int connectionTimeout, int readTimeout) {
......
......
......

try {
//iterate Vector contains http_post params
System.out.println("Iterating Vector to map to post params...");
for (int i = 0; i < requestParamKey.size(); i++) {
req_name = (String) requestParamKey.elementAt(i);
req_value = (String) requestParamValue.elementAt(i);
method.addParameter(req_name, req_value);
}

System.out.println("Iterating Vector Done...");

//execute Post Method
System.out.println("Executing Http Method...");
responseCode = client.executeMethod(method);
} catch (MalformedURLException mue) {
mue.printStackTrace();
} catch (IOException ioe) {
ioe.printStackTrace();
} catch (Exception runex) {
runex.printStackTrace();
}

//printout Server Status
System.out.println("HttpResponseCode : " + responseCode);

......
......
}


Dalam baris-baris diatas bahwa eksekusi post di lakukan disini setelah kita meng-iterasi Objeck Vector dan kemudian menempatkan masing-masing element dan nilainya ke dalam paramater metode http post. Proses tersebut harus dilakukan didalam blok try-catch untuk mencegah hal-hal yang tidak diinginkan seperti URL yang salah (ditunjukkan dengan catch MalformedURLException), atau catch-catch yang lainnya. Ketika method di eksekusi, server yang menerima eksekusi tsb pasti memulangkan status http, status ini bisa kita tangkap dan kemudian memprint-outnya ke atas konsol.

Sekarang mari kita perhatikan baris-baris terkahir dari metode ini:


public static String sendUrlPost(String Url, Hashtable hash,
int connectionTimeout, int readTimeout) {
......
......
......

if (responseCode != 200) {
// Release the connection.
method.releaseConnection();
System.out.println("Invalid HttpResponse: " + responseCode);
return sResponse;
}

// Read the response body.
System.out.println("Reading the Response Body...!!!");
byte[] responseBody = method.getResponseBody();

if (responseBody != null) {
System.out.println("Converting Response Body from byte array to String...");
sResponse = new String(responseBody);
if (sResponse != null) {
sResponse = sResponse.trim();
}
}

// Release the connection.
System.out.println("Releasing Connection...");
method.releaseConnection();

return sResponse;
}


Dalam baris-baris terakhir metode ini, kita bisa melihat bahwa jika respon kode http yang dipulangkan oleh server bukanlah 200 maka itu berarti proses posting kita tidak akan berhasil. Karena dalam respon kode http, sukses koneksi ke sebuah url akan ditandai oleh status http yang keluar dari server tsb berupa status 200. Kemudian baris selanjutnya dalam metode tersebut adalah mencoba membaca response body yang di hasilkan oleh file server yang kita hit tadi. Response body adalah tampilan suatu halaman akibat dari request yang kita lakukan pada sebuah halaman web.

Pembacaan Response body pada metode ini adalah membaca byte-byte yang memang tampil dari halaman tsb, pada metode ini byte-byte tsb kita masukkan dalam variabel yang berupa byte array(array of byte). Kemudian proses selanjutnya adalah mengkonversi byte array tadi ke sebuah string yang nantinya akan menjadi nilai kembalian metode ini. Proses terakhir metode ini adalah memutuskan koneksi yang ada pada metode http post itu.

Demikianlah pembahasan inti kedua metode ini yang kita buat dalam aplikasi kita kali ini, sementara untuk metode utamanya, saya rasa kita bisa mengerti dengan mudah, sebab metode utama aplikasi kita ini hanya memanggil kedua metode yang tadi sudah kita bahas.

Jika kita telah selesai melakukan pembuatan aplikasi kita ini, sekarang kita coba mengetes aplikasi kita ini, dari sisi saya aplikasi ini dapat berjalan dengan sukses menembak url yang kita definisikan tadi berikut screenshot-nya ketika aplikasi ini saya jalankan menggunakan IntelliJidea pada komputer saya, bagaimana dengan anda?

Untuk selanjutnya, anda bisa pakai konsep aplikasi ini untuk keperluan-keperluan posting data yang memang secara otomatis dapat dilakukan tanpa ada campur tangan user didalamnya. Misal memposting data ke dalam suatu web yang datanya banyak dan diambil dari isi suatu tabel dalam database, jika data yang diposting banyak maka, jika kita lakukan secara manual tentunya kegiatan posting ini akan banyak menyita waktu bukan.

Semoga bermanfaat.

Menteng January 15th 2008


josescalia

09 December 2008

Membuat Aplikasi XML Writer dengan Java Console

XML atau eXtensible MarkUp Language pada dasarnya adalah suatu bahasa buatan yang diciptakan oleh World Wide Web Consortium (W3C) untuk mengatasi keterbatasan yang ada pada bahasa HTML (Hyper Text Markup Language). Dengan XML kita bisa membuat tag-tag yang customizable atau dalam bahasa indonesianya “tag-tag semau gue”. Pada prakteknya saat ini XML digunakan untuk berbagai kepentingan dalam teknologi data komputer. Dari mulai penggunaan XML sebagai format pertukaran data dalam Web Servicesampai penggunaan XML sebagai sebuah format penyimpanan data.

Kita tidak akan membahas XML secara detail mengenai asal-usul, penggunaan atau bagaimana masa depan XML nantinya. Yang jelas saat ini, kita sudah tahu bahwa begitu penting kehadiran XML dalam kancah teknologi data komputer saat ini. Dan alangkan baiknya jika kita juga bisa mengimplementasikan kehadiran XML ini sebagai suatu tingkat tersendiri dalam pengetahuan kita. Untuk lebih jelasnya mengenai XML dan tingkah polahnya dalam dunia teknologi data komputer, silahkan anda mencari referensi sendiri tentang XML ini.

Kali ini kita akan mencoba membuat sebuah aplikasi java console yang mampu menuliskan sebuah data dalam format XML. Untuk contoh kali ini kita akan coba me-mapping sebuah list/daftar ke dalam sebuah format xml. Kita misalkan saja list seperti di bawah ini:

Seandainya daftar tsb kita mapping ke dalam sebuah format xml kira-kira akan menjadi seperti ini:

<BOOK_CATALOG>
<LIST>
<CODE>D0001</CODE>
<TITLE>Mastering Java</TITLE>
<WRITER>Ian Klause</WRITER>
<PUBLISHER>Ian Klause</PUBLISHER>
<YEAR>Ian Klause</YEAR>
</LIST>
<LIST>
<CODE>D0002</CODE>
<TITLE>Mastering Tomcat</TITLE>
<WRITER>Ian McFarland</WRITER>
<PUBLISHER>Ian McFarland</PUBLISHER>
<YEAR>Ian McFarland</YEAR>
</LIST>
<LIST>
<CODE>D0003</CODE>
<TITLE>Java GUI and Implementation</TITLE>
<WRITER>Patrick Boyze</WRITER>
<PUBLISHER>Patrick Boyze</PUBLISHER>
<YEAR>Patrick Boyze</YEAR>
</LIST>
<LIST>
<CODE>D0004</CODE>
<TITLE>Analyse Jboss Flow</TITLE>
<WRITER>Adelaine Gim</WRITER>
<PUBLISHER>Adelaine Gim</PUBLISHER>
<YEAR>Adelaine Gim</YEAR>
</LIST>
</BOOK_CATALOG>

Sekarang kita akan membuat sebuah aplikasi java console untuk menangani pembuatan list tersebut menjadi sebuah format data XML seperti diatas.

Ok, sekarang mari kita buat aplikasi ini, pertama kita buat dulu objeck yang propertinya adalah header list tsb, kita buat saja objeck standar java POJO (Plain Old Java Objeck) dengan getter, setter, konstruktor, dan metode toString , seperti kode yang ada pada link ini:

Hmm, sederhana bukan objeck yang baru saja kita buat diatas, untuk kontsruktornya pun langsung saja kita jadikan semua properti objeck ini menjadi paramater konstruktornya. Kemudian pada baris terkakhir kita lihat ada metode toString disana yang nanti berguna untuk mem-PrintOut nilai-nilai dari properti objeck tsb.

Kemudian langsung saja kita buat sebuah kelas kecil yang berguna untuk men-serialize Document menjadi sebuah Buffer String yang nantinya bisa kita langsung print-out string tersebut ke atas konsole. Kelas ini kita beri nama DomSerializer, link ini adalah kode-kode kelas ini.

Sebenarnya inti dari kelas DomSerializer ini adalah baris-baris yang ada pada metode yang ada pada serializeNode, metode ini intinya membaca setiap node yang ada dalam document yang menjadi parameter metode, kemudian hasil dari pembacaan tsb dimasukkan ke dalam string buffer. Kemudian pada kelas tsb juga ada metode serialize yang memanggil metode serializeNode dan kemudian mengembalikan nilai sebuah String, silahkan pahami sendiri masing-masing metode yang ada dalam kelas tsb.

Langkah selanjutnya kita langsung membuat sebuah aplikasi dimana aplikasi ini mempunyai skenario sebagai berikut :

1. Memasukkan semua data dalam list ke dalam objeck array.

2. Membuat sebuah objeck document XML

3. Mengkonversi document xml yang telah kita buat dengan menggunakan kelas DomSerializer.

Untuk me-mapping list tersebut menjadi sebuah objeck array mari perhatikan kode-kode berikut ini:

public class XMLApplication {
.........
.........
public static void main(String[] args) {
BookCatalog[] catalog = new BookCatalog[4];
//entrying the data
catalog[0] = new BookCatalog("D0001", "Mastering Java", "Ian Klause", "Wrox.com", Double.parseDouble("2005"));
catalog[1] = new BookCatalog("D0002", "Mastering Tomcat", "Ian McFarland", "Wrox.com", Double.parseDouble("2002"));
catalog[2] = new BookCatalog("D0003", "Java GUI and Implementation", "Patrick Boyze", "Andalusia.com", Double.parseDouble("2001"));
catalog[3] = new BookCatalog("D0004", "Analyse Jboss Flow", "Adelaine Gim", "Tarkuti.com", Double.parseDouble("2003"));
..........
........
.......
}
......

Pada baris-baris tsb kita bisa lihat bahwa yang kita lakukan pertama kali adalah membuat sebuah object array baru dengan indeks dari array ini sebanyak 4 sesuai dengan banyaknya data yang ada dalam list. Kemudian untuk masing-masing indeks kita isi nilainya sesuai dengan referensi kontsruktor objeck BookCatalog yang tadi sudah kita buat.

Langkah selanjutnya adalah membuat tiga buah metode dalam aplikasi kita ini, metode-metode tsb adalah:

1. getDocumentBuilder, metode ini adalah sebuah metode yang intinya menggunakan kelas DocumentBuilderFactory yang ada pada package javax.xml.parsers. Kemudian metode ini mengembalikan (return ) sebuah objeck berupa DocumentBuilder yang nantinya bisa dipakai dalam metode-metode berikutnya. Perhatikan kode baris metode ini:

public class XMLApplication {
.........
.........
.........
private DocumentBuilder getDocumentBuilder() {
DocumentBuilderFactory dbf=null;
DocumentBuilder db=null;
if ((db == null) || (dbf == null)) {
// Step 1: create a DocumentBuilderFactory and configure it
dbf = DocumentBuilderFactory.newInstance();
// Optional: set various configuration options
dbf.setValidating(false);
// Step 2: create a DocumentBuilder that satisfies the constraints
// specified by the DocumentBuilderFactory
try {
db = dbf.newDocumentBuilder();
}
catch (ParserConfigurationException pce) {
System.err.println(pce);
}
}
return db;
}
.........
.........
.........
}


dapat kita lihat dalam kode-kode tsb, pertama kali dalam metode ini kelas DocumentBuilderFactory dipanggil dan diinisialisasi dengan nilai null, kemudian dalam blok if kelas DocumentBuilderFactory ini kemudian di buat dan di set konfigurasinya, setelah itu dalam blok try baru kemudian di buat sebuah DocumentBuilder yang nantinya akan menjadi nilai kembalian metode ini.

2. createXMLTemp, metode ini mempunyai kembalian (return) sebuah document xml, dan dengan paramaternya yaitu objeck array BookCatalog. Berikut kode-kode dari metode ini:

public class XMLApplication {
.........
.........
.........
private Document createXMLTemp(BookCatalog[] catalog) {
Document doc = getDocumentBuilder().newDocument();
Element top = doc.createElement("BOOK_CATALOG");
doc.appendChild(top);
Element root = doc.getDocumentElement();
Element list = null;

for (int i = 0; i < catalog.length; i++) {
list = doc.createElement("LIST");

Element elCode = doc.createElement("CODE");
Text txtElCode = doc.createTextNode(catalog[i].getBookCode());
elCode.appendChild(txtElCode);
list.appendChild(elCode);

Element elTitle = doc.createElement("TITLE");
Text txtElTitle = doc.createTextNode(catalog[i].getBookTitle());
elTitle.appendChild(txtElTitle);
list.appendChild(elTitle);

Element elWriter = doc.createElement("WRITER");
Text txtElWriter = doc.createTextNode(catalog[i].getBookWriter());
elWriter.appendChild(txtElWriter);
list.appendChild(elWriter);

Element elPublisher = doc.createElement("PUBLISHER");
Text txtElPublisher = doc.createTextNode(catalog[i].getBookWriter());
elPublisher.appendChild(txtElPublisher);
list.appendChild(elPublisher);

Element elYear = doc.createElement("YEAR");
Text txtElYear = doc.createTextNode(catalog[i].getBookWriter());
elYear.appendChild(txtElYear);
list.appendChild(elYear);
root.appendChild(list);
}


return doc;
}

.........

jika kita lihat pada baris-baris tsb, metode getDocumentBuilder pertama kali dipanggil untuk membuat sebuah objeck document xml yang baru, kemudian objeck document tsb diberi sebuah element paling atas yang diberi nama element top, kemudian setelah itu ada looping yang dilakukan sebanyak jumlah indeks array yang ada pada objeck BookCatalog sebagai parameternya, dimana didalam proses pengulangan (looping) ini dilakukan sebuah proses penambahan element-element yang sesuai dengan header masing-masing yang ada pada list tersebut diantaranya : CODE, TITLE, WRITER, PUBLISHER dan YEAR

3. serializeDOM ini adalah metode ketiga yang kita buat yang berguna untuk mengkonversi document XML menjadi sebuah String yang nantinya dapat kita pakai untuk mencetak ke atas konsol. Berikut kode-kode metode terakhir ini.

public class XMLApplication {
.........
.........
.........
private String serializeDOM(Document doc) throws IOException {
DomSerializer serializer = new DomSerializer();
return serializer.serialize(doc);
}

.........
.........
.........
}

Setelah ketiga metode itu selesai kita buat mari kita lanjutkan ke skenario-skenario selanjutnya yang tadi telah kita susun yaitu ke langkah membuat sebuah objeck document XML dan mengkonversi document xml yang telah kita buat dengan menggunakan kelas DomSerializer. , perhatikan kode-kode berikut ini untuk sekaligus dua kita bahas langkah tsb.

public class XMLApplication {
.........
.........
public static void main(String[] args) {
............
............
XMLApplication app = new XMLApplication();

//create document Object
Document doc = app.createXMLTemp(catalog);
//Serialize document to String
String output = "";
try {
output = app.serializeDOM(doc);
} catch (IOException e) {
e.printStackTrace();
}
System.out.print(output);
......
......
......
}
......
......
......
}

Demikian diatas adalah dua skenario terakhir yang kita langsung terapkan dalam program kita kali ini, dimana pada kode-kode tsb kita bisa melihat bahwa kita membuat sebuah objeck document disini dan kemudian document ini langsung kita konversi menjadi string, dan akhirnya string tsb kita print out ke atas konsol. Ini adalah link yang berisi file aplikasi kita yang sudah kita optimasi kembali agar kode-kode kita terlihat lebih rapi dan mudah dibaca serta dimengerti (link source code aplikasi utama).

Demikianlah, percobaan kita kali ini, dimana aplikasi XML Writer yang bisa kita pakai untuk mencetak list menjadi sebuah tampilan format XML ke atas konsol. Pada prakteknya saya pribadi menggunakan metode ini untuk membuat sebuah Servlet yang menghasilkan format data XML. Saya memakainya untuk sebuah aplikasi web berupa layanan web service yang dipakai dalam perusahaan dimana saya bekerja. Dimana datanya saya ambil dari database dan kemudian print out xml nya ditangani oleh sebuah servlet untuk ditampilkan dalam sebuah request melalui port http.

Sengaja saya menuliskan contoh aplikasi XML Writer ini yang mem-print out hasil xml di atas konsol. Sebab jika saya membahasnya dalam lingkungan aplikasi web dan dengan database maka artikel ini pastinya akan berkembang menjadi lebih besar lagi sebab banyak sekali layer yang nantinya akan dibuat dalam aplikasi tsb dari mulai DAO Layer hingga Presentation Layer, sementara untuk pembuatan layer-layer itu sendiri akan juga memerlukan konsentrasi yang terpisah dari pembuatan XML Writer ini.

Silahkan anda kembangkan lagi aplikasi ini menjadi aplikasi yang skala penggunaannya lebih besar daripada yang kita bahas sekarang ini. Semoga artikel ini dapat menjadi panduan buat pembaca blog ini pada umumnya dan saya pribadi pada khususnya dalam menangani masalah penulisan XML dalam implementasinya dengan mempergunakan bahasa pemrograman Java.


Semoga bermanfaat

Menteng, 9 December 2009


josescalia.