В чем разница между SAX и DOM?

Я прочитал несколько статей о парсерах XML и наткнулся на SAX и DOM .

SAX основан на событиях, а DOM - это древовидная модель - я не понимаю различий между этими концепциями.

Из того, что я понял, основанный на событиях означает, что какое-то событие происходит с узлом. Например, если щелкнуть конкретный узел, он выдаст все подузлы, а не загрузит все узлы одновременно. Но в случае анализа DOM он загрузит все узлы и создаст модель дерева.

Правильно ли мое понимание?

Пожалуйста, поправьте меня, если я ошибаюсь, или объясните мне основанную на событиях и древовидную модель более простым способом.

Ну, ты рядом.

В SAX, событие срабатывает , когда XML в настоящее время анализируются . Когда синтаксический анализатор анализирует XML и обнаруживает начальный тег (например <something>), он запускает tagStartedсобытие (фактическое имя события может отличаться). Точно так же, когда конец тега встречается во время синтаксического анализа ( </something>), он срабатывает tagEnded. Использование парсера SAX подразумевает, что вам нужно обрабатывать эти события и разбираться в данных, возвращаемых с каждым событием.

В DOM нет событий, запускаемых при разборе. Весь XML анализируется, и генерируется и возвращается дерево DOM (из узлов в XML). После анализа пользователь может перемещаться по дереву для доступа к различным данным, ранее встроенным в различные узлы в XML.

В общем, DOM проще в использовании, но он требует дополнительной обработки всего XML, прежде чем вы сможете его использовать.

В нескольких словах ...

SAX ( S реализовать A PI для X ML): Является ли потоковый процессор на базе. В любой момент у вас есть лишь небольшая часть в памяти, и вы «нюхаете» поток XML, внедряя код обратного вызова для таких событий, как tagStarted()т. Д. Он почти не использует память, но вы не можете выполнять «DOM», например, использовать xpath или traverse. деревья.

DOM ( D ocument O ▪ Таблица M Одел): Вы загружаете все это в память - это массовые боры памяти. Вы можете взорвать память даже с документами среднего размера. Но вы можете использовать xpath и обходить дерево и т. Д.

Вот в более простых словах:

DOM

• Парсер модели дерева (на основе объекта) (дерево узлов).

• DOM загружает файл в память и затем анализирует файл.

• Имеет ограничения памяти, так как он загружает весь XML-файл перед анализом.

• DOM - чтение и запись (можно вставлять или удалять узлы).

• Если содержимое XML невелико, тогда предпочтительнее анализатор DOM.

• Обратный и прямой поиск возможен для поиска тегов и оценки информации внутри тегов. Так что это дает простоту навигации.

• Медленнее во время выполнения.

SAX

• Событийный парсер (последовательность событий).

• SAX анализирует файл, как он читает, то есть анализирует узел за узлом.

• Нет ограничений памяти, поскольку он не хранит содержимое XML в памяти.

• SAX только для чтения, т.е. не может вставить или удалить узел.

• Используйте SAX-парсер, когда объем памяти большой.

• SAX читает файл XML сверху вниз, и обратная навигация невозможна.

• Быстрее во время выполнения.

Вы правы в своем понимании модели на основе DOM. Файл XML будет загружен целиком, а все его содержимое будет построено в виде представления дерева в памяти, представленного в документе. Это может занять много времени и памяти, в зависимости от размера входного файла. Преимущество этого подхода заключается в том, что вы можете легко запрашивать любую часть документа и свободно манипулировать всеми узлами в дереве.

Подход DOM обычно используется для небольших XML-структур (где маленький зависит от того, сколько мощности и памяти имеет ваша платформа), которые могут потребоваться изменить и запросить различными способами после их загрузки.

SAX, с другой стороны, предназначен для обработки XML-ввода практически любого размера. Вместо того, чтобы фреймворк XML выполнял за вас тяжелую работу по выяснению структуры документа и подготовке потенциально большого количества объектов для всех узлов, атрибутов и т. Д., SAX полностью оставляет это за вами.

