¿Cómo transformar enormes archivos xml en Java?

Question

Como el título lo dice, tengo un archivo XML enorme (GB)

<root> 
<keep> 
    <stuff> ... </stuff> 
    <morestuff> ... </morestuff> 
</keep> 
<discard> 
    <stuff> ... </stuff> 
    <morestuff> ... </morestuff> 
</discard> 
</root> 

y me gustaría para transformarlo en un ser mucho más pequeño que sólo conserva algunos de los elementos.
Mi analizador debe hacer lo siguiente:
1. Revisar el archivo hasta que comience un elemento relevante.
2. Copie todo el elemento relevante (con elementos secundarios) en el archivo de salida. vaya a 1.

paso 1 es fácil con SAX e imposible para los analizadores DOM.
paso 2 es molesto con SAX, pero fácil con el DOM-Analizador o XSLT.

¿y qué? - ¿Existe una forma ordenada de combinar SAX y DOM-Parser para realizar la tarea?

Answer 1

Sí, solo escribe un controlador de contenido SAX, y cuando se encuentra con un elemento determinado, creas un árbol dom en ese elemento. He hecho esto con archivos muy grandes, y funciona muy bien.

En realidad es muy fácil: tan pronto como se encuentra con el inicio del elemento que desea, establece un indicador en su controlador de contenido, y a partir de ahí, reenvía todo al generador de DOM. Cuando encuentre el final del elemento, establezca el indicador en falso y escriba el resultado.

(Para los casos más complejos con elementos anidados del mismo nombre del elemento, que necesitará para crear una pila o un contador, pero que aún así es muy fácil de hacer.)

Answer 2

StAX parece ser una solución obvia: es un analizador de extracción en lugar del enfoque de "empuje" de SAX o de "amortiguar todo" de DOM. Sin embargo, no puedo decir que lo haya usado. Un "StAX tutorial" search puede ser útil :)

Answer 3

Tenga una mirada en StAX, este podría ser lo que necesitas Hay una buena introducción en IBM Developer Works.

Answer 4

Puede hacerlo fácilmente con XMLEventReader y varios XMLEventWriter s del paquete javax.xml.stream.

Answer 5

Como estás hablando de GB, prefiero priorizar el uso de memoria en la consideración. SAX necesita aproximadamente 2 veces más de memoria que el documento grande, mientras que DOM necesita que sea al menos 5 veces. Entonces, si su archivo XML tiene un tamaño de 1 GB, DOM requerirá un mínimo de 5 GB de memoria libre. Eso ya no es gracioso. Entonces SAX (o cualquier variante sobre él, como StAX) es la mejor opción aquí.

Si desea el enfoque más eficiente de la memoria, consulte VTD-XML. Solo requiere un poco de más memoria que el archivo grande.

Answer 6

Para un documento XML tan grande, algo con una arquitectura de transmisión, como Omnimark sería ideal.

No tendría que ser nada complejo tampoco. Una secuencia de comandos Omnimark gusta lo que está por debajo de usted podría darle lo que necesita:

process 

submit #main-input 

macro upto (arg string) is 
    ((lookahead not string) any)* 
macro-end 

find (("<keep") upto ("</keep>") "</keep>")=>keep 
    output keep 

find any 

Answer 7

Hice buenas experiencias con STX (Streaming transformaciones para XML).Básicamente, es una versión transmitida de XSLT, muy adecuada para analizar grandes cantidades de datos con una huella de memoria mínima. Tiene una implementación en Java llamada Joost.

Debería ser fácil encontrar una transformación STX que ignore todos los elementos hasta que el elemento coincida con un XPath determinado, copie ese elemento y todos sus elementos secundarios (utilizando una plantilla de identidad dentro de un grupo de plantillas) y continúe ignorando elementos hasta el próximo partido.

ACTUALIZACIÓN

I hackeado una STX transformar que hace lo que entiendo que desea. En su mayoría, depende de características solo STX como grupos de plantillas y plantillas predeterminadas configurables.

<stx:transform xmlns:stx="http://stx.sourceforge.net/2002/ns" 
    version="1.0" pass-through="none" output-method="xml"> 
    <stx:template match="element/child"> 
     <stx:process-self group="copy" /> 
    </stx:template> 
    <stx:group name="copy" pass-through="all"> 
    </stx:group> 
</stx:transform> 

El pass-through="none" en el stx:transform configura las plantillas predeterminadas (por nodos, atributos etc.) para producir ninguna salida, pero los elementos proceso hijo. Entonces el stx:template coincide con el XPath element/child (este es el lugar donde pone su expresión de coincidencia), se "procesa a sí mismo" en el grupo "copiar", lo que significa que la plantilla correspondiente del group name="copy" se invoca en el elemento actual. Ese grupo tiene pass-though="all", por lo que las plantillas predeterminadas copian su entrada y procesan elementos secundarios. Cuando finaliza el elemento element/child, el control se devuelve a la plantilla que invoca process-self, y los siguientes elementos se ignoran nuevamente. Hasta que la plantilla coincida nuevamente.

El siguiente es un ejemplo de archivo de entrada:

<root> 
    <child attribute="no-parent, so no copy"> 
    </child> 
    <element id="id1"> 
     <child attribute="value1"> 
      text1<b>bold</b> 
     </child> 
    </element> 
    <element id="id2"> 
     <child attribute="value2"> 
      text2 
      <x:childX xmlns:x="http://x.example.com/x"> 
      <!-- comment --> 
       yet more<b i="i" x:i="x-i" ></b> 
      </x:childX> 
     </child> 
    </element> 
</root> 

Este es el archivo de salida correspondiente:

<?xml version="1.0" encoding="UTF-8"?> 
<child attribute="value1"> 
      text1<b>bold</b> 
     </child><child attribute="value2"> 
      text2 
      <x:childX xmlns:x="http://x.example.com/x"> 
      <!-- comment --> 
       yet more<b i="i" x:i="x-i" /> 
      </x:childX> 
     </child> 

El formato inusual es el resultado de saltarse los nodos de texto que contienen saltos de línea fuera de los child elementos .