Jaka jest różnica między SAX a DOM?

W kilku słowach...

SAX (Simple A PI dlax ML): jest procesorem strumieniowym. W każdej chwili masz tylko małą część pamięci i" wąchasz " strumień XML, implementując kod zwrotny dla zdarzeń takich jak tagStarted() itp. Nie używa prawie żadnej pamięci, ale nie możesz robić rzeczy "DOM", takich jak używanie xpath lub trawersowanie drzew.

DOM (D ocument O bject m odel): ładujesz całość do pamięci - jest to ogromny wieprz pamięci. Możesz wydmuchać pamięć nawet średniej wielkości dokumentami. Ale można użyć xpath i trawersować drzewo itp.

Tutaj w prostszych słowach:

DOM

• Parser modelu drzewa (oparty na obiektach) (drzewo węzłów).

• DOM wczytuje plik do pamięci, a następnie analizuje - plik.

• Ma ograniczenia pamięci, ponieważ ładuje cały plik XML przed parsowaniem.

• DOM jest odczytywany i zapisywany(może wstawiać lub usuwać węzły).

• Jeżeli zawartość XML jest mała, wtedy preferujemy Parser DOM.

• Wyszukiwanie do tyłu i do przodu jest możliwość przeszukiwania tagów i oceny informacje wewnątrz tagów. Daje to łatwość nawigacji.

• Wolniej w czasie pracy.

SAX

• Parser oparty na zdarzeniach (sekwencja zdarzeń).

• SAX parsuje plik w trakcie jego odczytu, tzn. parsuje węzeł po węźle.

• Brak ograniczeń pamięci, ponieważ nie przechowuje zawartości XML w pamięci.

• SAX jest tylko do odczytu tzn. nie można Wstaw lub Usuń węzeł.

• Używaj parsera SAX, gdy zawartość pamięci jest duża.

• SAX odczytuje plik XML od góry do dołu i nawigacja do tyłu nie jest możliwa.

• Szybciej w czasie biegu.

Masz rację w zrozumieniu modelu opartego na DOM. Plik XML zostanie załadowany jako całość, a cała jego zawartość zostanie zbudowana jako reprezentacja drzewa dokumentu w pamięci. Może to być czasochłonne i zużywające pamięć, w zależności od rozmiaru pliku wejściowego. Zaletą tego podejścia jest to,że można łatwo odpytywać dowolną część dokumentu i dowolnie manipulować wszystkimi węzłami w drzewie.

Podejście DOM jest zwykle używane dla małych struktur XML (gdzie małe zależy od tego, ile mocy i pamięci ma twoja platforma) , które mogą wymagać modyfikacji i zapytań na różne sposoby po załadowaniu.

SAX Z drugiej strony jest przeznaczony do obsługi wejścia XML praktycznie dowolnego rozmiaru. Zamiast frameworku XML wykonującego ciężką pracę dla Ciebie w opracowywaniu struktury dokumentu i przygotowywaniu potencjalnie wielu obiektów dla wszystkich węzłów, atrybutów itp., SAX całkowicie pozostawia to tobie.

Co to w zasadzie robi odczytuje wejście od góry i wywołuje metody wywołania zwrotnego, które podajesz, gdy występują pewne "zdarzenia". Zdarzenie może polegać na trafieniu znacznika otwierającego, atrybutu znacznika, znalezieniu tekstu wewnątrz elementu lub natknięciu się na znacznik końcowy.

SAX uparcie czyta wejście i mówi, co widzi w ten sposób. Do ciebie należy utrzymanie wszystkich wymaganych informacji o stanie. Zazwyczaj oznacza to, że zbudujesz jakąś maszynę stanową.

Podczas gdy takie podejście do przetwarzania XML jest dużo bardziej żmudny, może być również bardzo potężny. Wyobraź sobie, że chcesz po prostu wyodrębnić tytuły artykułów z kanału na blogu. Jeśli przeczytasz ten XML używając DOM, załaduje on całą zawartość artykułu, wszystkie obrazy itp. które są zawarte w XML do pamięci, nawet jeśli nie jesteś nawet nim zainteresowany.

Za pomocą SAX możesz po prostu sprawdzić, czy nazwa elementu jest (np.) "title" przy każdym wywołaniu metody zdarzenia "startTag". Jeśli tak, wiesz, że musisz dodać cokolwiek następnego wydarzenie" elementText " oferuje Państwu. Po otrzymaniu wywołania zdarzenia " endTag "ponownie sprawdzasz, czy jest to element zamykający"title". Po tym, po prostu ignorujesz wszystkie dalsze elementy, aż albo wejście się skończy, albo pojawi się kolejny" startTag "z nazwą" title". I tak dalej...

