Método más simple para convertir Json a Xml

Question

Tengo servicio web en .net. Cuando recupero datos de la base de datos, devuelve el archivo JSON en Android Mobile. ¿Cómo puedo convertir archivos JSON a XML o texto?

Answer 1

No hay API de conversión directa disponible en Android para convertir JSON a XML. Primero debe analizar JSON y luego escribir la lógica para convertirlo a xml.

Answer 2

Para una solución simple, recomiendo Jackson, ya que puede transformar JSON arbitrariamente complejo en XML con solo unas pocas líneas simples de código.

import org.codehaus.jackson.map.ObjectMapper; 

import com.fasterxml.jackson.xml.XmlMapper; 

public class Foo 
{ 
    public String name; 
    public Bar bar; 

    public static void main(String[] args) throws Exception 
    { 
    // JSON input: {"name":"FOO","bar":{"id":42}} 
    String jsonInput = "{\"name\":\"FOO\",\"bar\":{\"id\":42}}"; 

    ObjectMapper jsonMapper = new ObjectMapper(); 
    Foo foo = jsonMapper.readValue(jsonInput, Foo.class); 

    XmlMapper xmlMapper = new XmlMapper(); 
    System.out.println(xmlMapper.writeValueAsString(foo)); 
    // <Foo xmlns=""><name>FOO</name><bar><id>42</id></bar></Foo> 
    } 
} 

class Bar 
{ 
    public int id; 
} 

Esta demostración se utiliza Jackson 1.7.7 (la más reciente 1.7.8 También hay que trabajar), Jackson XML Databind 0.5.3 (todavía no compatibles con Jackson 1,8), y Stax2 3.1.1.

Answer 3

La clase org.json.XML estándar convierte entre JSON y XML en ambas direcciones.

La conversión no es muy buena ya que no crea atributos XML (solo entidades), por lo que la salida XML es más voluminosa de lo que podría ser. Pero no requiere definir clases Java que coincidan con las estructuras de datos que deben convertirse.

Answer 4

Aquí hay un ejemplo de cómo puede hacerlo, generando XML válido. También uso la biblioteca Jackson en un proyecto Maven.

instalación de Maven:

<!-- https://mvnrepository.com/artifact/com.fasterxml/jackson-xml-databind --> 
    <dependency> 
     <groupId>com.fasterxml</groupId> 
     <artifactId>jackson-xml-databind</artifactId> 
     <version>0.6.2</version> 
    </dependency> 
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind --> 
    <dependency> 
     <groupId>com.fasterxml.jackson.core</groupId> 
     <artifactId>jackson-databind</artifactId> 
     <version>2.8.6</version> 
    </dependency> 

Aquí hay un código Java que primero convierte una cadena JSON a un objeto y luego convierte el objeto con el XMLMapper a XML y también elimina cualquier nombres de los elementos equivocados. La razón para reemplazar caracteres incorrectos en nombres de elementos XML es el hecho de que puede usar nombres de elementos JSON como $ oid con caracteres no permitidos en XML. La biblioteca de Jackson no explica eso, así que terminé agregando un código que elimina caracteres ilegales de los nombres de los elementos y también las declaraciones del espacio de nombres.

import com.fasterxml.jackson.core.type.TypeReference; 
import com.fasterxml.jackson.databind.ObjectMapper; 
import com.fasterxml.jackson.xml.XmlMapper; 

import java.io.IOException; 
import java.util.Map; 
import java.util.regex.Matcher; 
import java.util.regex.Pattern; 

/** 
* Converts JSON to XML and makes sure the resulting XML 
* does not have invalid element names. 
*/ 
public class JsonToXMLConverter { 

    private static final Pattern XML_TAG = 
      Pattern.compile("(?m)(?s)(?i)(?<first><(/)?)(?<nonXml>.+?)(?<last>(/)?>)"); 

    private static final Pattern REMOVE_ILLEGAL_CHARS = 
      Pattern.compile("(i?)([^\\s=\"'a-zA-Z0-9._-])|(xmlns=\"[^\"]*\")"); 

    private ObjectMapper mapper = new ObjectMapper(); 

    private XmlMapper xmlMapper = new XmlMapper(); 

    String convertToXml(Object obj) throws IOException { 
     final String s = xmlMapper.writeValueAsString(obj); 
     return removeIllegalXmlChars(s); 
    } 

    private String removeIllegalXmlChars(String s) { 
     final Matcher matcher = XML_TAG.matcher(s); 
     StringBuffer sb = new StringBuffer(); 
     while(matcher.find()) { 
      String elementName = REMOVE_ILLEGAL_CHARS.matcher(matcher.group("nonXml")) 
        .replaceAll("").trim(); 
      matcher.appendReplacement(sb, "${first}" + elementName + "${last}"); 
     } 
     matcher.appendTail(sb); 
     return sb.toString(); 
    } 

    Map<String, Object> convertJson(String json) throws IOException { 
     return mapper.readValue(json, new TypeReference<Map<String, Object>>(){}); 
    } 

    public String convertJsonToXml(String json) throws IOException { 
     return convertToXml(convertJson(json)); 
    } 
} 

Aquí está una prueba unitaria para convertJsonToXml:

@Test 
void convertJsonToXml() throws IOException, ParserConfigurationException, SAXException { 
    try(InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream("json/customer_sample.json")) { 
     String json = new Scanner(in).useDelimiter("\\Z").next(); 
     String xml = converter.convertJsonToXml(json); 
     DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); 
     DocumentBuilder db = dbf.newDocumentBuilder(); 
     Document doc = db.parse(new ByteArrayInputStream(xml.getBytes("UTF-8"))); 
     Node first = doc.getFirstChild(); 
     assertNotNull(first); 
     assertTrue(first.getChildNodes().getLength() > 0); 
    } 
}