XMLStreamWriter: indentation

Question

¿Realmente no hay forma de escribir directamente XML formateado usando javax.xml.stream.XMLStreamWriter (Java SE 6) ??? Esto es realmente increíble, ya que otras API XML como JAXB y algunas bibliotecas DOM pueden hacer esto. Incluso el .NET XMLStreamWriter equivalente es capaz de este AFAIK (si mal no recuerdo la clase es System.Xml.XmlTextWriter).

Esto significa que la única opción que tengo es volver a analizar el XML para generar una salida formateada ??

ej .:

  StringWriter sw = new StringWriter(); 
    XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newFactory(); 
    XMLStreamWriter xmlStreamWriter = xmlOutputFactory.createXMLStreamWriter(sw); 
    writeXml(xmlStreamWriter); 
    xmlStreamWriter.flush(); 
    xmlStreamWriter.close(); 

    TransformerFactory factory = TransformerFactory.newInstance(); 

    Transformer transformer = factory.newTransformer(); 
    transformer.setOutputProperty(OutputKeys.INDENT, "yes"); 
    transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4"); 

    StringWriter formattedStringWriter = new StringWriter(); 
    transformer.transform(new StreamSource(new StringReader(sw.toString())), new StreamResult(formattedStringWriter)); 
    System.out.println(formattedStringWriter); 

El problema de esta solución es la propiedad "{http://xml.apache.org/xslt}indent-amount". No encontré ninguna documentación al respecto y no parece garantizarse que sea portátil.

¿Qué otras opciones tengo, si quiero hacer esto con las clases estándar de Java 6? ¿Cree un gráfico de objetos JAXB o DOM solo para una bonita impresión?

Answer 1

Puede agregar el código necesario para formatear su documento en su método writeXml. Simplemente mantenga un contador de profundidad (para indicar los niveles de anidación). Luego, antes de escribirStartElement y después de escribirEndElement, use el índice de profundidad para insertar una sangría.

for(int x=0; x<depth; x++) { 
    xmlStreamWriter.writeCharacters(" "); 
} 

Answer 2

Tiene razón en que las interfaces estándar java.xml proporcionan poco o ningún control sobre la serialización, a pesar de la implementación subyacente (Apache Xerces) hace. Tuve que resolver este problema y lo mejor que se me ocurrió fue incluir una copia de Xerces y utilizar las clases org.apache.xml.serialize.

Answer 3

Este exacta question ha sido respondida hace unos meses y one of the answers es utilizar la clase IndentingXMLStreamWriter:

XMLOutputFactory xmlof = XMLOutputFactory.newInstance(); 
XMLStreamWriter writer = new IndentingXMLStreamWriter(xmlof.createXMLStreamWriter(out)); 

Es una buena solución por lo que el código va, pero cuidado: este es un com.sun . * clase, no hay ninguna garantía de su disponibilidad general ...

Answer 4

Con Spring batch esto requiere una subclase ya que este JIRA BATCH-1867

public class IndentingStaxEventItemWriter<T> extends StaxEventItemWriter<T> { 

    @Setter 
    @Getter 
    private boolean indenting = true; 

    @Override 
    protected XMLEventWriter createXmlEventWriter(XMLOutputFactory outputFactory, Writer writer) throws XMLStreamException { 
    if (isIndenting()) { 
     return new IndentingXMLEventWriter(super.createXmlEventWriter(outputFactory, writer)); 
    } 
    else { 
     return super.createXmlEventWriter(outputFactory, writer); 
    } 
    } 

} 

Pero esto requiere una dependencia additionnal porque Spring Batch no incluye el código para sangrar la salida StAX:

<dependency> 
    <groupId>net.java.dev.stax-utils</groupId> 
    <artifactId>stax-utils</artifactId> 
    <version>20070216</version> 
</dependency> 

Answer 5

Sólo para que conste, Saxon le permite obtener un XMLStreamWriter serialización a través de la interfaz de s9api:

Processor p = new Processor(); 
Serializer s = p.newSerializer(); 
s.setOutputProperty(Property.INDENT, "yes"); 
XMLStreamWriter w = s.getXMLStreamWriter(); 

y el serializador expone todas las propiedades de salida definidas por XSLT (incluyendo "sangría") más algunos específicos de Saxon.

Answer 6

No tengo respuesta teniendo en cuenta "{http://xml.apache.org/xslt}indent-amount" propiedad. Pero puede usar transformadores de alguna manera portátil sin la necesidad de volver a rastrear todos los resultados. Puede usar algo como el código siguiente para crear impresiones bonitas XMLStreamWriter.

public static void main(String[] args) { 
    XMLStreamWriter xmlStreamWriter = createXMLStreamWriter(new OutputStreamWriter(System.out)); 
    writeXml(xmlStreamWriter); 
} 

private static XMLStreamWriter createXMLStreamWriter(Writer textWriter) throws XMLStreamException { 
    SAXTransformerFactory xmlTransformerFactory = (SAXTransformerFactory)SAXTransformerFactory.newInstance(); 
    TransformerHandler transformingSAXHandler; 
    try { 
     transformingSAXHandler = xmlTransformerFactory.newTransformerHandler(); 
    } catch (TransformerConfigurationException e) { 
     throw new XMLStreamException(e); 
    } 
    Transformer xmlTransformer = transformingSAXHandler.getTransformer(); 
    xmlTransformer.setOutputProperty(OutputKeys.INDENT, "yes"); 
    transformingSAXHandler.setResult(new StreamResult(textWriter)); 

    XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newInstance(); 
    return xmlOutputFactory.createXMLStreamWriter(new SAXResult(transformingSAXHandler)); 
}