Konvertierung von XML zu JSON in Groovy

Möchte ich die Konvertierung von xml zu JSON Verwendung von groovy. Ich verstehe die Besonderheiten der Konvertierung ist abhängig von meiner Vorlieben, aber könnte jemand bitte empfehlen, welche Bibliotheken und Methoden, die ich verwenden soll und mir ein wenig Informationen, warum/wie Sie zu nutzen? Ich bin mit groovy als ich haben gesagt, es ist eine sehr effektive parser, also ich bin auf der Suche nach Bibliotheken, die die Vorteile dieses

Dank!

InformationsquelleAutor Tom Hadkiss | 2013-09-16
  1. 8

    Können Sie tun es alle mit basic 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"}]}'

    JEDOCH, die Sie wirklich brauchen, zu denken, dass gewisse Dinge...

    • Wie sind Sie zur Darstellung von Parametern?
    • Wird Ihre XML enthalten <node>text<another>woo</another>text</node> Stil-markup? Wenn ja, wie gehst du damit um?
    • CDATA? Kommentare? etc?

    Es ist nicht eine glatte 1:1-Zuordnung zwischen den beiden... Aber für eine bestimmte format von XML, kann es möglich sein zu kommen mit einem bestimmten format Json.

    Update:

    Um die Namen aus dem Dokument (siehe Kommentar), die Sie tun können:

    def jsonObject = [ (parsed.name()): parsed.collect {
  [ (it.name()): it.text() ]
} ]

    Update 2

    Können Sie hinzufügen von Unterstützung für mehr Tiefe mit:

    //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"]}]}]}'

    Wieder, werden alle vorherigen Warnungen immer noch für wahr halten (sollten aber zu hören sein, ein wenig lauter an dieser Stelle) 😉

    • Vielen Dank für Eure Hilfe! Ich habe eine weitere Frage zu deiner Lösung.. aber .. Wenn Sie definiert jsonObject, die Sie angegeben "root:" und "node:" gibt es einen Weg für groovy automatisch diese Namen anzugeben, ohne die Notwendigkeit für die Annahme, durch Analyse der Namen der xml-Attribute?
    • Aktualisierte Antwort zu zeigen, wie Sie dies tun könnte (aber wieder, mit einer komplexeren xml-Dokument, die Dinge get funky) 😉
    • Entschuldige bitte, google ist nicht die mir keine Antworten.. Wie würde Sie empfehlen, arbeiten mit XML, das tiefer geht? Zum Beispiel, <root><node><anotherNode>weiteres</anotherNode></Knoten></root>
    • Aktualisiert, aber wieder sollten Sie hören einen alarm, als wir das Ende der Straße mit dieser Art von generischen-Konvertierung
    InformationsquelleAutor tim_yates
  2. 6

    Dieser würde die Aufgabe: http://www.json.org/java/

    In der Zeit des Schreibens dieser Antwort, das Glas ist erhältlich auf: http://mvnrepository.com/artifact/org.json/json/20140107

    Folgende zeigt die Verwendung.

    Importe:

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

    Konvertierung:

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

    Verwandte Spock-tests, um bestimmte Szenarien, die wir müssen aufpassen:

    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)
}

    Hoffe, dies hilft jemand, die noch brauchen, um dieses problem zu beheben.

    • Super einfach mit wenigen Zeilen Code. Es kann auch mit XML-Parametern.
    InformationsquelleAutor Max
  3. 1

    Ich bin ein bisschen spät zur party, aber der folgende code konvertiert jedes beliebige XML-Daten in eine konsistente JSON-format:

    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()

    Wandelt die XML...

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

    In...

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

    Feedback/Verbesserungen willkommen!

    InformationsquelleAutor Nick Grealy
  4. 0

    Ich genutzt staxon komplexe XML zu JSON mit staxon. Diese enthalten Elemente mit Attributen.

    Folgende ist ein Beispiel der Umwandlung von xml zu json.

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

    InformationsquelleAutor onekilo79
Schreibe einen Kommentar