Możesz w ten sposób Odczytać megabajty i megabajty XML, wydobywając tylko niewielką ilość danych, których potrzebujesz.

Negatywną stroną tego podejścia jest oczywiście to, że trzeba wiele więcej samodzielnego księgowania, w zależności od tego, jakie dane trzeba wyodrębnić i jak skomplikowana jest struktura XML. Co więcej, naturalnie nie można modyfikować struktury drzewa XML, ponieważ nigdy nie masz go w ręku jako całości.

Ogólnie rzecz biorąc, SAX nadaje się do przeczesywania potencjalnie dużych ilości danych, które otrzymujesz z myślą o konkretnym "zapytaniu", ale nie musisz go modyfikować, podczas gdy DOM ma na celu zapewnienie pełnej elastyczności w zmienianiu struktury i treści, kosztem wyższego zapotrzebowania na zasoby.

Porównujesz jabłka i gruszki. SAX jest parserem , który parsuje szeregowane struktury DOM. Istnieje wiele różnych parserów, a "oparte na zdarzeniach" odnosi się do metody parsowania.

Może małe podsumowanie jest w porządku:

• document object model (DOM) jest abstrakcyjnym modelem danych, który opisuje hierarchiczną, drzewiastą strukturę dokumentu; drzewo dokumentu składa się z węzłów, a mianowicie węzłów elementu, atrybutu i tekstu (i niektórych innych). Węzły mają rodziców, rodzeństwo i dzieci i mogą być przemierzane, itp., wszystkie rzeczy, do których przywykłeś robiąc JavaScript (który nawiasem mówiąc nie ma nic wspólnego z DOM).

• Struktura DOM może być serializowana , tj. zapisana do pliku, przy użyciu języka znaczników, takiego jak HTML lub XML. Plik HTML lub XML zawiera więc" wypisaną "lub" spłaszczoną " wersję abstrakcyjnego drzewa dokumentów.

• Aby komputer manipulował, a nawet wyświetlał drzewo DOM z pliku, musi deserializować lub parsować, plik i rekonstruować abstrakcyjne drzewo w pamięci. Tutaj wchodzi parsowanie.

Teraz dochodzimy do natury parserów. Jednym ze sposobów analizy byłoby odczytanie całego dokumentu i rekurencyjne zbudowanie struktury drzewa w pamięci, a na koniec ujawnienie całego wyniku użytkownikowi. (Przypuszczam, że można nazwać te parsery "parsery DOM".) To byłoby bardzo przydatne dla użytkownika (myślę, że to właśnie robi parser XML PHP), ale cierpi na problemy ze skalowalnością i staje się bardzo kosztowne dla dużych dokumentów.

Z drugiej strony, parsowanie oparte na zdarzeniach, Jak to robi SAX, patrzy na plik liniowo i po prostu wywołuje wywołania do użytkownika, gdy napotka strukturalną część danych, jak "ten element rozpoczął", "ten element zakończył", "jakiś tekst tutaj", itp. Ma to tę zaletę, że może trwać w nieskończoność bez obawy o rozmiar pliku wejściowego, ale jest o wiele bardziej niskopoziomowy, ponieważ wymaga od użytkownika wykonania całej rzeczywistej pracy przetwarzania (poprzez zapewnienie połączeń zwrotnych). Aby powrócić do pierwotnego pytania, termin "oparte na zdarzeniach" odnosi się do tych parsujących zdarzeń , które parser podnosi podczas przechodzenia przez plik XML.

Artykuł W Wikipedii zawiera wiele szczegółów na temat etapów parsowania saksofonu.

Udzielę ogólnej odpowiedzi na to pytanie:

Odpowiedź na pytania

Dlaczego potrzebujemy parsera XML?

Potrzebujemy parsera XML, ponieważ nie chcemy robić wszystkiego w naszej aplikacji od zera, a potrzebujemy "pomocniczych" programów lub bibliotek, aby zrobić coś bardzo niskiego poziomu, ale bardzo potrzebnego dla nas. Te niskopoziomowe, ale niezbędne rzeczy obejmują sprawdzenie poprawności, walidację dokumentu pod kątem jego DTD lub schematu (tylko do walidacji parserów), rozwiązywania odniesień do znaków, rozumienia sekcji CDATA i tak dalej. Parsery XML są właśnie takimi" pomocniczymi " programami i wykonają wszystkie te zadania. Dzięki parserowi XML jesteśmy chronieni przed wieloma z tych zawiłości i możemy skoncentrować się na programowaniu na wysokim poziomie poprzez API zaimplementowane przez parsery, a tym samym zyskać wydajność programowania.

