Apa perbedaan antara SAX dan DOM?

Saya membaca beberapa artikel tentang parser XML dan menemukan SAX dan DOM .

SAX berbasis acara dan DOM adalah model pohon - Saya tidak mengerti perbedaan antara konsep-konsep ini.

Dari apa yang saya mengerti, event-based berarti semacam peristiwa yang terjadi pada node. Seperti ketika seseorang mengklik node tertentu, ia akan memberikan semua sub node daripada memuat semua node pada saat yang sama. Tetapi dalam kasus parsing DOM itu akan memuat semua node dan membuat model pohon.

Apakah pemahaman saya benar?

Tolong perbaiki saya. Jika saya salah atau jelaskan kepada saya model berdasarkan kejadian dan pohon dengan cara yang lebih sederhana.

Yah, kamu dekat.

Di SAX, peristiwa dipicu ketika XML sedang diuraikan . Ketika parser mem-parsing XML, dan menemukan tag awal (mis. <something>), Maka pemicu tagStartedkejadian (nama sebenarnya acara mungkin berbeda). Demikian pula ketika akhir tag bertemu saat parsing ( </something>), ia memicu tagEnded. Menggunakan SAX parser menyiratkan Anda perlu menangani peristiwa ini dan memahami data yang dikembalikan dengan setiap peristiwa.

Di DOM, tidak ada peristiwa yang dipicu saat parsing. Seluruh XML diuraikan dan pohon DOM (dari node dalam XML) dihasilkan dan dikembalikan. Setelah diuraikan, pengguna dapat menavigasi pohon untuk mengakses berbagai data yang sebelumnya tertanam dalam berbagai node dalam XML.

Secara umum, DOM lebih mudah digunakan tetapi memiliki overhead untuk menguraikan seluruh XML sebelum Anda dapat mulai menggunakannya.

Hanya dalam beberapa kata ...

SAX ( S imple A PI untuk X ML): Adalah prosesor berbasis aliran. Anda hanya memiliki bagian kecil dalam memori kapan saja dan Anda "mengendus" aliran XML dengan menerapkan kode panggilan balik untuk acara-acara seperti tagStarted()dll. Ini hampir tidak menggunakan memori, tetapi Anda tidak dapat melakukan hal-hal "DOM", seperti menggunakan xpath atau traverse pohon.

DOM ( D ocument O bject M odel): Anda memuat semuanya ke dalam memori - ini adalah memori babi yang besar. Anda dapat meniup memori dengan dokumen berukuran sedang sekalipun. Tetapi Anda dapat menggunakan xpath dan melintasi pohon dll.

Di sini dengan kata-kata yang lebih sederhana:

DOM

• Parser model pohon (berbasis objek) (Pohon node).

• DOM memuat file ke dalam memori dan kemudian mengurai file.

• Memiliki kendala memori karena memuat seluruh file XML sebelum parsing.

• DOM dibaca dan ditulis (dapat menyisipkan atau menghapus node).

• Jika konten XML kecil, maka lebih memilih parser DOM.

• Pencarian mundur dan maju dimungkinkan untuk mencari tag dan mengevaluasi informasi di dalam tag. Jadi ini memberi kemudahan navigasi.

• Lebih lambat saat run time.

SAKSOFON

• Parser berbasis acara (Urutan acara).

• SAX mem-parsing file ketika membacanya, yaitu mem-parsing node demi node.

• Tidak ada kendala memori karena tidak menyimpan konten XML dalam memori.

• Hanya SAX yang dapat dibaca yaitu tidak dapat menyisipkan atau menghapus simpul.

• Gunakan SAX parser saat konten memori besar.

• SAX membaca file XML dari atas ke bawah dan navigasi ke belakang tidak dimungkinkan.

• Lebih cepat saat dijalankan.

Anda benar dalam pemahaman Anda tentang model berbasis DOM. File XML akan dimuat secara keseluruhan dan semua kontennya akan dibuat sebagai representasi in-memory dari pohon yang diwakili oleh dokumen. Ini bisa memakan waktu dan memori, tergantung pada seberapa besar file input. Manfaat dari pendekatan ini adalah Anda dapat dengan mudah meminta bagian apa pun dari dokumen, dan secara bebas memanipulasi semua node di pohon.

Pendekatan DOM biasanya digunakan untuk struktur XML kecil (di mana kecil tergantung pada berapa banyak tenaga kuda dan memori platform Anda) yang mungkin perlu dimodifikasi dan ditanya dengan cara yang berbeda setelah mereka dimuat.

