Convertir XML en JSON en Groovy

Je souhaite convertir xml en JSON à l'aide de groovy. J'comprendre les spécificités de la conversion dépend de mes préférences, mais quelqu'un pourrait s'il vous plaît recommander dont les bibliothèques et les méthodes à utiliser et me donner un peu d'informations sur le pourquoi/comment les utiliser? Je suis à l'aide de groovy comme je l'ai dit c'est un moyen très efficace de l'analyseur, je suis à la recherche pour les bibliothèques qui aura l'avantage de cette

Merci!

OriginalL'auteur Tom Hadkiss | 2013-09-16

8

Vous pouvez tout faire avec base Groovy:
```
//Given an XML string
def xml = '''<root>
            |    <node>Tim</node>
            |    <node>Tom</node>
            |</root>'''.stripMargin()

//Parse it
def parsed = new XmlParser().parseText( xml )

//Convert it to a Map containing a List of Maps
def jsonObject = [ root: parsed.node.collect {
  [ node: it.text() ]
} ]

//And dump it as Json
def json = new groovy.json.JsonBuilder( jsonObject )

//Check it's what we expected
assert json.toString() == '{"root":[{"node":"Tim"},{"node":"Tom"}]}'
```
CEPENDANT, vous avez vraiment besoin de penser à certaines choses...
- Comment allez-vous vous représenter les Attributs?
- Votre XML contiennent <node>text<another>woo</another>text</node> style de balisage? Si oui, comment allez-vous gérer cela?
- CDATA? Des commentaires? etc?
Il n'est pas lisse d'un mappage 1:1 entre les deux... Mais pour un format spécifique de XML, il peut être possible de venir avec un format spécifique de Json.

Mise à jour:

Pour obtenir le nom du document (voir le commentaire), vous pouvez le faire:
```
def jsonObject = [ (parsed.name()): parsed.collect {
  [ (it.name()): it.text() ]
} ]
```
Mise à jour 2

Vous pouvez ajouter la prise en charge pour une plus grande profondeur avec:
```
//Given an XML string
def xml = '''<root>
            |    <node>Tim</node>
            |    <node>Tom</node>
            |    <node>
            |      <anotherNode>another</anotherNode>
            |    </node>
            |</root>'''.stripMargin()

//Parse it
def parsed = new XmlParser().parseText( xml )

//Deal with each node:
def handle
handle = { node ->
  if( node instanceof String ) {
      node
  }
  else {
      [ (node.name()): node.collect( handle ) ]
  }
}
//Convert it to a Map containing a List of Maps
def jsonObject = [ (parsed.name()): parsed.collect { node ->
   [ (node.name()): node.collect( handle ) ]
} ]

//And dump it as Json
def json = new groovy.json.JsonBuilder( jsonObject )

//Check it's what we expected
assert json.toString() == '{"root":[{"node":["Tim"]},{"node":["Tom"]},{"node":[{"anotherNode":["another"]}]}]}'
```
Encore une fois, toutes les mises en garde encore vrai (mais il devrait être entendu parler un peu plus fort à ce point) 😉

Merci beaucoup pour votre aide! J'ai une autre question au sujet de votre solution cependant. Lorsque vous avez défini jsonObject, vous avez spécifié "de racine:" et de "nœud", est-il un moyen pour groovy automatiquement spécifier ces noms, sans la nécessité d'hypothèse, par l'analyse des noms des attributs xml?
Mise à jour de la réponse à montrer comment vous pouvez le faire (mais encore une fois, avec de plus en plus complexe document xml, les choses vont devenir funky) 😉
Toutes mes excuses, google ne m'accorde pas avec toutes les réponses.. Comment recommanderiez-vous l'utilisation du XML qui va au plus profond? Par exemple, <root><nœud><anotherNode>autre</anotherNode></node></root>
Mise à jour, mais encore une fois, vous devriez entendre une alarme que nous arrivons à la fin de la route, avec ce genre de générique de conversion

OriginalL'auteur tim_yates

Ce serait faire le travail: http://www.json.org/java/

Au moment de la rédaction de cette réponse, le pot est disponible sur: http://mvnrepository.com/artifact/org.json/json/20140107

