JSON to XML Converter

Converting JSON to XML is a common task, especially when you need to convert data between formats that are used by different systems or applications. JSON and XML are both widely used formats for data interchange, and sometimes you need to transform data from one format to the other to integrate different systems.

There are several ways to convert JSON to XML in Java, using libraries such as Jackson, org.json, and JAXB.

Why Convert JSON to XML?
Interoperability: XML is often used in legacy systems, APIs, or configurations, whereas JSON is more common in modern web APIs.
Data Format Transformation: You might need to convert JSON to XML for data exchange between systems that expect XML.
Data Integration: Converting between JSON and XML can be useful when integrating with third-party services or legacy applications that require one format over the other.
Methods to Convert JSON to XML in Java
Below are a few methods for converting JSON data to XML in Java using popular libraries:

Method 1: Using Jackson
Jackson is one of the most widely used libraries for JSON and XML conversion in Java. It supports converting between various formats, including JSON and XML.

Steps:
Add Jackson Dependencies (for Maven):
xml

<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
<version>2.13.0</version>
</dependency>

<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.13.0</version>
</dependency>
Java Code to Convert JSON to XML Using Jackson:
java

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonToXml {
public static void main(String[] args) {
String jsonString = "{\"id\":1, \"name\":\"John Doe\", \"department\":\"HR\", \"salary\":50000}";

try {
// Create ObjectMapper for JSON
ObjectMapper jsonMapper = new ObjectMapper();

// Read the JSON string into a JsonNode
JsonNode jsonNode = jsonMapper.readTree(jsonString);

// Create XmlMapper for XML conversion
XmlMapper xmlMapper = new XmlMapper();

// Convert JSON to XML
String xmlString = xmlMapper.writeValueAsString(jsonNode);

// Print the XML output
System.out.println(xmlString);
} catch (Exception e) {
e.printStackTrace();
}
}
}
Explanation:

ObjectMapper: Used for reading JSON data into a JsonNode object.
XmlMapper: Used to convert the JsonNode to XML format.
Example Output (XML):

xml

<id>1</id>
<name>John Doe</name>
<department>HR</department>
<salary>50000</salary>
Method 2: Using Gson and org.json
Gson and org.json are simpler alternatives to Jackson for working with JSON. To convert JSON to XML using these libraries, you can combine them with other XML libraries (such as javax.xml or custom methods).

Steps:
Add Gson and org.json Dependencies (for Maven):
xml

<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.8</version>
</dependency>

<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>20210307</version>
</dependency>
Java Code to Convert JSON to XML Using Gson and org.json:
java

import com.google.gson.Gson;
import org.json.JSONObject;
import org.json.XML;

public class JsonToXml {
public static void main(String[] args) {
String jsonString = "{\"id\":1, \"name\":\"John Doe\", \"department\":\"HR\", \"salary\":50000}";

// Convert JSON to org.json JSONObject
JSONObject jsonObject = new JSONObject(jsonString);

// Convert JSONObject to XML string
String xmlString = XML.toString(jsonObject);

// Print the XML output
System.out.println(xmlString);
}
}
Explanation:

Gson is used to handle the JSON data (though it's not directly used for the conversion in this example).
org.json.XML: The XML.toString() method is used to convert the JSONObject to XML format.
Example Output (XML):

xml

<id>1</id>
<name>John Doe</name>
<department>HR</department>
<salary>50000</salary>
Method 3: Using JAXB (Java Architecture for XML Binding)
JAXB is a standard Java API for binding XML schemas and Java objects. While JAXB is typically used to convert Java objects to XML, you can also use it for JSON to XML conversion by first converting the JSON to Java objects and then using JAXB to convert the Java objects to XML.

Steps:
Add JAXB Dependencies (for Maven):
xml

<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.3.1</version>
</dependency>
Java Code to Convert JSON to XML Using JAXB:
java

import com.fasterxml.jackson.databind.ObjectMapper;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;

public class JsonToXml {
public static void main(String[] args) throws Exception {
String jsonString = "{\"id\":1, \"name\":\"John Doe\", \"department\":\"HR\", \"salary\":50000}";

// Step 1: Convert JSON to Java object
ObjectMapper objectMapper = new ObjectMapper();
Employee employee = objectMapper.readValue(jsonString, Employee.class);

// Step 2: Convert Java object to XML
try {
JAXBContext context = JAXBContext.newInstance(Employee.class);
Marshaller marshaller = context.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
marshaller.marshal(employee, System.out);
} catch (JAXBException e) {
e.printStackTrace();
}
}
}

class Employee {
private int id;
private String name;
private String department;
private double salary;

// Getters and Setters
public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getDepartment() {
return department;
}

public void setDepartment(String department) {
this.department = department;
}

public double getSalary() {
return salary;
}

public void setSalary(double salary) {
this.salary = salary;
}
}
Explanation:

ObjectMapper: Converts the JSON data into a Java object (Employee).
JAXBContext: Used to bind the Employee object to XML using JAXB's Marshaller.
Example Output (XML):

xml

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<employee>
<id>1</id>
<name>John Doe</name>
<department>HR</department>
<salary>50000.0</salary>
</employee>
Conclusion
Converting JSON to XML in Java can be accomplished using various libraries. The choice of method depends on your needs and the complexity of the data. Here are the main methods:

Jackson: A powerful library for both JSON and XML processing, great for complex data structures.
Gson + org.json: A simpler approach using Gson to handle the JSON data and org.json.XML for the conversion.
JAXB: Ideal when you need to convert Java objects to XML, especially if you are already using JAXB for XML binding in your project.