Który jest lepszy, SAX czy DOM ?

ZARÓWNO SAX jak i Parser DOM mają swoje zalety i wady. To, który z nich jest lepszy, powinno zależeć od charakterystyki Twojej aplikacji (zapoznaj się z kilkoma pytaniami poniżej).

Który parser może uzyskać lepszą prędkość, parsery DOM lub SAX?

Parser saksofonu może uzyskać lepszą prędkość.

Jaka jest różnica między tree-based API a event-based API?

Jaka jest różnica między PARSEREM DOM a PARSEREM SAX?

Parsery DOM i SAX działają na różne sposoby:

• Parser DOM tworzy strukturę drzewa w pamięci z wejścia dokument, a następnie czeka na żądania od klienta. Ale parser saksofonu nie tworzy żadnej wewnętrznej struktury. Zamiast tego zajmuje wystąpienia składników dokumentu wejściowego jako zdarzenia i informuje klient co czyta jak czyta przez Dokument wejściowy. A

• Parser DOM zawsze obsługuje aplikację kliencką z całą dokument bez względu na to, ile jest rzeczywiście potrzebne przez Klienta. Ale Parser SAX obsługuje aplikację kliencką zawsze tylko z kawałkami dokument w dowolnym momencie.

• z PARSEREM DOM, metoda wywołuje w aplikacja kliencka musi być jednoznaczna i tworzy rodzaj łańcucha. Ale z SAX, niektóre pewne metody (Zwykle przesłonięte przez cient) będą być wywoływane automatycznie (domyślnie) w sposób wywołany "oddzwanianie", gdy występują pewne zdarzenia. Metody te nie mają być wywołane jawnie przez klienta, choć możemy zadzwonić oni wyraźnie.

Jak zdecydować, który parser jest dobry?

Najlepiej, aby dobry parser był szybki(oszczędny w czasie), oszczędny w przestrzeni, bogaty w funkcjonalność i łatwy w użyciu. Ale w rzeczywistości żaden z głównych parserów nie ma wszystkich tych funkcji w tym samym czasie. Na przykład Parser DOM jest bogaty w funkcjonalności (ponieważ tworzy drzewo DOM w pamięci i umożliwia wielokrotny dostęp do dowolnej części dokumentu i pozwala modyfikować drzewo DOM), ale jest przestrzeń nieefektywna, gdy dokument jest ogromny, a nauczenie się, jak z nim pracować, zajmuje trochę czasu. Parser SAX jest jednak o wiele bardziej oszczędny w przypadku dużych dokumentów wejściowych (ponieważ nie tworzy wewnętrznej struktury). Co więcej, działa szybciej i jest łatwiejszy do nauczenia się niż Parser DOM, ponieważ jego API jest naprawdę proste. Ale z punktu widzenia funkcjonalności zapewnia mniej funkcji, co oznacza, że sami użytkownicy muszą zadbać o więcej, takich jak tworzenie własnych danych struktury. Przy okazji, co to jest dobry parser? Myślę, że odpowiedź naprawdę zależy od cech aplikacji.

Jakie są realne aplikacje, w których używanie parsera SAX jest korzystne niż używanie parsera DOM i odwrotnie? Jakie są zwykle aplikacja dla parsera DOM i dla parsera SAX?

W następujących przypadkach używanie parsera SAX jest korzystniejsze niż używanie parsera DOM.

• Dokument wejściowy jest zbyt duży, aby był dostępny pamięć (właściwie w tym przypadku saksofon jest twoim jedynym wyborem)
• dokument można przetwarzać w małych sąsiadujących ze sobą fragmentach danych wejściowych. Nie potrzebujesz całego dokumentu, zanim będziesz mógł wykonać użyteczną pracę]}
• po prostu chcesz użyć parsera do wyodrębnienia interesujących Cię informacji, a wszystkie twoje obliczenia będą całkowicie oparte na strukturach danych stworzonych przez Ciebie. W większości naszych aplikacji tworzymy własne struktury danych, które zazwyczaj nie są tak skomplikowane jak Drzewo DOM. Z tego punktu widzenia, myślę, że Szansa użycia parsera DOM jest mniejsza niż użycie parsera SAX.