Suivant illustre l'utilisation.

Importations:

import org.json.JSONObject
import org.json.XML

De Conversion:

static String convert(final String input) {
  int textIndent = 2
  JSONObject xmlJSONObj = XML.toJSONObject(input)
  xmlJSONObj.toString(textIndent)
}

Liées Spock les essais de certains scénarios que nous avons besoin de regarder dehors pour:

void "If tag and content are available, the content is put into a content attribute"() {
  given:
  String xml1 = '''
  <tag attr1="value">
    hello
  </tag>
  '''
  and:
  String xml2 = '''
  <tag attr1="value" content="hello"></tag>
  '''
  and:
  String xml3 = '''
  <tag attr1="value" content="hello" />
  '''
  and:
  String json = '''
  {"tag": {
      "content": "hello",
      "attr1": "value"
  }}
  '''

  expect:
  StringUtils.deleteWhitespace(convert(xml1)) == StringUtils.deleteWhitespace(json)
  StringUtils.deleteWhitespace(convert(xml2)) == StringUtils.deleteWhitespace(json)
  StringUtils.deleteWhitespace(convert(xml3)) == StringUtils.deleteWhitespace(json)
}

void "The content attribute would be merged with the content as an array"() {
  given:
  String xml = '''
  <tag content="same as putting into the content"
       attr1="value">
    hello
  </tag>
  '''
  and:
  String json = '''
  {"tag": {
      "content": [
          "same as putting into the content",
          "hello"
      ],
      "attr1": "value"
  }}
  '''

  expect:
  StringUtils.deleteWhitespace(convert(xml)) == StringUtils.deleteWhitespace(json)
}

void "If no additional attributes, the content attribute would be omitted, and it creates array in array instead"() {
  given:
  String xml = '''
  <tag content="same as putting into the content" >
    hello
  </tag>
  '''
  and:
  String notExpected = '''
  {"tag": {[
          "same as putting into the content",
          "hello"
          ]}
  }
  '''
  String json = '''
  {"tag": [[
          "same as putting into the content",
          "hello"
          ]]
  }
  '''

  expect:
  StringUtils.deleteWhitespace(convert(xml)) != StringUtils.deleteWhitespace(notExpected)
  StringUtils.deleteWhitespace(convert(xml)) == StringUtils.deleteWhitespace(json)
}

Espère que cela aide quelqu'un qui a encore besoin de résoudre ce problème.

Super simple avec quelques lignes de codes. Il gère également des attributs XML.

OriginalL'auteur Max

Je suis un peu en retard à la fête, mais le code suivant permettra de convertir n'importe quel document XML dans une cohérence format JSON:

def toJsonBuilder(xml){
    def pojo = build(new XmlParser().parseText(xml))
    new groovy.json.JsonBuilder(pojo)
}
def build(node){
    if (node instanceof String){ 
        return //ignore strings...
    }
    def map = ['name': node.name()]
    if (!node.attributes().isEmpty()) {
        map.put('attributes', node.attributes().collectEntries{it})
    }
    if (!node.children().isEmpty() && !(node.children().get(0) instanceof String)) { 
        map.put('children', node.children().collect{build(it)}.findAll{it != null})
    } else if (node.text() != ''){
        map.put('value', node.text())
    }
    map
}
toJsonBuilder(xml1).toPrettyString()

Convertit le XML...

<root>
    <node>Tim</node>
    <node>Tom</node>
</root>

En...

{
    "name": "root",
    "children": [
        {
            "name": "node",
            "value": "Tim"
        },
        {
            "name": "node",
            "value": "Tom"
        }
    ]
}

Commentaires/améliorations bienvenues!

OriginalL'auteur Nick Grealy

0

J'ai utilisé staxon pour obtenir complexes XML en JSON avec staxon. Cela inclut des éléments avec des attributs.

Le tableau suivant est un exemple de conversion de xml en json.

https://github.com/beckchr/staxon/wiki/Converting-XML-to-JSON

OriginalL'auteur onekilo79

Vous devez vous connecter pour publier un commentaire.

Mise à jour:

Mise à jour 2