Groovy XmlSlurper vs XmlParser

Question

J'ai cherché pendant un certain temps sur ce sujet et a trouvé des résultats trop, qui je le mentionne à la fin de l'après. Quelqu'un peut-il m'aider à répondre précisément à ces trois questions, pour les cas énumérés ci-dessous d'eux?

1. Pour lequel cas d'utilisation à l'aide de XmlSluper plus de sens que parseur xml et vice-versa (du point de vue de la facilité d'utilisation de l'API/Syntaxe)?

2. Lequel est le plus efficace en terme de mémoire? (il ressemble à Slurper)

3. dont on traite le xml plus vite?

Cas une. quand je dois lire presque tous les nœuds dans le fichier xml?

Cas b. quand je dois lire juste quelques nœuds (comme l'utilisation de gpath expression)?

Affaire c. quand je dois mettre à jour/transformer le xml?

pourvu que le document xml n'est pas trivial (avec niveau de profondeurs et de la taille du xml).

Ressources :

http://www.tutkiun.com/2009/10/xmlparser-and-xmlslurper.html membres :

Différence entre parseur xml et XMLSlurper:

Il y a des similitudes entre le parseur xml et XMLSlurper lorsqu'il est utilisé pour la simple lecture, mais quand nous les utilisons pour des avancées de lecture et lors de la traitement de documents XML en d'autres formats, il y a des différences entre les deux.

XMLParser magasins de résultats intermédiaires après l'analyse des documents. Mais sur l'autre main,

XMLSlurper ne stocke interne des résultats après le traitement XML documents.

Le réel, des différences fondamentales devenu évident lors du traitement de l' informations analysées. C'est lors du traitement avec direct de données la manipulation et la transformation en un streaming scénario.

http://groovy.dzone.com/news/john-wilson-groovy-and-xml

Le groovy doc (parseur xml, XmlSlurper) et le groovy du site explique bien (ici et ici), mais ne fait pas un bon travail en expliquant à la question qui précède.

Answer 1

La grande différence entre XmlSlurper et XmlParser est l'Analyseur va créer quelque chose de semblable à un DOM, tandis que Slurper essaie de créer des structures que si vraiment nécessaire et donc utilise les chemins d'accès, qui sont paresseusement évalué. Pour l'utilisateur à la fois peut sembler extrêmement égalité. La différence est plus que l'analyseur, la structure est évaluée qu'une seule fois, le slurper chemins peuvent être évaluées à la demande. Sur demande peut être lu comme "le plus efficace en terme de mémoire, mais plus lent" ici. Ultimatively il dépend du nombre de chemins/demandes que vous faites. Par exemple si vous voulez seulement de connaître la valeur d'un attribut dans une certaine partie du XML et ensuite être fait avec elle, XmlParser serait encore tous les processus et l'exécution de votre requête sur la quasi DOM. Dans un lot d'objets seront créés, de mémoire et de CPU passer. XmlSlurper ne va pas créer des objets, et ainsi économiser de la mémoire et du PROCESSEUR. Si vous avez besoin de toutes les parties du document, de toute façon, le slurper perd l'avantage, car elle permettra de créer au moins autant d'objets que l'analyseur serait.

Les deux peuvent faire des transformations sur le document, mais le slurper l'assume d'être une constante, et donc vous devez d'abord écrire les modifications et créer un nouveau slurper de lire le nouveau format xml dans. L'analyseur prend en charge en voyant les changements tout de suite.

Donc la réponse à la question (1), les cas d'utilisation, serait, que vous utilisez l'analyseur si vous avez à traiter de l'ensemble de XML, le slurper si seulement en partie. API et la syntaxe ne sont pas vraiment jouer un rôle dans cela. Le Groovy, les gens essaient de rendre ces deux très similaire dans l'expérience de l'utilisateur. Aussi, vous préférez l'analyseur sur le slurper si vous voulez faire des changements progressifs du XML.

C'est l'intro-dessus s'explique alors ce qui est plus efficace en terme de mémoire, la question (2). Le slurper est, à moins que vous lisez dans tous de toute façon, alors l'analyseur, mais je n'ai pas la réalité des chiffres sur l'ampleur de la différence ensuite.

Également la question (3) peut être répondu par l'intro. Si vous avez plusieurs paresseux évalué les chemins, vous avez à eval encore une fois, cela peut être plus lent que si vous il suffit de naviguer un existant graphique comme dans l'analyseur. Si l'analyseur peut être plus rapide, selon votre utilisation.

Donc je dirais (3a) de lecture de presque tous les nœuds se fait pas beaucoup de différence, depuis lors, les demandes sont le plus déterminant. Mais dans le cas (3b), je dirais que le slurper est plus rapide si vous n'avez qu'à lire quelques nœuds, car il n'aura pas de créer une structure entièrement en mémoire, ce qui, en soi, déjà, les coûts de temps et de mémoire.

Comme pour (3c)... ces deux jours peuvent mettre à jour/transformer le XML, qui est plus rapide est plus lié à la façon dont de nombreuses parties du xml que vous devez modifier. Si de nombreuses parties, je dirais que l'analyseur, si non, alors peut-être que le slurper. Mais si vous voulez par exemple changer la valeur d'un attribut de "Fred" à "Jean" avec le slurper, juste pour interroger par la suite pour ce "John" en utilisant la même slurper, ça ne marchera pas.