Groovy XmlSlurper vs XmlParser

J’ai cherché pendant un certain temps sur ce sujet et j’ai également trouvé des résultats, que je mentionne à la fin du message. Est-ce que quelqu’un peut m’aider à répondre précisément à ces trois questions pour les cas énumérés ci-dessous?

  1. Pour quels cas d’utilisation de XmlSluper ont plus de sens que XmlParser et vice-versa (du sharepoint vue de la facilité d’utilisation de l’API / de la syntaxe)?

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

  3. lequel traite le xml plus rapidement?

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

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

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

à condition que le document XML ne soit pas sortingvial (avec le niveau de profondeur et la taille du fichier XML).

Ressources :

http://www.tutkiun.com/2009/10/xmlparser-and-xmlslurper.html déclare:

Différence entre XMLParser et XMLSlurper:

Il existe des similitudes entre XMLParser et XMLSlurper lorsqu’il est utilisé pour une lecture simple, mais lorsque nous les utilisons pour une lecture avancée et lors du traitement de documents XML dans d’autres formats, il existe des différences entre deux.

XMLParser stocke les résultats intermédiaires après l’parsing des documents. Mais d’autre part,

XMLSlurper ne stocke pas les résultats internes après le traitement des documents XML.

Les différences fondamentales réelles deviennent apparentes lors du traitement des informations analysées. C’est-à-dire lors du traitement avec manipulation directe des données sur place et traitement dans un scénario de diffusion en continu.

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

Le groovy doc ( XmlParser , XmlSlurper ) et le site groovy les expliquent bien ( ici et ici ) mais n’expliquent pas très bien la question susmentionnée.

La grande différence entre XmlSlurper et XmlParser est que le Parser va créer quelque chose de similaire à un DOM, tandis que Slurper essaie de créer des structures uniquement si cela est vraiment nécessaire et utilise donc des chemins évalués paresseusement. Pour l’utilisateur, les deux peuvent être extrêmement similaires. La différence réside dans le fait que la structure de l’parsingur n’est évaluée qu’une seule fois, les chemins d’épuration peuvent être évalués à la demande. Sur demande, on peut lire “plus de mémoire efficace mais plus lent” ici. En fin de compte, cela dépend du nombre de chemins / requêtes que vous faites. Si, par exemple, vous ne voulez que connaître la valeur d’un atsortingbut dans une certaine partie du XML et que vous en avez fini avec cela, XmlParser traiterait tout et exécuterait votre requête sur le quasi DOM. En cela, beaucoup d’objects seront créés, de la mémoire et du processeur. XmlSlurper ne créera pas les objects, économisant ainsi de la mémoire et du processeur. Si vous avez besoin de toutes les parties du document, le filtre perd l’avantage, car il créera au moins autant d’objects que l’parsingur.

Les deux peuvent faire des transformations sur le document, mais le slurper suppose qu’il s’agit d’une constante et vous devrez donc d’abord écrire les modifications et créer un nouveau slurper pour lire le nouveau XML. L’parsingur prend immédiatement en charge les modifications.

Donc, la réponse à la question (1), le cas d’utilisation, serait que vous utilisiez l’parsingur si vous devez traiter l’intégralité du XML, le slurper si ce n’est que des parties. L’API et la syntaxe n’y jouent pas vraiment un rôle. Les Groovy essayent de rendre ces deux choses très similaires dans l’expérience utilisateur. De plus, vous préféreriez l’parsingur plutôt que le slurper si vous souhaitez apporter des modifications incrémentielles au XML.

Cette introduction explique également ce qui est plus efficace en mémoire, question (2). Le slurper est, à moins que vous lisiez tout de toute façon, alors l’parsingur peut, mais je n’ai pas de chiffres réels sur la taille de la différence alors.

Aussi la question (3) peut être répondue par l’intro. Si vous avez plusieurs chemins évalués paresseux, vous devez réévaluer, alors cela peut être plus lent que si vous parcourez simplement un graphique existant comme dans l’parsingur. L’parsingur peut donc être plus rapide, en fonction de votre utilisation.

Je dirais donc que (3a) la lecture de presque tous les nœuds ne fait pas beaucoup de différence, car les demandes sont alors le facteur le plus déterminant. Mais dans le cas (3b), je dirais que le slurper est plus rapide si vous devez juste lire quelques nœuds, car il ne sera pas nécessaire de créer une structure complète en mémoire, ce qui en soi coûte déjà du temps et de la mémoire.

Quant à (3c) … ces deux jours peuvent tous deux mettre à jour / transformer le XML, ce qui est plus rapide, en réalité, plus lié au nombre de parties du XML que vous devez modifier. Si beaucoup de parties je dirais l’parsingur, sinon, alors peut-être le slurper. Mais si vous voulez par exemple changer une valeur d’atsortingbut de “Fred” à “John” avec le slurper, juste pour demander ultérieurement ce “John” en utilisant le même slurper, cela ne fonctionnera pas.

Je vais vous donner des réponses nettes:

* XML Parser est plus rapide que XML Slurper.
* XML Slurper consum moins de mémoire que l’parsingur XML.
* XML Parser peut parsingr et mettre à jour le XML simultanément.
* Pour XML Slurper vous avez besoin de MarkupBuild Le XML après chaque mise à jour que vous effectuez.
* Lorsque vous souhaitez utiliser Path Expressions XML Slurper serait mieux que l’parsingur.
* Pour la lecture, presque tous les nœuds XML Parser serait correct

J’espère que cela aide