SAX di sisi lain dirancang untuk menangani input XML dari ukuran apa pun. Alih-alih kerangka XML melakukan kerja keras untuk Anda dalam mencari tahu struktur dokumen dan mempersiapkan banyak objek yang berpotensi untuk semua node, atribut dll, SAX benar-benar meninggalkan itu untuk Anda.

Apa yang pada dasarnya dilakukannya adalah membaca input dari atas dan memanggil metode panggilan balik yang Anda berikan ketika "peristiwa" tertentu terjadi. Suatu peristiwa mungkin mengenai tag pembuka, atribut dalam tag, menemukan teks di dalam elemen atau menemukan tag akhir.

SAX dengan keras kepala membaca input dan memberi tahu Anda apa yang dilihatnya dengan cara ini. Terserah Anda untuk mempertahankan semua informasi negara yang Anda butuhkan. Biasanya ini berarti Anda akan membangun semacam mesin negara.

Meskipun pendekatan ini untuk pemrosesan XML jauh lebih membosankan, itu bisa sangat kuat juga. Bayangkan Anda ingin mengekstrak judul artikel berita dari umpan blog. Jika Anda membaca XML ini menggunakan DOM, itu akan memuat semua konten artikel, semua gambar, dll. Yang terkandung dalam XML ke dalam memori, meskipun Anda bahkan tidak tertarik dengannya.

Dengan SAX Anda bisa memeriksa apakah nama elemennya adalah (misalnya) "judul" setiap kali metode acara "startTag" Anda dipanggil. Jika demikian, Anda tahu bahwa Anda perlu menambahkan apa pun yang ditawarkan "elemenText" acara berikutnya kepada Anda. Ketika Anda menerima panggilan acara "endTag", Anda memeriksa lagi apakah ini adalah elemen penutup dari "judul". Setelah itu, Anda mengabaikan semua elemen lebih lanjut, sampai input berakhir, atau "startTag" lainnya dengan nama "judul" muncul. Dan seterusnya...

Anda dapat membaca megabita dan megabita XML dengan cara ini, hanya mengekstraksi sejumlah kecil data yang Anda butuhkan.

Sisi negatif dari pendekatan ini tentu saja, bahwa Anda perlu melakukan lebih banyak pembukuan sendiri, tergantung pada data apa yang Anda perlu ekstrak dan seberapa rumit struktur XML itu. Selain itu, Anda secara alami tidak dapat memodifikasi struktur pohon XML, karena Anda tidak pernah memilikinya secara keseluruhan.

Jadi secara umum, SAX cocok untuk menyisir data berpotensi besar dalam jumlah besar yang Anda terima dengan "kueri" tertentu, tetapi tidak perlu memodifikasi, sementara DOM lebih ditujukan untuk memberi Anda fleksibilitas penuh dalam mengubah struktur dan konten, dengan biaya permintaan sumber daya yang lebih tinggi.

Anda membandingkan apel dan pir. SAX adalah pengurai yang mem-parsing struktur DOM serial. Ada banyak parser yang berbeda, dan "berbasis kejadian" mengacu pada metode parsing.

Mungkin rekap kecil dalam urutan:

• The objek dokumen Model (DOM) adalah model data abstrak yang menggambarkan struktur dokumen hirarkis, berbasis pohon; pohon dokumen terdiri dari node , yaitu elemen, atribut dan node teks (dan beberapa lainnya). Node memiliki orang tua, saudara kandung dan anak-anak dan dapat dilalui, dll., Semua hal yang biasa Anda lakukan dari JavaScript (yang notabene tidak ada hubungannya dengan DOM).

• Struktur DOM dapat diserialisasi , yaitu ditulis ke file, menggunakan bahasa markup seperti HTML atau XML. File HTML atau XML dengan demikian berisi versi "ditulis" atau "diratakan" dari pohon dokumen abstrak.

• Agar komputer dapat memanipulasi, atau bahkan menampilkan, pohon DOM dari suatu file, komputer harus melakukan deserialisasi , atau mengurai , file dan merekonstruksi pohon abstrak dalam memori. Di sinilah penguraian masuk

Sekarang kita sampai pada sifat parser. Salah satu cara untuk menguraikan adalah dengan membaca seluruh dokumen dan secara rekursif membangun struktur pohon dalam memori, dan akhirnya memaparkan seluruh hasil kepada pengguna. (Saya kira Anda bisa memanggil parser ini "parser DOM".) Itu akan sangat berguna bagi pengguna (saya pikir itulah yang dilakukan parser XML PHP), tetapi ia mengalami masalah skalabilitas dan menjadi sangat mahal untuk dokumen besar.