По сути, он читает входные данные сверху и вызывает методы обратного вызова, которые вы предоставляете, когда происходят определенные «события». Событие может касаться открывающего тега, атрибута в теге, поиска текста внутри элемента или попадания в конечный тег.

SAX упорно читает входной и говорит вам, что он видит в этой моде. Вы должны поддерживать всю необходимую вам информацию о состоянии. Обычно это означает, что вы создадите некий конечный автомат.

Хотя этот подход к обработке XML намного более утомителен, он также может быть очень мощным. Представьте, что вы хотите просто извлечь заголовки новостных статей из блога. Если вы прочитаете этот XML с помощью DOM, он загрузит все содержимое статьи, все изображения и т. Д., Содержащиеся в XML, в память, даже если вы даже не заинтересованы в этом.

С SAX вы можете просто проверять, является ли имя элемента (например) «title» всякий раз, когда вызывается ваш метод события startTag. Если это так, вы знаете, что вам нужно добавить все, что вам предложит следующее событие «elementText». Когда вы получаете вызов события «endTag», вы снова проверяете, является ли это закрывающим элементом «title». После этого вы просто игнорируете все дальнейшие элементы, пока не закончится ввод или не появится другой «startTag» с именем «title». И так далее...

Вы можете читать мегабайты и мегабайты XML таким образом, просто извлекая крошечный объем данных, который вам нужен.

Негативная сторона этого подхода, конечно, заключается в том, что вам нужно гораздо больше вести бухгалтерский учет самостоятельно, в зависимости от того, какие данные вам нужно извлечь и насколько сложна структура XML. Кроме того, вы, естественно, не можете изменить структуру дерева XML, потому что у вас никогда не было его в руках в целом.

Таким образом, в целом SAX подходит для обработки потенциально больших объемов данных, которые вы получаете с учетом конкретного «запроса», но не нуждаетесь в модификации, в то время как DOM больше нацелен на предоставление вам полной гибкости в изменении структуры и содержания за счет более высокого спроса на ресурсы.

Вы сравниваете яблоки и груши. SAX - это анализатор, который анализирует сериализованные структуры DOM. Существует много различных анализаторов, и «основанный на событиях» относится к методу синтаксического анализа.

Может быть, небольшое резюме в порядке:

• Объект модель документа (DOM) , представляет собой абстрактную модель данных , которая описывает иерархическое дерево, на основе структуры документа; дерево документа состоит из узлов , а именно элементов, атрибутов и текстовых узлов (и некоторых других). Узлы имеют родителей, братьев и сестер, детей, их можно обойти и т. Д. - все то, к чему вы привыкли при работе с JavaScript (что, кстати, не имеет ничего общего с DOM).

• Структура DOM может быть сериализована , т.е. записана в файл, используя язык разметки, такой как HTML или XML. Файл HTML или XML, таким образом, содержит «выписанную» или «выровненную» версию абстрактного дерева документов.

• Чтобы компьютер мог манипулировать или даже отображать дерево DOM из файла, он должен десериализовать или проанализировать файл и восстановить абстрактное дерево в памяти. Это где разбор приходит.

Теперь мы приходим к природе парсеров. Одним из способов анализа может быть чтение всего документа и рекурсивное построение древовидной структуры в памяти и, наконец, представление всего результата пользователю. (Я полагаю, вы могли бы назвать эти парсеры «парсерами DOM».) Это было бы очень удобно для пользователя (я думаю, именно это и делает PHP-парсер XML), но оно страдает от проблем с масштабируемостью и становится очень дорогим для больших документов.

