Detailed explanation of the principles and performance comparison of four XML parsers

1: DOM

DOM is the official W3C standard for representing XML documents in a platform- and language-independent way. The DOM is a collection of nodes or pieces of information organized in a hierarchical structure. This hierarchy allows developers to search the tree for specific information. Analyzing this structure typically requires loading the entire document and constructing the hierarchy before any work can be done. Because it is based on information hierarchy, the DOM is considered tree-based or object-based. DOM, and tree-based processing in general, has several advantages.
First, because the tree is persistent in memory, it can be modified so that the application can make changes to the data and structure. It also allows navigation up and down the tree at any time, rather than a one-time process like SAX. DOM is also much simpler to use.
On the other hand, for particularly large documents, parsing and loading the entire document can be slow and resource-intensive, so it is better to use other means to process such data. These are event-based models like SAX.

2:SAX

The advantages of this processing are very similar to the advantages of streaming media. Analysis can begin immediately instead of waiting for all data to be processed. Also, since the application just checks the data as it is read, there is no need to store the data in memory. This is a huge advantage for large documents. In fact, the application doesn't even have to parse the entire document; it can stop parsing when a certain condition is met. In general, SAX is also much faster than its replacement, DOM.
　3: Choose DOM or SAX?
　For developers who need to write their own code to process XML documents, choosing the DOM or SAX parsing model is a very important design decision.
　DOM uses a tree structure to access XML documents, while SAX uses an event model.
　The DOM parser converts the XML document into a tree containing its content, and can traverse the tree. The advantage of using DOM to parse the model is that programming is easy. Developers only need to call the tree-building instructions, and then use navigation APIs to access the required tree nodes to complete the task. Elements in the tree can be easily added and modified. However, since the entire XML document needs to be processed when using the DOM parser, the performance and memory requirements are relatively high, especially when encountering large XML files. Due to its traversal capabilities, DOM parsers are often used in services where XML documents need to change frequently.
The SAX parser adopts an event-based model. It can trigger a series of events when parsing XML documents. When a given tag is found, it can activate a callback method to tell the method that the specified tag has been turn up. SAX generally has lower memory requirements because it lets developers decide which tags to process. Especially when developers only need to process part of the data contained in the document, SAX's scalability is better reflected. However, coding is more difficult when using a SAX parser, and it is difficult to access multiple different data in the same document at the same time.

4:JDOM

JDOM is intended to be a Java-specific document model that simplifies interaction with XML and is faster than using the DOM implementation. JDOM has been heavily promoted and promoted since it was the first Java-specific model. It is being considered for eventual use as a "Java Standard Extension" via "Java Specification Request JSR-102". JDOM development has been going on since the early 2000s.
There are two main differences between JDOM and DOM. First, JDOM only uses concrete classes and not interfaces. This simplifies the API in some ways, but also limits flexibility. Second, the API makes heavy use of Collections classes, simplifying usage for Java developers who are already familiar with these classes.
　The JDOM documentation states that its purpose is to "solve 80% (or more) of Java/XML problems using 20% ​​(or less) of the effort" (assuming 20% ​​based on the learning curve). JDOM is certainly useful for most Java/XML applications, and most developers find the API much easier to understand than the DOM. JDOM also includes fairly extensive checks on program behavior to prevent users from doing anything that doesn't make sense in XML. However, it still requires that you understand XML well enough to do more than the basics (or even understand errors in some cases). This may be a more meaningful job than learning DOM or JDOM interfaces.
　JDOM itself does not contain a parser. It typically uses a SAX2 parser to parse and validate input XML documents (although it can also take previously constructed DOM representations as input). It contains converters to output JDOM representations into SAX2 event streams, DOM models, or XML text documents. JDOM is open source released under a variant of the Apache license.

5: DOM4J

Although DOM4J represents a completely independent development result, it was originally an intelligent fork of JDOM. It incorporates many features beyond basic XML document representation, including integrated XPath support, XML Schema support, and event-based processing for large or streaming documents. It also provides options to build document representations with parallel access capabilities through the DOM4J API and standard DOM interfaces. It has been under development since late 2000.
To support all these features, DOM4J uses interfaces and abstract basic class methods. DOM4J makes heavy use of the Collections class in the API, but in many cases it also provides alternatives that allow for better performance or a more straightforward coding approach. The direct benefit is that, although DOM4J pays the price of a more complex API, it provides much greater flexibility than JDOM.
While adding flexibility, XPath integration, and the goal of processing large documents, DOM4J's goals are the same as JDOM: ease of use and intuitive operation for Java developers. It also aims to be a more complete solution than JDOM, achieving the goal of handling essentially all Java/XML problems. It accomplishes this goal with less emphasis than JDOM on preventing incorrect application behavior.
DOM4J is a very, very excellent Java XML API with excellent performance, powerful functions and extreme ease of use. It is also an open source software. Nowadays, you can see that more and more Java software is using DOM4J to read and write XML. It is particularly worth mentioning that even Sun's JAXM is also using DOM4J.
　6: Overview
　JDOM and DOM performed poorly during performance testing, and memory overflowed when testing 10M documents. It's also worth considering using DOM and JDOM in the case of small documents. Although the developers of JDOM have stated that they expect to focus on performance issues before the official release, there is really nothing to recommend it from a performance perspective. In addition, DOM is still a very good choice. DOM implementation is widely used in many programming languages. It is also the basis for many other XML-related standards, and since it is officially recommended by the W3C (as opposed to the non-standard based Java model), it may also be required in certain types of projects (such as in javascript using DOM).
SAX performs better, which depends on its specific parsing method. A SAX detects the incoming XML stream, but does not load it into memory (of course when the XML stream is read, some documents will be temporarily hidden in memory).
Undoubtedly, DOM4J is the best. Currently, DOM4J is widely used in many open source projects. For example, the famous Hibernate also uses DOM4J to read XML configuration files. If portability is not a concern, then use DOM4J!

The above is the detailed content of Detailed explanation of the principles and performance comparison of four XML parsers. For more information, please follow other related articles on the PHP Chinese website!