W następujących przypadkach używanie parsera DOM jest korzystniejsze niż używanie parsera SAX.

• Twoja aplikacja musi mieć dostęp do oddzielnych części dokumentu w tym samym czasie.
• Twoja aplikacja może prawdopodobnie korzystać z wewnętrznej struktury danych, która jest prawie tak skomplikowana, jak sam dokument.
• Twoja aplikacja musi zmodyfikować dokumentować wielokrotnie.
• Twoja aplikacja musi przechowywać dokument przez znaczny czas przez wiele wywołań metod.

Przykład (użyć parsera DOM lub parsera SAX?):

Załóżmy, że instruktor ma dokument XML zawierający wszystkie dane osobowe uczniów, a także punkty, które jego uczniowie uzyskali w swojej klasie, a teraz przydziela uczniom końcowe oceny za pomocą aplikacji. To, co chce wyprodukować, to lista z SSN i stopniami. Zakładamy również, że w swojej aplikacji instruktor nie używa żadnej struktury danych, takiej jak tablice do przechowywania danych osobowych ucznia i punktów. Jeśli instruktor zdecyduje się dać A tym, którzy zdobyli średnią klasową lub wyższą, i dać B pozostałym, to lepiej będzie użyć parsera DOM w swojej aplikacji. Powodem jest to, że nie ma sposobu, aby dowiedzieć się, ile wynosi średnia klasa, zanim cały dokument zostanie przetworzony. Co prawdopodobnie musi zrobić w jego aplikacja polega najpierw na przejrzeniu wszystkich punktów uczniów i obliczeniu średniej, a następnie ponownie przejrzeniu dokumentu i przypisaniu końcowej oceny każdemu uczniowi, porównując zdobyte punkty ze średnią klasową. Jeśli jednak instruktor przyjmuje taką politykę oceniania, że uczniom, którzy zdobyli 90 punktów lub więcej, przypisuje się A, a pozostałym B, to prawdopodobnie lepiej będzie użyć parsera saksofonu. Powodem jest, aby przypisać każdemu uczniowi ocenę końcową, nie musi czekać na Przetworzenie całego dokumentu. Może on natychmiast przypisać ocenę uczniowi, gdy parser saksofonu przeczyta ocenę tego ucznia. W powyższej analizie założyliśmy, że instruktor nie stworzył własnej struktury danych. Co jeśli tworzy własną strukturę danych, taką jak tablica ciągów do przechowywania SSN i tablica liczb całkowitych do sto re punktów ? W tym przypadku, myślę, że saksofon jest lepszym wyborem, zanim to może zaoszczędzić zarówno pamięć i czas, jak również, jeszcze dostać pracę załatwione. Jeszcze jedna uwaga na tym przykładzie. Co zrobić, jeśli instruktor nie chce wydrukować listy, ale zapisać oryginalny dokument ze zaktualizowaną oceną każdego ucznia ? W takim przypadku parser DOM powinien być lepszym wyborem bez względu na to, jaką politykę klasyfikacji przyjmuje. Nie musi tworzyć własnej struktury danych. Musi najpierw zmodyfikować drzewo DOM (tzn. ustawić wartość na węzeł 'grade'), a następnie zapisać całe zmodyfikowane drzewo. Jeśli zdecyduje się na użyj parsera SAX zamiast parsera DOM, wtedy w tym przypadku musi stworzyć strukturę danych, która jest prawie tak skomplikowana jak drzewo DOM, zanim będzie mógł wykonać zadanie.

Przykład

Problem statement: napisz program Java, aby wyodrębnić wszystkie informacje o kręgach będących elementami w danym dokumencie XML. Zakładamy, że każdy element okręgu ma trzy elementy potomne (tj. x, y i promień), a także atrybut koloru. Próbka dokument jest podany poniżej:

<?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 z 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 z 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);
         }
   }


}

W praktyce: książka.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 prezentuje dokument xml jako następującą strukturę drzewa w pamięci.
• DOM jest standardem W3C.
• parser DOM działa na modelu obiektowym dokumentu.
• DOM zajmuje więcej pamięci, preferowany dla małych dokumentów XML
• DOM jest łatwy w nawigacji do przodu lub do tyłu.

• SAX prezentuje dokument xml jako oparty na zdarzeniach jak start element:abc, end element:abc.
• SAX nie jest standardem W3C, został opracowany przez grupę programistów.
• SAX nie używa pamięci, preferowanej dla dużych dokumentów XML.
• nawigacja wstecz nie jest możliwa, ponieważ sekwencyjnie przetwarza dokumenty.
• zdarzenie dzieje się z węzłem / elementem i daje wszystkie węzły podrzędne (łac. nodus, 'węzeł').