С другой стороны, анализ на основе событий , как это делает SAX, смотрит на файл линейно и просто делает обратные вызовы пользователю всякий раз, когда он сталкивается со структурным фрагментом данных, таким как «этот элемент запущен», «этот элемент завершен» , «некоторый текст здесь» и т. д. Преимущество заключается в том, что он может продолжаться вечно, не заботясь о размере входного файла, но он намного более низкоуровневый, поскольку требует, чтобы пользователь выполнял всю фактическую работу по обработке (предоставляя позывные спины). Чтобы вернуться к исходному вопросу, термин «на основе событий» относится к тем событиям синтаксического анализа, которые анализатор вызывает при прохождении XML-файла.

В статье Википедии есть много деталей об этапах синтаксического анализа SAX.

Я дам общий ответ на вопросы и ответы на этот вопрос:

Ответ на вопросы

Зачем нам нужен парсер XML?

Нам нужен синтаксический анализатор XML, потому что мы не хотим делать все в нашем приложении с нуля, и нам нужны некоторые «вспомогательные» программы или библиотеки для выполнения чего-то очень низкого уровня, но очень необходимого для нас. Эти низкоуровневые, но необходимые вещи включают проверку правильности формы, проверку документа по его DTD или схеме (только для проверки парсеров), разрешение ссылок на символы, понимание разделов CDATA и так далее. XML-парсеры - просто такие «вспомогательные» программы, и они будут выполнять все эти работы. С парсером XML мы защищены от многих этих сложностей, и мы могли бы сосредоточиться на простом программировании на высоком уровне через API, реализованный синтаксическими анализаторами, и таким образом повысить эффективность программирования.

Какой из них лучше, SAX или DOM?

Как SAX, так и DOM-парсер имеют свои преимущества и недостатки. Какой из них лучше, зависит от характеристик вашего приложения (см. Некоторые вопросы ниже).

Какой парсер может получить лучшую скорость, DOM или SAX парсеры?

SAX-парсер может получить лучшую скорость.

В чем разница между API на основе дерева и API на основе событий?

API на основе дерева сосредоточен вокруг древовидной структуры и, следовательно, предоставляет интерфейсы для компонентов дерева (который является документом DOM), таких как интерфейс документа, интерфейс узла, интерфейс NodeList, интерфейс элемента, интерфейс Attr и так далее. Однако API на основе событий предоставляет интерфейсы для обработчиков. Существует четыре интерфейса обработчиков, интерфейс ContentHandler, интерфейс DTDHandler, интерфейс EntityResolver и интерфейс ErrorHandler.

В чем разница между DOM Parser и SAX Parser?

Парсеры DOM и SAX работают по-разному:

• Анализатор DOM создает древовидную структуру в памяти из входного документа и затем ожидает запросы от клиента. Но парсер SAX не создает никакой внутренней структуры. Вместо этого он принимает в качестве событий компоненты входного документа и сообщает клиенту, что он читает, когда он читает входной документ.

• Парсер DOM всегда предоставляет клиентскому приложению весь документ, независимо от того, сколько на самом деле нужно клиенту. Но парсер SAX обслуживает клиентское приложение всегда только с частями документа в любой момент времени.

• При использовании синтаксического анализатора DOM вызовы методов в клиентском приложении должны быть явными и образовывать некую цепочку. Но с SAX некоторые определенные методы (обычно переопределяемые cient) будут вызываться автоматически (неявно) способом, который называется «обратным вызовом», когда происходят некоторые определенные события. Эти методы не должны вызываться явно клиентом, хотя мы могли бы вызывать их явно.

Как мы решаем, какой парсер хорош?

В идеале хороший синтаксический анализатор должен быть быстрым (экономичным по времени), компактным, функциональным и простым в использовании. Но в действительности ни один из основных анализаторов не обладает всеми этими функциями одновременно. Например, синтаксический анализатор DOM обладает широкими функциональными возможностями (поскольку он создает дерево DOM в памяти и позволяет многократно обращаться к любой части документа, а также позволяет изменять дерево DOM), но он неэффективен в случае большого размера документа. и это займет немного времени, чтобы научиться работать с ним. Парсер SAX, однако, намного более экономит место в случае большого входного документа (потому что он не создает внутренней структуры). Более того, он работает быстрее и его легче изучать, чем DOM Parser, потому что его API действительно прост. Но с точки зрения функциональности, он предоставляет меньше функций, которые означают, что сами пользователи должны заботиться о большем, например, создавать свои собственные структуры данных. Кстати, что такое хороший парсер? Я думаю, что ответ действительно зависит от характеристик вашего приложения.

