Java Convert Large JSON File to XML

In the realm of data processing, the need to convert data from one format to another is a common task. JSON (JavaScript Object Notation) and XML (eXtensible Markup Language) are two popular data interchange formats. JSON is lightweight, easy to read, and widely used in web applications, while XML provides a more structured and self-descriptive format, often used in enterprise systems and legacy applications. When dealing with large JSON files, the conversion to XML can be challenging due to memory limitations. In this blog post, we will explore how to convert large JSON files to XML using Java, covering core concepts, typical usage scenarios, common pitfalls, and best practices.

Table of Contents#

  1. Core Concepts
  2. Typical Usage Scenarios
  3. Common Pitfalls
  4. Best Practices
  5. Code Examples
  6. Conclusion
  7. FAQ
  8. References

Core Concepts#

JSON and XML#

  • JSON: JSON is a text-based data format that uses a simple syntax to represent data objects. It consists of key-value pairs and arrays. For example:
{
    "name": "John",
    "age": 30,
    "hobbies": ["reading", "swimming"]
}
  • XML: XML is a markup language that uses tags to define elements and attributes. It provides a hierarchical structure for data. The equivalent XML for the above JSON would be:
<person>
    <name>John</name>
    <age>30</age>
    <hobbies>
        <hobby>reading</hobby>
        <hobby>swimming</hobby>
    </hobbies>
</person>

Streaming vs. In-Memory Processing#

  • In-Memory Processing: This approach loads the entire JSON file into memory, converts it to an in-memory data structure (like a JSONObject in Java), and then converts it to XML. It is suitable for small to medium-sized files.
  • Streaming Processing: For large files, streaming is a better option. It reads the JSON file incrementally, processes each part, and writes the corresponding XML output without loading the entire file into memory.

Typical Usage Scenarios#

  1. Data Migration: When migrating data from a modern JSON-based system to an older XML-based system.
  2. Integration with Legacy Systems: Many legacy systems still rely on XML for data exchange. Converting JSON data to XML allows seamless integration with these systems.
  3. Data Transformation and Analysis: XML has a rich set of tools for data transformation and analysis. Converting JSON to XML can make it easier to perform complex data processing tasks.

Common Pitfalls#

  1. Memory Issues: Loading a large JSON file into memory can lead to OutOfMemoryError. This is especially true when using in-memory processing approaches.
  2. Encoding and Character Set Issues: JSON and XML may use different character encodings. Incorrect handling of character encodings can result in data corruption.
  3. Namespace and Schema Compatibility: XML has the concept of namespaces and schemas. Ensuring compatibility between the JSON data and the target XML schema can be challenging.

Best Practices#

  1. Use Streaming Libraries: For large files, use streaming libraries like Jackson for JSON and StAX for XML. These libraries allow you to process data incrementally.
  2. Error Handling: Implement proper error handling to deal with issues such as invalid JSON syntax or XML encoding errors.
  3. Testing: Test the conversion process with different types of JSON files, including large and complex ones, to ensure the reliability of the conversion.

Code Examples#

Using Jackson and StAX for Streaming Conversion#

import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
 
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
 
public class LargeJsonToXmlConverter {
 
    public static void convertJsonToXml(File jsonFile, File xmlFile) throws IOException, XMLStreamException {
        JsonFactory jsonFactory = new JsonFactory();
        JsonParser jsonParser = jsonFactory.createParser(new FileInputStream(jsonFile));
 
        XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newInstance();
        XMLStreamWriter xmlWriter = xmlOutputFactory.createXMLStreamWriter(new FileOutputStream(xmlFile));
 
        xmlWriter.writeStartDocument("UTF-8", "1.0");
        processJson(jsonParser, xmlWriter);
        xmlWriter.writeEndDocument();
 
        xmlWriter.close();
        jsonParser.close();
    }
 
    private static void processJson(JsonParser jsonParser, XMLStreamWriter xmlWriter) throws IOException, XMLStreamException {
        JsonToken token;
        while ((token = jsonParser.nextToken()) != null) {
            switch (token) {
                case START_OBJECT:
                    xmlWriter.writeStartElement("object");
                    break;
                case END_OBJECT:
                    xmlWriter.writeEndElement();
                    break;
                case START_ARRAY:
                    xmlWriter.writeStartElement("array");
                    break;
                case END_ARRAY:
                    xmlWriter.writeEndElement();
                    break;
                case FIELD_NAME:
                    String fieldName = jsonParser.getCurrentName();
                    xmlWriter.writeStartElement(fieldName);
                    break;
                case VALUE_STRING:
                    String value = jsonParser.getText();
                    xmlWriter.writeCharacters(value);
                    if (jsonParser.getCurrentToken() == JsonToken.VALUE_STRING) {
                        xmlWriter.writeEndElement();
                    }
                    break;
                case VALUE_NUMBER_INT:
                case VALUE_NUMBER_FLOAT:
                    Number number = jsonParser.getNumberValue();
                    xmlWriter.writeCharacters(number.toString());
                    if (jsonParser.getCurrentToken() != JsonToken.FIELD_NAME) {
                        xmlWriter.writeEndElement();
                    }
                    break;
                case VALUE_TRUE:
                case VALUE_FALSE:
                    boolean boolValue = jsonParser.getBooleanValue();
                    xmlWriter.writeCharacters(Boolean.toString(boolValue));
                    if (jsonParser.getCurrentToken() != JsonToken.FIELD_NAME) {
                        xmlWriter.writeEndElement();
                    }
                    break;
                case VALUE_NULL:
                    xmlWriter.writeEmptyElement("null");
                    if (jsonParser.getCurrentToken() != JsonToken.FIELD_NAME) {
                        xmlWriter.writeEndElement();
                    }
                    break;
            }
        }
    }
 
    public static void main(String[] args) {
        try {
            File jsonFile = new File("large_file.json");
            File xmlFile = new File("output.xml");
            convertJsonToXml(jsonFile, xmlFile);
            System.out.println("Conversion completed successfully.");
        } catch (IOException | XMLStreamException e) {
            e.printStackTrace();
        }
    }
}

In this code:

  • We use Jackson's JsonParser to read the JSON file incrementally.
  • StAX's XMLStreamWriter is used to write the XML output incrementally.
  • The processJson method handles different JSON tokens and writes the corresponding XML elements.

Conclusion#

Converting large JSON files to XML in Java requires careful consideration of memory usage and processing techniques. Streaming processing is the preferred approach for large files, as it avoids memory issues. By following best practices and using appropriate libraries, you can perform the conversion efficiently and reliably.

FAQ#

  1. Can I use other libraries for JSON to XML conversion? Yes, there are other libraries like Gson and JSON - XML converters provided by Apache. However, for large files, Jackson and StAX offer better streaming capabilities.
  2. How can I handle JSON arrays in the conversion process? In the code example, we handle JSON arrays by creating an XML element named array and writing each array element as a child element.
  3. What if the JSON file contains nested objects? The streaming approach can handle nested objects by recursively processing each object and writing the corresponding XML elements.

References#

  1. Jackson Documentation: https://github.com/FasterXML/jackson-docs
  2. StAX Documentation: https://docs.oracle.com/javase/tutorial/jaxp/stax/
  3. JSON Specification: https://www.json.org/json-en.html
  4. XML Specification: https://www.w3.org/TR/xml/
2025-10