Di sisi lain, parsing berbasis peristiwa , seperti yang dilakukan oleh SAX, melihat file secara linear dan hanya membuat panggilan balik kepada pengguna setiap kali menemukan sepotong struktural data, seperti "elemen ini dimulai", "elemen itu berakhir" , "beberapa teks di sini", dll. Ini memiliki manfaat yang dapat berlangsung selamanya tanpa memperhatikan ukuran file input, tetapi ini jauh lebih rendah karena mengharuskan pengguna untuk melakukan semua pekerjaan pemrosesan yang sebenarnya (dengan menyediakan panggilan balik). Untuk kembali ke pertanyaan awal Anda, istilah "berbasis peristiwa" mengacu pada peristiwa parsing yang dimunculkan parser saat melintasi file XML.

The Artikel Wikipedia memiliki banyak detail pada tahapan SAX parsing.

Saya akan memberikan jawaban umum yang berorientasi pada Tanya Jawab untuk pertanyaan ini:

Jawab untuk Pertanyaan

Mengapa kita membutuhkan parser XML?

Kami membutuhkan parser XML karena kami tidak ingin melakukan semuanya dalam aplikasi kami dari awal, dan kami membutuhkan beberapa program atau pustaka "pembantu" untuk melakukan sesuatu yang sangat rendah tetapi sangat diperlukan bagi kami. Hal-hal tingkat rendah tetapi perlu ini termasuk memeriksa kemapanan, memvalidasi dokumen terhadap DTD atau skema (hanya untuk memvalidasi parser), menyelesaikan referensi karakter, memahami bagian CDATA, dan sebagainya. Parser XML hanyalah program "pembantu" dan mereka akan melakukan semua pekerjaan ini. Dengan parser XML, kami dilindungi dari banyak kerumitan ini dan kami dapat berkonsentrasi hanya pada pemrograman tingkat tinggi melalui API yang diimplementasikan oleh parser, dan dengan demikian mendapatkan efisiensi pemrograman.

Mana yang lebih baik, SAX atau DOM?

Pengurai SAX dan DOM memiliki kelebihan dan kekurangan. Mana yang lebih baik harus bergantung pada karakteristik aplikasi Anda (silakan lihat beberapa pertanyaan di bawah).

Parser mana yang bisa mendapatkan kecepatan, DOM atau SAX parser yang lebih baik?

Parser SAX bisa mendapatkan kecepatan yang lebih baik.

Apa perbedaan antara API berbasis pohon dan API berbasis peristiwa?

API berbasis pohon dipusatkan di sekitar struktur pohon dan oleh karena itu menyediakan antarmuka pada komponen pohon (yang merupakan dokumen DOM) seperti antarmuka Dokumen, antarmuka Node, antarmuka NodeList, antarmuka Elemen, antarmuka Attr dan sebagainya. Sebaliknya, API berbasis peristiwa menyediakan antarmuka pada penangan. Ada empat antarmuka handler, antarmuka ContentHandler, antarmuka DTDHandler, antarmuka EntityResolver, dan antarmuka ErrorHandler.

Apa perbedaan antara DOM Parser dan SAX Parser?

Parser DOM dan Parser SAX bekerja dengan berbagai cara:

• Pengurai DOM membuat struktur pohon dalam memori dari dokumen input dan kemudian menunggu permintaan dari klien. Tetapi parser SAX tidak membuat struktur internal apa pun. Alih-alih, ia mengambil kejadian komponen input dokumen sebagai peristiwa, dan memberi tahu klien apa yang dibaca saat membaca dokumen input. SEBUAH

• Parser DOM selalu melayani aplikasi klien dengan seluruh dokumen tidak peduli berapa banyak sebenarnya yang dibutuhkan oleh klien. Tetapi parser SAX melayani aplikasi klien selalu hanya dengan potongan dokumen pada waktu tertentu.

• Dengan parser DOM, pemanggilan metode dalam aplikasi klien harus eksplisit dan membentuk semacam rantai. Tetapi dengan SAX, beberapa metode tertentu (biasanya ditimpa oleh si cient) akan dipanggil secara otomatis (secara implisit) dengan cara yang disebut "callback" ketika beberapa peristiwa tertentu terjadi. Metode-metode ini tidak harus dipanggil secara eksplisit oleh klien, meskipun kita dapat memanggilnya secara eksplisit.