В каких реальных приложениях SAX-парсер выгоднее, чем DOM-парсер и наоборот? Каковы обычные приложения для парсера DOM и парсера SAX?

В следующих случаях использование парсера SAX выгоднее, чем парсера DOM.

• Входной документ слишком велик для доступной памяти (фактически в этом случае SAX - ваш единственный выбор)
• Вы можете обрабатывать документ небольшими непрерывными порциями ввода. Вам не нужен весь документ, прежде чем вы сможете сделать полезную работу
• Вы просто хотите использовать анализатор для извлечения интересующей информации, и все ваши вычисления будут полностью основаны на структурах данных, созданных вами. На самом деле в большинстве наших приложений мы создаем собственные структуры данных, которые обычно не так сложны, как дерево DOM. В этом смысле, я думаю, вероятность использования DOM-парсера меньше, чем у SAX-парсера.

В следующих случаях использование парсера DOM выгоднее, чем парсера SAX.

• Ваше приложение должно иметь доступ к отдельным частям документа одновременно.
• Ваше приложение может использовать внутреннюю структуру данных, которая почти так же сложна, как и сам документ.
• Ваша заявка должна повторно изменить документ.
• Ваше приложение должно хранить документ в течение значительного периода времени посредством множества вызовов методов.

Пример (Использовать анализатор DOM или SAX?):

