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.