Bagaimana kita memutuskan parser mana yang bagus?

Idealnya pengurai yang baik harus cepat (hemat waktu), hemat ruang, kaya fungsionalitas, dan mudah digunakan. Namun pada kenyataannya, tidak ada parser utama yang memiliki semua fitur ini pada saat yang sama. Misalnya, DOM Parser kaya fungsionalitas (karena membuat pohon DOM dalam memori dan memungkinkan Anda untuk mengakses bagian mana pun dari dokumen berulang kali dan memungkinkan Anda untuk memodifikasi pohon DOM), tetapi itu adalah ruang yang tidak efisien ketika dokumen sangat besar , dan perlu waktu agak lama untuk mempelajari cara bekerja dengannya. Parser SAX, bagaimanapun, jauh lebih efisien ruang dalam hal dokumen input besar (karena tidak menciptakan struktur internal). Terlebih lagi, ini berjalan lebih cepat dan lebih mudah dipelajari daripada DOM Parser karena API-nya sangat sederhana. Tapi dari sudut pandang fungsionalitas, ini menyediakan lebih sedikit fungsi yang berarti bahwa pengguna itu sendiri harus mengurus lebih banyak, seperti membuat struktur data mereka sendiri. Omong-omong, apa itu pengurai yang baik? Saya pikir jawabannya sangat tergantung pada karakteristik aplikasi Anda.

Apa saja aplikasi dunia nyata di mana menggunakan SAX parser lebih menguntungkan daripada menggunakan DOM parser dan sebaliknya? Apa aplikasi yang biasa untuk parser DOM dan untuk parser SAX?

Dalam kasus berikut, menggunakan parser SAX lebih menguntungkan daripada menggunakan parser DOM.

• Dokumen input terlalu besar untuk memori yang tersedia (sebenarnya dalam hal ini SAX adalah satu-satunya pilihan Anda)
• Anda dapat memproses dokumen dalam potongan input kecil yang berdekatan. Anda tidak perlu seluruh dokumen sebelum dapat melakukan pekerjaan yang bermanfaat
• Anda hanya ingin menggunakan parser untuk mengekstrak informasi yang menarik, dan semua perhitungan Anda akan sepenuhnya didasarkan pada struktur data yang Anda buat sendiri. Sebenarnya di sebagian besar aplikasi kita, kita membuat struktur data kita sendiri yang biasanya tidak serumit pohon DOM. Dari pengertian ini, saya pikir, kesempatan menggunakan parser DOM lebih kecil dari pada menggunakan parser SAX.

Dalam kasus berikut, menggunakan parser DOM lebih menguntungkan daripada menggunakan parser SAX.

• Aplikasi Anda perlu mengakses secara terpisah berbagai bagian dokumen pada saat yang bersamaan.
• Aplikasi Anda mungkin menggunakan struktur data internal yang hampir serumit dokumen itu sendiri.
• Aplikasi Anda harus memodifikasi dokumen berulang kali.
• Aplikasi Anda harus menyimpan dokumen untuk waktu yang signifikan melalui banyak panggilan metode.

Contoh (Gunakan parser DOM atau parser SAX?):