Предположим, что у инструктора есть XML-документ, содержащий всю личную информацию учеников, а также баллы, которые его ученики сделали в своем классе, и теперь он назначает ученикам итоговые оценки с помощью приложения. То, что он хочет произвести, является списком с SSN и оценками. Также мы предполагаем, что в своем приложении инструктор не использует структуру данных, такую ​​как массивы, для хранения личной информации ученика и баллов. Если инструктор решит дать A тем, кто получил средний балл или выше, а B другим, тогда ему лучше использовать анализатор DOM в своем приложении. Причина в том, что он не может узнать, сколько в среднем по классу, до обработки всего документа. Что он, вероятно, должен сделать в своем заявлении, это сначала просмотреть все студенты баллы и вычислите среднее значение, а затем снова просмотрите документ и назначьте итоговую оценку каждому ученику, сравнив баллы, которые он заработал, со средним в классе. Однако, если преподаватель принимает такую ​​политику оценки, что ученикам, набравшим 90 или более баллов, присваиваются баллы А, а другим присваиваются баллы Б, тогда, вероятно, ему лучше использовать синтаксический анализатор SAX. Причина в том, что для того, чтобы назначить каждому ученику итоговую оценку, ему не нужно ждать обработки всего документа. Он может сразу назначить оценку студенту, когда парсер SAX прочитает оценку этого студента. В приведенном выше анализе мы предположили, что инструктор не создал собственную структуру данных. Что если он создаст свою собственную структуру данных, такую ​​как массив строк для хранения SSN и массив целых чисел для хранения точек? В таком случае, Я думаю, что SAX - лучший выбор, прежде чем он мог бы сэкономить как память, так и время, но выполнить работу. Ну, еще одно соображение на этом примере. Что если преподаватель хочет не распечатать список, а сохранить исходный документ с обновленной оценкой каждого учащегося? В этом случае анализатор DOM должен быть лучшим выбором, независимо от того, какую политику оценки он принимает. Ему не нужно создавать какую-либо собственную структуру данных. Ему нужно сначала изменить дерево DOM (т.е. установить значение для узла 'grade'), а затем сохранить все измененное дерево. Если он решит использовать парсер SAX вместо парсера DOM, то в этом случае он должен создать структуру данных, которая почти так же сложна, как дерево DOM, прежде чем он сможет выполнить свою работу. все же сделай работу. Ну, еще одно соображение на этом примере. Что если преподаватель хочет не распечатать список, а сохранить исходный документ с обновленной оценкой каждого учащегося? В этом случае анализатор DOM должен быть лучшим выбором, независимо от того, какую политику оценки он принимает. Ему не нужно создавать какую-либо собственную структуру данных. Ему нужно сначала изменить дерево DOM (т.е. установить значение для узла 'grade'), а затем сохранить все измененное дерево. Если он решит использовать парсер SAX вместо парсера DOM, то в этом случае он должен создать структуру данных, которая почти так же сложна, как дерево DOM, прежде чем он сможет выполнить свою работу. все же сделай работу. Ну, еще одно соображение на этом примере. Что если преподаватель хочет не распечатать список, а сохранить исходный документ с обновленной оценкой каждого учащегося? В этом случае анализатор DOM должен быть лучшим выбором, независимо от того, какую политику оценки он принимает. Ему не нужно создавать какую-либо собственную структуру данных. Ему нужно сначала изменить дерево DOM (т.е. установить значение для узла 'grade'), а затем сохранить все измененное дерево. Если он решит использовать парсер SAX вместо парсера DOM, то в этом случае он должен создать структуру данных, которая почти так же сложна, как дерево DOM, прежде чем он сможет выполнить свою работу. но сохранить исходный документ обратно с обновленной оценкой каждого студента? В этом случае анализатор DOM должен быть лучшим выбором, независимо от того, какую политику оценки он принимает. Ему не нужно создавать какую-либо собственную структуру данных. Ему нужно сначала изменить дерево DOM (т.е. установить значение для узла 'grade'), а затем сохранить все измененное дерево. Если он решит использовать парсер SAX вместо парсера DOM, то в этом случае он должен создать структуру данных, которая почти так же сложна, как дерево DOM, прежде чем он сможет выполнить свою работу. но сохранить исходный документ обратно с обновленной оценкой каждого студента? В этом случае анализатор DOM должен быть лучшим выбором, независимо от того, какую политику оценки он принимает. Ему не нужно создавать какую-либо собственную структуру данных. Ему нужно сначала изменить дерево DOM (т.е. установить значение для узла 'grade'), а затем сохранить все измененное дерево. Если он решит использовать парсер SAX вместо парсера DOM, то в этом случае он должен создать структуру данных, которая почти так же сложна, как дерево DOM, прежде чем он сможет выполнить свою работу. узел), а затем сохранить все измененное дерево. Если он решит использовать парсер SAX вместо парсера DOM, то в этом случае он должен создать структуру данных, которая почти так же сложна, как дерево DOM, прежде чем он сможет выполнить свою работу. узел), а затем сохранить все измененное дерево. Если он решит использовать парсер SAX вместо парсера DOM, то в этом случае он должен создать структуру данных, которая почти так же сложна, как дерево DOM, прежде чем он сможет выполнить свою работу.

Пример

Постановка проблемы : Напишите программу на Java для извлечения всей информации о кругах, которые являются элементами в данном документе XML. Мы предполагаем, что каждый элемент круга имеет три дочерних элемента (то есть x, y и радиус), а также атрибут цвета. Пример документа приведен ниже:

<?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> 

Программа с 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);}

    }

}

Программа с 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);
         }
   }


}

На практике: 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 представляет XML-документ в виде следующей древовидной структуры в памяти.
• DOM - это стандарт W3C.
• Парсер DOM работает на объектной модели документа.
• DOM занимает больше памяти, предпочтительнее для небольших XML-документов
• DOM легко перемещаться вперед или назад.

• SAX представляет документ XML как события на основе как start element:abc, end element:abc.
• SAX не является стандартом W3C, он был разработан группой разработчиков.
• SAX не использует память, предпочтительнее для больших XML-документов.
• Обратная навигация невозможна, поскольку она последовательно обрабатывает документы.
• Событие происходит с узлом / элементом и дает все подузлы (латинский nodus, 'knot').

