XmlStreamReader

07/02/2023

Although the XML format is not as commonly used as it once was, it is still an efficient way to work with XML data in Salesforce, especially when dealing with large quantities. In this article, we will dive into the capabilities of the XmlStreamReader class and how it can be used to perform different operations with this markup language.

What is the XmlStreamReader class in Apex and why would I use it?

The XmlStreamReader class allows you to read and parse XML data in a streaming manner, rather than loading the entire document into memory at once. This can be useful if you are working with large XML documents, as it allows you to process the data incrementally and avoid running out of memory.

By using this class, you have access to a number of methods that allow you to easily navigate and extract data from the XML document. For instance, you can move to specific elements and attributes, and read the text content of elements.

Operations that can be performed with XmlStreamReader

As we have just seen, XmlStreamReader is quite a powerful class when it comes to handling data in XML format. Here are some of the operations that can be performed with this Apex class:

XML data can be parsed via the XmlStreamReader class, which also offers a stream-based API for reading the data. Instead of loading the complete XML document into memory, this enables you to read the XML data one piece at a time.
Several methods for navigating through the XML data are provided by the XmlStreamReader class, including next(), nextTag(), hasNext(), and getElementText (). These techniques let you navigate the XML data and get to particular components and attributes.
Validation: XML data can be checked against a schema using the XmlStreamReader class to make sure it adheres to a predetermined structure. This can be helpful for making sure that the XML data is well-formed and has all of the anticipated elements and attributes.
Event handling: The XmlEvent class, which offers an event-based API for working with XML data, can be used in conjunction with the XmlStreamReader class. This enables you to handle particular events and take appropriate action in response to them, such as the beginning and end of elements.
XML can be loaded and saved using the fromXml() and toXml() methods provided by the XmlStreamReader class (). You can read or write XML data from a string, file, or input/output stream using these techniques.
Reading the attribute and element values: to read the current element attribute and value, use getElementText() and getAttributeValue() methods respectively.

XmlStreamReader Considerations

In this section, we will list some of the best practices and considerations so that you can ensure that your code is efficient, maintainable, and effective when using the XmlStreamReader class.

Make sure to use the stream-based API: To read and parse XML data, the XmlStreamReader class offers a stream-based API. Instead of loading the complete XML document into memory, this enables you to read the XML data one piece at a time. When working with huge XML documents, this can be extremely helpful because it enables you to manage the data more effectively and prevent memory problems.
Validate your XML data: The XmlStreamReader class offers validation features that let you check your XML data against a schema to make sure it follows a preset structure. By doing this, you may help prevent unexpected behaviour and problems.
Handle events: The XmlEvent class, which offers an event-based API for working with XML data, can be used in conjunction with the XmlStreamReader class to handle events. This enables you to handle particular events and take appropriate action in response to them, such as the beginning and end of elements.
Use the right methods: Several methods for navigating through the XML data are provided by the XmlStreamReader class, including next(), nextTag(), hasNext(), and getElementText (). These techniques let you navigate the XML data and get to particular components and attributes. Use the appropriate technique for the job at hand to maintain the clarity and effectiveness of your code.
Keep in mind the API version: The available endpoints and functionality may vary based on the version of the API being accessed because the API endpoints are versioned. Verify that you are utilising the appropriate API version for your use case.

Exceptions and errors

When working with this class, as in all Apex, it is important to handle errors and exceptions properly to ensure the stability and reliability of the code. Here are a few key points to keep in mind:

XmlExceptions: When interacting with erroneous or improperly formatted XML data, the XmlStreamReader class may throw an XmlException. An XmlException will be thrown, for instance, if the XML document is not well-formed or if it does not adhere to the schema. It’s crucial to catch this exception and respond correctly, such as by informing the user of the error or logging it for investigation.
If the XML data given to the XmlStreamReader class is null or empty, it may also raise a NullPointerException. The data must be verified before being sent to the XmlStreamReader class, and this exception must be handled appropriately.
Limit Exceptions: The XMLStreamReader class has a 2,000,000 character limit; if the XML data provided to it exceeds this limit, a LimitException is thrown. Before supplying the XML data to the XmlStreamReader class, it is crucial to determine the size of the data and handle this exception appropriately.

Example

Jumping to the most important part of this article, in this section we are going to showcase the use of the XmlParserClass with an XML file containing different books, along with their specifications. This XML file will be parsed thanks to a parser built with Apex, which implements the XmlStreamReader class.

Operations that can be performed with XmlStreamReader

As we have just seen, XmlStreamReader is quite a powerful class when it comes to handling data in XML format. Here are some of the operations that can be performed with this Apex class:

XML data can be parsed via the XmlStreamReader class, which also offers a stream-based API for reading the data. Instead of loading the complete XML document into memory, this enables you to read the XML data one piece at a time.
Several methods for navigating through the XML data are provided by the XmlStreamReader class, including next(), nextTag(), hasNext(), and getElementText (). These techniques let you navigate the XML data and get to particular components and attributes.
Validation: XML data can be checked against a schema using the XmlStreamReader class to make sure it adheres to a predetermined structure. This can be helpful for making sure that the XML data is well-formed and has all of the anticipated elements and attributes.
Event handling: The XmlEvent class, which offers an event-based API for working with XML data, can be used in conjunction with the XmlStreamReader class. This enables you to handle particular events and take appropriate action in response to them, such as the beginning and end of elements.
XML can be loaded and saved using the fromXml() and toXml() methods provided by the XmlStreamReader class (). You can read or write XML data from a string, file, or input/output stream using these techniques.
Reading the attribute and element values: to read the current element attribute and value, use getElementText() and getAttributeValue() methods respectively.