Asumsikan bahwa seorang instruktur memiliki dokumen XML yang berisi semua informasi pribadi siswa serta poin yang dibuat siswa di kelasnya, dan ia sekarang menugaskan nilai akhir untuk siswa menggunakan aplikasi. Apa yang ingin dia hasilkan, adalah daftar dengan SSN dan nilai-nilainya. Kami juga berasumsi bahwa dalam aplikasinya, instruktur tidak menggunakan struktur data seperti array untuk menyimpan informasi pribadi siswa dan poin. Jika instruktur memutuskan untuk memberikan nilai A kepada mereka yang mendapatkan nilai rata-rata kelas atau di atas, dan memberikan nilai B kepada yang lain, maka ia lebih baik menggunakan parser DOM dalam aplikasinya. Alasannya adalah bahwa dia tidak memiliki cara untuk mengetahui berapa rata-rata kelas sebelum seluruh dokumen diproses. Apa yang mungkin perlu dia lakukan dalam lamarannya, adalah pertama-tama memeriksa semua siswa. poin dan menghitung rata-rata, dan kemudian melihat kembali dokumen itu dan menetapkan nilai akhir untuk setiap siswa dengan membandingkan poin yang dia dapatkan dengan rata-rata kelas. Namun, jika instruktur mengadopsi kebijakan penilaian sedemikian rupa sehingga siswa yang mendapat 90 poin atau lebih, diberi nilai A dan yang lain diberi nilai B, maka mungkin ia lebih baik menggunakan parser SAX. Alasannya, untuk menugaskan setiap siswa nilai akhir, ia tidak perlu menunggu seluruh dokumen diproses. Dia bisa segera memberikan nilai kepada siswa setelah parser SAX membaca nilai siswa ini. Dalam analisis di atas, kami berasumsi bahwa instruktur tidak membuat struktur data sendiri. Bagaimana jika dia membuat struktur datanya sendiri, seperti array string untuk menyimpan SSN dan array integer untuk mengembalikan poin? Pada kasus ini, Saya pikir SAX adalah pilihan yang lebih baik, sebelum ini bisa menghemat memori dan waktu juga, namun menyelesaikan pekerjaan. Nah, satu pertimbangan lagi pada contoh ini. Bagaimana jika yang ingin dilakukan oleh instruktur bukanlah mencetak daftar, tetapi untuk menyimpan kembali dokumen asli dengan nilai setiap siswa yang diperbarui? Dalam hal ini, parser DOM harus menjadi pilihan yang lebih baik tidak peduli kebijakan penilaian apa yang ia adopsi. Dia tidak perlu membuat struktur data sendiri. Apa yang perlu dia lakukan adalah memodifikasi pohon DOM terlebih dahulu (yaitu, menetapkan nilai ke simpul 'kelas') dan kemudian menyimpan seluruh pohon yang dimodifikasi. Jika dia memilih untuk menggunakan SAX parser daripada parser DOM, maka dalam hal ini dia harus membuat struktur data yang hampir sama rumitnya dengan pohon DOM sebelum dia bisa menyelesaikan pekerjaan. belum menyelesaikan pekerjaan. Nah, satu pertimbangan lagi pada contoh ini. Bagaimana jika yang ingin dilakukan oleh instruktur bukanlah mencetak daftar, tetapi untuk menyimpan kembali dokumen asli dengan nilai setiap siswa yang diperbarui? Dalam hal ini, parser DOM harus menjadi pilihan yang lebih baik tidak peduli kebijakan penilaian apa yang ia adopsi. Dia tidak perlu membuat struktur data sendiri. Apa yang perlu dia lakukan adalah memodifikasi pohon DOM terlebih dahulu (yaitu, menetapkan nilai ke simpul 'kelas') dan kemudian menyimpan seluruh pohon yang dimodifikasi. Jika dia memilih untuk menggunakan SAX parser daripada parser DOM, maka dalam hal ini dia harus membuat struktur data yang hampir sama rumitnya dengan pohon DOM sebelum dia bisa menyelesaikan pekerjaan. belum menyelesaikan pekerjaan. Nah, satu pertimbangan lagi pada contoh ini. Bagaimana jika yang ingin dilakukan oleh instruktur bukanlah mencetak daftar, tetapi untuk menyimpan kembali dokumen asli dengan nilai setiap siswa yang diperbarui? Dalam hal ini, parser DOM harus menjadi pilihan yang lebih baik tidak peduli kebijakan penilaian apa yang ia adopsi. Dia tidak perlu membuat struktur data sendiri. Apa yang perlu dia lakukan adalah memodifikasi pohon DOM terlebih dahulu (yaitu, menetapkan nilai ke simpul 'kelas') dan kemudian menyimpan seluruh pohon yang dimodifikasi. Jika dia memilih untuk menggunakan SAX parser daripada parser DOM, maka dalam hal ini dia harus membuat struktur data yang hampir sama rumitnya dengan pohon DOM sebelum dia bisa menyelesaikan pekerjaan. tetapi untuk menyimpan dokumen asli kembali dengan nilai setiap siswa diperbarui? Dalam hal ini, parser DOM harus menjadi pilihan yang lebih baik tidak peduli kebijakan penilaian apa yang ia adopsi. Dia tidak perlu membuat struktur data sendiri. Apa yang perlu dia lakukan adalah memodifikasi pohon DOM terlebih dahulu (yaitu, menetapkan nilai ke simpul 'kelas') dan kemudian menyimpan seluruh pohon yang dimodifikasi. Jika dia memilih untuk menggunakan SAX parser daripada parser DOM, maka dalam hal ini dia harus membuat struktur data yang hampir sama rumitnya dengan pohon DOM sebelum dia bisa menyelesaikan pekerjaan. tetapi untuk menyimpan dokumen asli kembali dengan nilai setiap siswa diperbarui? Dalam hal ini, parser DOM harus menjadi pilihan yang lebih baik tidak peduli kebijakan penilaian apa yang ia adopsi. Dia tidak perlu membuat struktur data sendiri. Apa yang perlu dia lakukan adalah memodifikasi pohon DOM terlebih dahulu (yaitu, menetapkan nilai ke simpul 'kelas') dan kemudian menyimpan seluruh pohon yang dimodifikasi. Jika dia memilih untuk menggunakan SAX parser daripada parser DOM, maka dalam hal ini dia harus membuat struktur data yang hampir sama rumitnya dengan pohon DOM sebelum dia bisa menyelesaikan pekerjaan. simpul) dan kemudian menyimpan seluruh pohon yang dimodifikasi. Jika dia memilih untuk menggunakan SAX parser daripada parser DOM, maka dalam hal ini dia harus membuat struktur data yang hampir sama rumitnya dengan pohon DOM sebelum dia bisa menyelesaikan pekerjaan. simpul) dan kemudian menyimpan seluruh pohon yang dimodifikasi. Jika dia memilih untuk menggunakan SAX parser daripada parser DOM, maka dalam hal ini dia harus membuat struktur data yang hampir sama rumitnya dengan pohon DOM sebelum dia bisa menyelesaikan pekerjaan.