Этот XML-документ при передаче через SAX-анализатор будет генерировать последовательность событий, подобную следующей :

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 обозначает объектную модель документа и представляет документ XML в виде дерева, каждый элемент которого представляет ветви дерева. DOM Parser создает представление XML-файла в памяти и затем анализирует его, поэтому ему требуется больше памяти и рекомендуется увеличить размер кучи для DOM-анализатора, чтобы избежать Java.lang.OutOfMemoryError: пространство кучи java. Синтаксический анализ XML-файла с использованием DOM-парсера довольно быстрый, если XML-файл небольшой, но если вы пытаетесь прочитать большой XML-файл с помощью DOM-анализатора, есть больше шансов, что это займет много времени или даже может оказаться невозможным его полной загрузки, потому что для создания XML Dom Tree требуется много памяти. Java поддерживает синтаксический анализ DOM, и вы можете анализировать XML-файлы в Java с помощью анализатора DOM. DOM-классы находятся в пакете w3c.dom, а DOM Parser для Java - в пакете JAXP (Java API для синтаксического анализа XML).

SAX XML Parser в Java

SAX означает простой API для разбора XML. Это синтаксический анализ XML, основанный на событиях, и он шаг за шагом анализирует XML-файл, настолько подходящий для больших XML-файлов. SAX XML Parser запускает событие, когда встречается открывающий тег, элемент или атрибут, и синтаксический анализ работает соответственно. Рекомендуется использовать синтаксический анализатор SAX XML для анализа больших XML-файлов в Java, поскольку он не требует загрузки всего XML-файла в Java и может читать большой XML-файл небольшими частями. Java обеспечивает поддержку SAX-парсера, и вы можете анализировать любой XML-файл в Java с помощью SAX-парсера. Я рассмотрел пример чтения XML-файла с использованием SAX-парсера здесь. Одним из недостатков использования SAX Parser в Java является то, что для чтения XML-файла в Java с использованием SAX Parser требуется больше кода по сравнению с DOM Parser.

Разница между DOM и SAX XML Parser

Вот несколько различий высокого уровня между парсером DOM и парсером SAX в Java:

1) DOM-парсер загружает весь XML-документ в память, в то время как SAX загружает только небольшую часть XML-файла в память.

2) DOM-парсер работает быстрее, чем SAX, потому что он обращается ко всему XML-документу в памяти.

3) SAX-парсер в Java лучше подходит для больших XML-файлов, чем DOM-парсер, потому что он не требует много памяти.

4) DOM-парсер работает с объектной моделью документа, в то время как SAX - это xml-анализатор, основанный на событиях.

Подробнее: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz2uz1bJQqZ

И SAX, и DOM используются для анализа XML-документа. Оба имеют свои преимущества и недостатки и могут быть использованы в нашем программировании в зависимости от ситуации

SAX:

1. Анализирует узел за узлом

2. Не хранит XML в памяти

3. Мы не можем вставить или удалить узел

4. Перемещение сверху вниз

DOM

1. Сохраняет весь XML-документ в памяти перед обработкой

2. Занимает больше памяти

3. Мы можем вставить или удалить узлы

4. Траверс в любом направлении.

Если нам нужно найти узел и не нужно вставлять или удалять, мы можем использовать сам SAX, иначе DOM, если у нас больше памяти.

1) DOM-парсер загружает весь XML-документ в память, в то время как SAX загружает только небольшую часть XML-файла в память.

2) DOM-парсер работает быстрее, чем SAX, потому что он обращается ко всему XML-документу в памяти.

3) SAX-парсер в Java лучше подходит для больших XML-файлов, чем DOM-парсер, потому что он не требует много памяти.

4) Парсер DOM работает на объектной модели документов, в то время как SAX - это парсер XML на основе событий.

Подробнее: http://javarevisited.blogspot.com/2011/12/difference-between-dom-and-sax-parsers.html#ixzz498y3vPFR