XmlStreamReader Considerations

In this section, we will list some of the best practices and considerations so that you can ensure that your code is efficient, maintainable, and effective when using the XmlStreamReader class.

Make sure to use the stream-based API: To read and parse XML data, the XmlStreamReader class offers a stream-based API. Instead of loading the complete XML document into memory, this enables you to read the XML data one piece at a time. When working with huge XML documents, this can be extremely helpful because it enables you to manage the data more effectively and prevent memory problems.
Validate your XML data: The XmlStreamReader class offers validation features that let you check your XML data against a schema to make sure it follows a preset structure. By doing this, you may help prevent unexpected behaviour and problems.
Handle events: The XmlEvent class, which offers an event-based API for working with XML data, can be used in conjunction with the XmlStreamReader class to handle events. This enables you to handle particular events and take appropriate action in response to them, such as the beginning and end of elements.
Use the right methods: Several methods for navigating through the XML data are provided by the XmlStreamReader class, including next(), nextTag(), hasNext(), and getElementText (). These techniques let you navigate the XML data and get to particular components and attributes. Use the appropriate technique for the job at hand to maintain the clarity and effectiveness of your code.
Keep in mind the API version: The available endpoints and functionality may vary based on the version of the API being accessed because the API endpoints are versioned. Verify that you are utilising the appropriate API version for your use case.

Exceptions and errors

When working with this class, as in all Apex, it is important to handle errors and exceptions properly to ensure the stability and reliability of the code. Here are a few key points to keep in mind:

XmlExceptions: When interacting with erroneous or improperly formatted XML data, the XmlStreamReader class may throw an XmlException. An XmlException will be thrown, for instance, if the XML document is not well-formed or if it does not adhere to the schema. It’s crucial to catch this exception and respond correctly, such as by informing the user of the error or logging it for investigation.
If the XML data given to the XmlStreamReader class is null or empty, it may also raise a NullPointerException. The data must be verified before being sent to the XmlStreamReader class, and this exception must be handled appropriately.
Limit Exceptions: The XMLStreamReader class has a 2,000,000 character limit; if the XML data provided to it exceeds this limit, a LimitException is thrown. Before supplying the XML data to the XmlStreamReader class, it is crucial to determine the size of the data and handle this exception appropriately.

Example

<catalog>
  <book id="bk101">

     <author>Gambardella, Matthew</author>

     <genre>Computer</genre>

     <price>44.95</price>

     <publish_date>2000-10-01</publish_date>

     <description>An in-depth look at creating applications

     with XML.</description>

  </book>

  <book id="bk102">

     <author>Ralls, Kim</author>

     
<title>Midnight Rain</title>


     <genre>Fantasy</genre>

     <price>5.95</price>

     <publish_date>2000-12-16</publish_date>

     <description>A former architect battles corporate zombies,

     an evil sorceress, and her own childhood to become queen

     of the world.</description>

  </book>

  <book id="bk103">

     <author>Corets, Eva</author>
     
     
<title>Maeve Ascendant</title>


     <genre>Fantasy</genre>

     <price>5.95</price>

     <publish_date>2000-11-17</publish_date>

     <description>After the collapse of a nanotechnology

     society in England, the young survivors lay the

     foundation for a new society.</description>

  </book>

</catalog>


public class BookParser {

 public List<book> parse(String xmlString) {

   List<book> books = new List<book>();

   XmlStreamReader reader = new XmlStreamReader(xmlString);

   while (reader.hasNext()) {

     XmlEvent event = reader.nextEvent();

     if (event.getEventType() == XmlEventType.START_ELEMENT && event.getName() == 'book') {

       Book book = new Book();

       book.id = event.getAttributeByName('id').getValue();

       while (reader.hasNext()) {

         event = reader.nextEvent();

       if (event.getEventType() == XmlEventType.START_ELEMENT) {

         String elementName = event.getName();

       if (elementName == 'author') {

         book.author = reader.getElementText();

       } else if (elementName == 'title') {

         book.title = reader.getElementText();

       } else if (elementName == 'genre') {

         book.genre = reader.getElementText();

       } else if (elementName == 'price') {

         book.price = Double.valueOf(reader.getElementText());

       } else if (elementName == 'publish_date') {

         book.publishDate = Date.valueOf(reader.getElementText());

       } else if (elementName == 'description') {

         book.description = reader.getElementText();

       }

       } else if (event.getEventType() == XmlEventType.END_ELEMENT && event.getName() == 'book') {

         books.add(book);

       break;

       }

      }

    }

  }

 return books;

}
</book></book></book>


public class Book {

   public String id;

   public String author;

   public String title;

   public String genre;

   public Double price;

   public Date publishDate;

   public String description;

 }

Summary

As we have seen in this article, the XmlStreamReader class provides usage for reading and parsing XML documents. This article was aimed at being a short review of this handy feature, which allows us, developers, to have a way of handling large XML documents. It also ensures that the data conforms to a predefined structure, by validating that XML data against a schema.

This class is definitely a powerful tool for working with XML data. By highlighting the main characteristics and best practices, along with an example, one can greatly improve the ability to create robust and scalable Apex applications.Xml