Sebuah contoh

Pernyataan masalah : Tulis program Java untuk mengekstrak semua informasi tentang lingkaran yang merupakan elemen dalam dokumen XML yang diberikan. Kami berasumsi bahwa setiap elemen lingkaran memiliki tiga elemen anak (yaitu, x, y dan jari-jari) serta atribut warna. Contoh dokumen diberikan di bawah ini:

<?xml version="1.0"?> 
<!DOCTYPE shapes [
<!ELEMENT shapes (circle)*>
<!ELEMENT circle (x,y,radius)>
<!ELEMENT x (#PCDATA)>
<!ELEMENT y (#PCDATA)>
<!ELEMENT radius (#PCDATA)>
<!ATTLIST circle color CDATA #IMPLIED>
]>

<shapes> 
          <circle color="BLUE"> 
                <x>20</x>
                <y>20</y>
                <radius>20</radius> 
          </circle>
          <circle color="RED" >
                <x>40</x>
                <y>40</y>
                <radius>20</radius> 
          </circle>
</shapes> 

Program dengan DOMparser

import java.io.*;
import org.w3c.dom.*;
import org.apache.xerces.parsers.DOMParser;


public class shapes_DOM {
   static int numberOfCircles = 0;   // total number of circles seen
   static int x[] = new int[1000];   // X-coordinates of the centers
   static int y[] = new int[1000];   // Y-coordinates of the centers  
   static int r[] = new int[1000];   // radius of the circle
   static String color[] = new String[1000];  // colors of the circles 

   public static void main(String[] args) {   

      try{
         // create a DOMParser
         DOMParser parser=new DOMParser();
         parser.parse(args[0]);

         // get the DOM Document object
         Document doc=parser.getDocument();

         // get all the circle nodes
         NodeList nodelist = doc.getElementsByTagName("circle");
         numberOfCircles =  nodelist.getLength();

         // retrieve all info about the circles
         for(int i=0; i<nodelist.getLength(); i++) {

            // get one circle node
            Node node = nodelist.item(i);

            // get the color attribute 
            NamedNodeMap attrs = node.getAttributes();
            if(attrs.getLength() > 0)
               color[i]=(String)attrs.getNamedItem("color").getNodeValue();

            // get the child nodes of a circle node 
            NodeList childnodelist = node.getChildNodes();

            // get the x and y value 
            for(int j=0; j<childnodelist.getLength(); j++) {
               Node childnode = childnodelist.item(j);
               Node textnode = childnode.getFirstChild();//the only text node
               String childnodename=childnode.getNodeName(); 
               if(childnodename.equals("x")) 
                  x[i]= Integer.parseInt(textnode.getNodeValue().trim());
               else if(childnodename.equals("y")) 
                  y[i]= Integer.parseInt(textnode.getNodeValue().trim());
               else if(childnodename.equals("radius")) 
                  r[i]= Integer.parseInt(textnode.getNodeValue().trim());
            }

         }

         // print the result
         System.out.println("circles="+numberOfCircles);
         for(int i=0;i<numberOfCircles;i++) {
             String line="";
             line=line+"(x="+x[i]+",y="+y[i]+",r="+r[i]+",color="+color[i]+")";
             System.out.println(line);
         }

      }  catch (Exception e) {e.printStackTrace(System.err);}

    }

}

Program dengan SAXparser

import java.io.*;
import org.xml.sax.*;
import org.xml.sax.helpers.DefaultHandler;
import org.apache.xerces.parsers.SAXParser;


public class shapes_SAX extends DefaultHandler {

   static int numberOfCircles = 0;   // total number of circles seen
   static int x[] = new int[1000];   // X-coordinates of the centers
   static int y[] = new int[1000];   // Y-coordinates of the centers
   static int r[] = new int[1000];   // radius of the circle
   static String color[] = new String[1000];  // colors of the circles

   static int flagX=0;    //to remember what element has occurred
   static int flagY=0;    //to remember what element has occurred
   static int flagR=0;    //to remember what element has occurred

   // main method 
   public static void main(String[] args) {   
      try{
         shapes_SAX SAXHandler = new shapes_SAX (); // an instance of this class
         SAXParser parser=new SAXParser();          // create a SAXParser object 
         parser.setContentHandler(SAXHandler);      // register with the ContentHandler 
         parser.parse(args[0]);
      }  catch (Exception e) {e.printStackTrace(System.err);}  // catch exeptions
   }

   // override the startElement() method
   public void startElement(String uri, String localName, 
                       String rawName, Attributes attributes) {
         if(rawName.equals("circle"))                      // if a circle element is seen
            color[numberOfCircles]=attributes.getValue("color");  // get the color attribute 

         else if(rawName.equals("x"))      // if a x element is seen set the flag as 1 
            flagX=1;
         else if(rawName.equals("y"))      // if a y element is seen set the flag as 2
            flagY=1;
         else if(rawName.equals("radius")) // if a radius element is seen set the flag as 3 
            flagR=1;
   }

   // override the endElement() method
   public void endElement(String uri, String localName, String rawName) {
         // in this example we do not need to do anything else here
         if(rawName.equals("circle"))                       // if a circle element is ended 
            numberOfCircles +=  1;                          // increment the counter 
   }

   // override the characters() method
   public void characters(char characters[], int start, int length) {
         String characterData = 
             (new String(characters,start,length)).trim(); // get the text

         if(flagX==1) {        // indicate this text is for <x> element 
             x[numberOfCircles] = Integer.parseInt(characterData);
             flagX=0;
         }
         else if(flagY==1) {  // indicate this text is for <y> element 
             y[numberOfCircles] = Integer.parseInt(characterData);
             flagY=0;
         }
         else if(flagR==1) {  // indicate this text is for <radius> element 
             r[numberOfCircles] = Integer.parseInt(characterData);
             flagR=0;
         }
   }

   // override the endDocument() method
   public void endDocument() {
         // when the end of document is seen, just print the circle info 
         System.out.println("circles="+numberOfCircles);
         for(int i=0;i<numberOfCircles;i++) {
             String line="";
             line=line+"(x="+x[i]+",y="+y[i]+",r="+r[i]+",color="+color[i]+")";
             System.out.println(line);
         }
   }


}

Secara praktis: book.xml

<bookstore>
  <book category="cooking">
    <title lang="en">Everyday Italian</title>
    <author>Giada De Laurentiis</author>
    <year>2005</year>
    <price>30.00</price>
  </book>
</bookstore>

• DOM menyajikan dokumen xml sebagai struktur pohon berikut dalam memori.
• DOM adalah standar W3C.
• Pengurai DOM bekerja pada Model Objek Dokumen.
• DOM menempati lebih banyak memori, lebih disukai untuk dokumen XML kecil
• DOM Mudah dinavigasi maju atau mundur.

• SAX menyajikan dokumen xml sebagai berbasis acara seperti start element:abc,end element:abc .
• SAX bukan standar W3C, itu dikembangkan oleh sekelompok pengembang.
• SAX tidak menggunakan memori, lebih disukai untuk dokumen XML besar.
• Navigasi mundur tidak dimungkinkan karena memproses dokumen secara berurutan.
• Peristiwa terjadi pada node / elemen dan memberikan semua sub node (Latin nodus, 'knot').

Dokumen XML ini, ketika melewati parser SAX, akan menghasilkan urutan peristiwa seperti berikut :

start element: bookstore
start element: book with an attribute category equal to cooking
start element: title with an attribute lang equal to en
Text node, with data equal to Everyday Italian
....
end element: title
.....
end element: book
end element: bookstore

DOM Singkatan dari Model Objek Dokumen dan itu mewakili Dokumen XML ke dalam format pohon yang masing-masing elemen mewakili cabang-cabang pohon. DOM Parser membuat representasi In Memory tree dari file XML dan kemudian mem-parsingnya, sehingga membutuhkan lebih banyak memori dan disarankan untuk meningkatkan ukuran tumpukan untuk parser DOM untuk menghindari Java.lang.OutOfMemoryError: java heap space. Parsing file XML menggunakan DOM parser cukup cepat jika file XML kecil tetapi jika Anda mencoba membaca file XML besar menggunakan DOM parser ada lebih banyak kemungkinan bahwa itu akan memakan waktu lama atau bahkan mungkin tidak dapat memuatnya sepenuhnya hanya karena membutuhkan banyak memori untuk membuat XML Dom Tree. Java menyediakan dukungan Parsing DOM dan Anda dapat mengurai file XML di Java menggunakan parser DOM. Kelas DOM ada dalam paket w3c.dom sementara DOM Parser untuk Java ada dalam paket JAXP (Java API untuk XML Parsing).

Parser XML SAX di Jawa

SAX Singkatan dari Simple API for XML Parsing. Ini adalah XML Parsing berbasis acara dan mem-parsing file XML langkah demi langkah yang sangat cocok untuk File XML besar. SAX XML Parser memadamkan acara ketika menemui tag pembuka, elemen atau atribut, dan penguraian berfungsi sesuai. Dianjurkan untuk menggunakan SAX XML parser untuk mem-parsing file xml besar di Jawa karena tidak perlu memuat seluruh file XML di Jawa dan dapat membaca file XML besar di bagian-bagian kecil. Java menyediakan dukungan untuk SAX parser dan Anda dapat mem-parsing semua file xml di Java menggunakan SAX Parser, saya telah membahas contoh membaca file xml menggunakan SAX Parser di sini. Salah satu kelemahan menggunakan SAX Parser di java adalah bahwa membaca file XML di Java menggunakan SAX Parser membutuhkan lebih banyak kode dibandingkan dengan DOM Parser.

Perbedaan antara DOM dan SAX XML Parser

Berikut adalah beberapa perbedaan tingkat tinggi antara DOM parser dan SAX Parser di Jawa:

1) DOM parser memuat seluruh dokumen xml dalam memori sementara SAX hanya memuat sebagian kecil file XML dalam memori.

2) DOM parser lebih cepat daripada SAX karena mengakses seluruh dokumen XML dalam memori.

3) SAX parser di Java lebih cocok untuk file XML besar daripada DOM Parser karena tidak memerlukan banyak memori.

