Java XML API: we select correctly. StAX: we work with pleasure

Hello!
Despite the decline in the popularity of the XML format since the early 2000s, it has firmly occupied its niche. I came across XML processing in 60% of the projects and dedicated my internship to Masterjava to it. Its most frequent applications are: XHTML, SOAP, various configurations (for example, Tomcat, SoapUI, IntelliJ IDEA, Spring XML configuration), data import and export.

In Java, there are several APIs for working with XML and it is important for a developer to understand which API to choose in each specific situation. In this article, I will briefly list all the Java XML API, their purpose and examples of use, and I’ll dwell more on the work with a rather rare, but in some cases the only true StAX technology. It is assumed that you are already familiar with the elements of XML .

Java XML API: choosing the right

• JAXP (Java API for XML Processing) is a set of APIs (SAX + DOM + DTD + XSLT validation). Xerces and Xalan are standard implementations of these APIs. In addition to XSLT, all APIs are outdated: StAX came to replace SAX, DOM replaced JAXB, DTD replaced XSD.
• DOM and JAXB - API for reading XML completely and getting its application in Java ready objects. For DOM, these are collections of org.w3c.dom.Node interface implementations (attributes, elements, text, ..). For JAXB, a mapping is set, similar to how ORM defines mappings of database tables to Java objects. Those. XML makes ready-made and easy-to-use Java beans. JAXB is the most convenient and frequently used API for working with XML when you need to read all the XML (it should fit in the JVM memory) and perform the required actions with it.
• DTD (deprecated) and XSD are schemas that specify the validation of the XML structure (the order of the elements, the binding or optional element, the presence of attributes on the element). You can bind a schema of the structure verification to XML, and then tools that work with XML (for example, IntelliJ IDEA) can do auto-completion and show schema errors. You can also validate an XML document from within an application. The XSD format is more modern and is itself an XML document.
• XPath query language to XML. Roughly, you can compare it with a SQL query to a database, the code we need to get some specific element (or elements) from XML or count their number . I saw their use, for example, in ESB : data between systems is transmitted in XML format and in the configuration each system through XPath "bites out" from XML the data it needs. XPath is most commonly used when transforming XML.
• XSL, XSLT - convert XML to any other format. One of the applications, for example, is to send a response from the server to the browser in the form of XML and set its XSL transformation to HTML . All modern browsers support XSLT transformations, i.e. on the client side, they themselves transform XML in a given XSL to the required form.
• SAX and StAX are sequential reads from an XML source. The document is read sequentially in chunks (events). The APIs differ from each other in that SAX is based on the push model, and Stax on the pull model. If you once made several consecutive AJAX requests on javascript, then come across a callback hell . Execution of the code is done asynchronously and the code is written not sequentially, but in steps in the return functions. When using SAX, something like this happens: you need to set functions for processing certain events in XML (the beginning of the tag, the end of the tag, the text inside the tag, a comment), and inside these handlers, set new handlers. Working with StAX is much more convenient. We consistently read events from the document, analyze them and process suitable ones. These APIs are used for very large documents, from which lists of objects are read out one by one as they appear in the document, or when we are not interested in the whole document, but its specific part and model of the entire document is not needed.

In the comparative API label on their capabilities, Easy of Use for SAX / StAX says that the author does not know how to work with StAX and the rest of the article will be about how to “prepare it correctly”.
')

StAX: we work with pleasure

First of all, I want to note that you can work with StAX through 2 APIs: a low-level XMLStreamReader , which returns primitives and a high-level XMLEventReader , which returns objects and consumes more memory. Further I will work with XMLStreamReader. Making a wrapper on it will make working with XML simple and convenient. Let's look at a small example: there is a simple XML with cities and users:

  <Payload> <Cities> <City id="spb">-</City> <City id="mow"></City> ... </Cities> ... <Users> <User city="mow"> <email>gmail@gmail.com</email> <fullName>Gmail User</fullName> </User> <User city="spb"> <email>admin@javaops.ru</email> <fullName>Admin</fullName> </User> ... </Users> ... </Payload> 

In reality, this XML may contain hundreds of cities and hundreds of thousands / millions of users. All that is required: print a list of cities. In this case, the StAX API is the only right choice. Add the StaxStreamProcessor helper class to the StaxStreamProcessor :

 public class StaxStreamProcessor implements AutoCloseable { private static final XMLInputFactory FACTORY = XMLInputFactory.newInstance(); private final XMLStreamReader reader; public StaxStreamProcessor(InputStream is) throws XMLStreamException { reader = FACTORY.createXMLStreamReader(is); } public XMLStreamReader getReader() { return reader; } @Override public void close() { if (reader != null) { try { reader.close(); } catch (XMLStreamException e) { // empty } } } } 

Next, we go through XML sequentially, read all the events that are interesting to us and output the required information:

 try (StaxStreamProcessor processor = new StaxStreamProcessor(Files.newInputStream(Paths.get("payload.xml")))) { XMLStreamReader reader = processor.getReader(); while (reader.hasNext()) { // while not end of XML int event = reader.next(); // read next event if (event == XMLEvent.START_ELEMENT && "City".equals(reader.getLocalName())) { System.out.println(reader.getElementText()); } } } 

In order not to constantly duplicate in the program the often repeated code for finding the desired event in XML, we can add it to StaxStreamProcessor :

 public boolean doUntil(int stopEvent, String value) throws XMLStreamException { while (reader.hasNext()) { int event = reader.next(); if (event == stopEvent && value.equals(reader.getLocalName())) { return true; } } return false; } 

It will not be easy, but very easy to use the utility class:

 while (processor.doUntil(XMLEvent.START_ELEMENT, "City")){ System.out.println(reader.getElementText()); } 

The disadvantage of this code is that we absolutely uselessly spend resources on passing hundreds of thousands of unnecessary users to us instead of completing the program. You need to add a condition to stop scanning XML. This is usually the end of the tag of the parent element (in our case Cities ). Add another utility method to StaxStreamProcessor that scans XML either to the end of the parent tag or to a specified element:

 public boolean startElement(String element, String parent) throws XMLStreamException { while (reader.hasNext()) { int event = reader.next(); if (parent != null && event == XMLEvent.END_ELEMENT && parent.equals(reader.getLocalName())) { return false; } if (event == XMLEvent.START_ELEMENT && element.equals(reader.getLocalName())) { return true; } } return false; } 

Add attribute and text reading methods:

 public String getAttribute(String name) throws XMLStreamException { return reader.getAttributeValue(null, name); } public String getText() throws XMLStreamException { return reader.getElementText(); } 

The call code will remain super simple and we will stop processing XML immediately after the end of the Cities tag:

 while (processor.startElement("City", "Cities")) { System.out.println(processor.getAttribute("id") +":" + processor.getText()); } 

StAX API requires accuracy when reading events. If in the output we memorize reading the attribute and text, but the code becomes inoperative: after reading the city name from the XML, the attribute will be left behind and will be unavailable. It should also be remembered that, depending on the current position of the XML, some API read methods from XML are available and others are not available. Using startElement you can get to XML elements of any nesting level and, as necessary, add other utilities to StaxStreamProcessor. I hope that with this approach, working with StAX will seem easy and convenient.

Thank you for your attention and pleasant coding!