Ten dokument XML, po przepuszczeniu przez parser SAX, wygeneruje sekwencję zdarzeń, jak poniżej :

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 oznacza Document Object Model i reprezentuje dokument XML w formacie drzewa, który każdy element reprezentuje gałęzie drzewa. Parser DOM tworzy w drzewie pamięci reprezentację pliku XML, a następnie parsuje go, więc wymaga więcej pamięci i zaleca zwiększenie rozmiaru Sterty Dla parsera DOM w celu uniknięcia Javy.lang.OutOfMemoryError: Java heap space . Parsowanie pliku XML za pomocą DOM parser jest dość szybki, jeśli plik XML jest mały, ale jeśli próbujesz odczytać duży plik XML za pomocą DOM parser jest bardziej prawdopodobne, że zajmie to dużo czasu lub nawet nie będzie w stanie załadować go całkowicie, ponieważ wymaga dużo pamięci do tworzenia drzewa Dom XML. Java zapewnia obsługę parsowania DOM i można parsować pliki XML w Javie za pomocą parsera DOM. Klasy DOM znajdują się w pakiecie W3C.dom, natomiast Parser dom dla Javy znajduje się w pakiecie JAXP (Java API for XML Parsing).

Parser XML SAX w Javie

Sax to skrót od Simple API for XML Parsing. Jest to parsowanie XML oparte na zdarzeniach i to analizuj plik XML krok po kroku tak bardzo odpowiedni dla dużych plików XML. Parser XML sax wywołuje zdarzenie, gdy napotkał otwierający znacznik, element lub atrybut i parsowanie działa odpowiednio. Do parsowania dużych plików XML w Javie zaleca się użycie parsera sax XML, ponieważ nie wymaga on ładowania całego pliku XML w Javie i może odczytywać duży plik XML w małych częściach. Java zapewnia wsparcie dla parsera SAX i możesz parsować dowolny plik xml w Javie za pomocą parsera SAX, omówiłem przykład odczytu pliku xml używanie parsera SAX tutaj. Wadą korzystania z parsera SAX w Javie jest to, że odczyt pliku XML w Javie przy użyciu parsera SAX wymaga więcej kodu w porównaniu z PARSEREM DOM.

Różnica między PARSEREM DOM i SAX XML

Oto kilka różnic pomiędzy PARSEREM DOM i PARSEREM SAX w Javie:

1) Parser DOM ładuje cały dokument xml do pamięci, podczas gdy SAX ładuje tylko małą część pliku XML do pamięci.

2) Parser DOM jest szybszy niż SAX, ponieważ ma dostęp do całego XML dokument w pamięci.

3) parser SAX w Javie lepiej nadaje się do dużych plików XML niż Parser DOM, ponieważ nie wymaga dużo pamięci.

4) parser DOM działa na modelu obiektu dokumentu, podczas gdy SAX jest parserem XML opartym na zdarzeniach.

Czytaj więcej: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz2uz1bJQqZ

Zarówno sax jak i DOM są używane do analizy dokumentu XML. Oba mają zalety i wady i mogą być używane w naszym programowaniu w zależności od sytuacji

SAX:

1. Parses node by node

2. Nie przechowuje XML w pamięci

3. Nie możemy wstawić lub usunąć węzła

4. Przejście od góry do dołu

DOM

1. Zapisuje cały dokument XML do pamięci przed przetwarzanie

2. Zajmuje więcej pamięci

3. Możemy wstawiać lub usuwać węzły

4. Przemierzać w dowolnym kierunku.

Jeśli musimy znaleźć węzeł i nie musimy wstawiać ani usuwać możemy użyć samego SAX ' a w przeciwnym razie DOM pod warunkiem, że mamy więcej pamięci.

1) Parser DOM ładuje cały dokument XML do pamięci, podczas gdy SAX ładuje tylko niewielką część pliku XML do pamięci.

2) Parser DOM jest szybszy niż SAX, ponieważ uzyskuje dostęp do całego dokumentu XML w pamięci.

3) parser SAX w Javie lepiej nadaje się do dużych plików XML niż Parser DOM, ponieważ nie wymaga dużo pamięci.

4) parser DOM działa na modelu obiektu dokumentu, podczas gdy SAX jest parserem XML opartym na zdarzeniach.

Czytaj więcej: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz498y3vPFR