4) parser DOM bekerja pada Model Objek Dokumen sementara SAX adalah parser xml berbasis acara.

Baca selengkapnya: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz2uz1bJQqZ

SAX dan DOM digunakan untuk mem-parsing dokumen XML. Keduanya memiliki kelebihan dan kekurangan dan dapat digunakan dalam pemrograman kami tergantung pada situasinya

SAKSOFON:

1. Parsing simpul demi simpul

2. Tidak menyimpan XML dalam memori

3. Kami tidak dapat menyisipkan atau menghapus simpul

4. Melintasi atas ke bawah

DOM

1. Menyimpan seluruh dokumen XML ke dalam memori sebelum diproses

2. Menempati lebih banyak memori

3. Kami dapat menyisipkan atau menghapus node

4. Lintasi ke segala arah.

Jika kita perlu menemukan simpul dan tidak perlu menyisipkan atau menghapus, kita bisa menggunakan SAX itu sendiri kalau tidak DOM asalkan kita memiliki lebih banyak memori.

1) DOM parser memuat seluruh dokumen XML dalam memori sementara SAX hanya memuat sebagian kecil file XML dalam memori.

2) DOM parser lebih cepat daripada SAX karena mengakses seluruh dokumen XML dalam memori.

3) SAX parser di Java lebih cocok untuk file XML besar daripada DOM Parser karena tidak memerlukan banyak memori.

4) parser DOM bekerja pada Model Objek Dokumen sementara SAX adalah parser XML berbasis acara.

Baca selengkapnya: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz498y3vPFR