it-swarm.com.de

Konvertieren Sie XML mit Java in Json

Gibt es eine Möglichkeit, eine XML-Datei in Json zu konvertieren? Das XML kann eine beliebige Struktur haben, daher gibt es keine POJO-Klasse für die Instantiierung. Ich muss das XML in Json oder in eine Map ohne Wurzelknoten konvertieren.

Zum Beispiel:

<import name="person">
    <item>
        <firstName>Emil</firstName>
        <lastName>Example</lastName>
        <addresses>
            <address>
                <street>Example Blvd.</street>
            </address>
            <address>
                <street>Example Ave.</street>
            </address>
        </addresses>
    </item>
</import>

Erwartete JSON

{
    "firstName": "Emil",
    "lastName": "Example",
    "addresses": [
        { "street" : "Example Blvd." },
        { "street" : "Example Ave." }
    ]
}
8
Dominic
import org.json.JSONException;
import org.json.JSONObject;
import org.json.XML;

XML.toJSONObject(xml_text).toString()

org.json.XML

15

Sie können JSON- und XML-Bibliothek von json.org verwenden.

import org.json.JSONObject;
import org.json.XML;
import org.junit.Test;

public class XmlToJsonTest {
    private static final String XML_TEXT = "<note>\n" +
            "<to>Tove</to>\n" +
            "<from>Jani</from>\n" +
            "<heading>Reminder</heading>\n" +
            "<body>Don't forget me this weekend!</body>\n" +
            "</note>";
    private static final int PRETTY_PRINT_INDENT_FACTOR = 4;

    @Test
    public void convert() {
        JSONObject xmlJSONObj = XML.toJSONObject(XML_TEXT);
        String jsonPrettyPrintString = xmlJSONObj.toString(PRETTY_PRINT_INDENT_FACTOR);
        System.out.println(jsonPrettyPrintString);
    }
}

Quelle

<note>
    <to>Tove</to>
    <from>Jani</from>
    <heading>Reminder</heading>
    <body>Don't forget me this weekend!</body>
</note>

Ausgabe

{"note": {
    "heading": "Reminder",
    "from": "Jani",
    "to": "Tove",
    "body": "Don't forget me this weekend!"
}}
8
Adi Sembiring

Wenn Sie Java 8 verwenden, sollten Sie meine Open Source-Bibliothek auschecken: unXml . unXml bildet im Wesentlichen von Xpaths zu Json-Attributen ab.

Es ist auf Maven Central verfügbar.

Beispiel

import com.fasterxml.jackson.databind.node.ObjectNode;
import com.nerdforge.unxml.factory.ParsingFactory;
import com.nerdforge.unxml.parsers.Parser;
import org.w3c.dom.Document;

public class ParserExample {
    public ObjectNode parseXml(String xml){
        Parsing parsing = ParsingFactory.getInstance().create();
        Document document = parsing.xml().document(xml);

        Parser<ObjectNode> parser = parsing.obj("//item")
            .attribute("firstName", "firstName")
            .attribute("lastName", "lastName")
            .attribute("addresses", parsing.arr("addresses/address", parsing.obj()
                .attribute("street", "street")
            ))
            .build();

        ObjectNode result = parser.apply(document);
        return result;
    }
}

Es wird eine JacksonObjectNode mit dem Json aus Ihrem Beispiel zurückgegeben.

3
tomaj

Auf dieser Website finden Sie hilfreiche Kurse für Ihre Aufgabe.

public class Main {

    public static int PRETTY_PRINT_INDENT_FACTOR = 4;
    public static String TEST_XML_STRING = "Your xml string here";

    public static void main(String[] args) {
        try {
            JSONObject xmlJSONObj = XML.toJSONObject(TEST_XML_STRING);
            String jsonPrettyPrintString = xmlJSONObj.toString(PRETTY_PRINT_INDENT_FACTOR);
            System.out.println(jsonPrettyPrintString);
        } catch (JSONException je) {
            System.out.println(je.toString());
        }
    }
}
1

Ich bin JSON-Java , habe aber eine effizientere Bibliothek zum Konvertieren von XML in Json gefunden XmlToJson

Welches ist die beste Anpassung, um Json vonXML zu machen

Fügen Sie die libary-Abhängigkeit zu Ihrer APP build.gradle-Datei hinzu

dependencies {
compile 'com.github.smart-fun:XmlToJson:1.4.4'    // add this line
}

    <?xml version="1.0" encoding="utf-8"?>
    <library>
    <book id="007">James Bond</book>
    <book id="000">Book for the dummies</book>
    </library>
  • Benutzerdefinierte Inhaltsnamen

    public String convertXmlToJson(String xml) {
    XmlToJson xmlToJson = new XmlToJson.Builder(xml)
        .setContentName("/library/book", "title")
        .build();
    return xmlToJson.toString();
    }
    

    "library":{  
      "book":[  
         {  
            "id":"007",
            "title":"James Bond"
         },
         {  
            "id":"000",
            "title":"Book for the dummies"
         }
       ]
      }
     }
    

  • Namen der benutzerdefinierten Attribute

    public String convertXmlToJson(String xml) {
      XmlToJson xmlToJson = new XmlToJson.Builder(xml)
        .setAttributeName("/library/book/id", "code")
        .build();
      return xmlToJson.toString();
    }
    

    {  
      "library":{  
      "book":[  
         {  
            "code":"007",
            "content":"James Bond"
         },
         {  
            "code":"000",
            "content":"Book for the dummies"
         }
      ]
     }
    }
    

und viel effizientere Techniken zur Anpassung Ihres Json

Hier klicken, um auf Github auszuchecken

1
Nikunj Paradva

Sie können Standardwerkzeuge dafür verwenden

  1. Verwenden Sie das Tool xjc aus Ihrem jdk, um Java-Klassen aus Schema zu generieren

    Seit Java 9 müssen Sie JAXB explizit als Modul mit –add-modules Java.se.ee .__ hinzufügen. Siehe: So lösen Sie Java.lang.NoClassDefFoundError auf: javax/xml/bind/JAXBException in Java 9

Seit Java 11 müssen Sie xjc in einem zusätzlichen Schritt von https://javaee.github.io/jaxb-v2/ herunterladen.

  1. Als XML einlesen als JSON mit Jackson einlesen

Beispiel

Mit https://schema.datacite.org/meta/kernel-4.1/metadata.xsd

1. Verwenden Sie das Tool xjc aus Ihrem jdk

In meinem Beispiel werde ich ein ziemlich komplexes Beispiel verwenden, das auf Datenschemas basiert.

/path/to/jdk/bin/xjc -d /path/to/Java/project \
-p stack24174963.datacite \
 https://schema.datacite.org/meta/kernel-4.1/metadata.xsd

Dies wird mit antworten

parsing a schema...
compiling a schema...
stack24174963/datacite/Box.Java
stack24174963/datacite/ContributorType.Java
stack24174963/datacite/DateType.Java
stack24174963/datacite/DescriptionType.Java
stack24174963/datacite/FunderIdentifierType.Java
stack24174963/datacite/NameType.Java
stack24174963/datacite/ObjectFactory.Java
stack24174963/datacite/Point.Java
stack24174963/datacite/RelatedIdentifierType.Java
stack24174963/datacite/RelationType.Java
stack24174963/datacite/Resource.Java
stack24174963/datacite/ResourceType.Java
stack24174963/datacite/TitleType.Java
stack24174963/datacite/package-info.Java

2. Einlesen als XML ausschreiben als JSON mit Jackson

  import com.fasterxml.jackson.databind.ObjectMapper;
  import com.fasterxml.jackson.databind.SerializationFeature;

  import stack24174963.datacite.Resource;

  public class HowToXmlToJsonWithSchema {
    @Test
    public void readXmlAndConvertToSchema() throws Exception {
        String example = "schemas/datacite/kernel-4.1/example/datacite-example-complicated-v4.1.xml";
        try (InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream(example)) {
            Resource resource = JAXB.unmarshal(in, Resource.class);
            System.out.println(asJson(resource));
        }
    }

    private String asJson(Object obj) throws Exception {
        StringWriter w = new StringWriter();
        new ObjectMapper().configure(SerializationFeature.INDENT_OUTPUT, true).writeValue(w, obj);
        String result = w.toString();
        return result;
    }
  }

Drucke:

 {
      "identifier" : {
        "value" : "10.5072/testpub",
        "identifierType" : "DOI"
      },
      "creators" : {
        "creator" : [ {
          "creatorName" : {
            "value" : "Smith, John",
            "nameType" : "PERSONAL"
          },
          "givenName" : "<?xml version=\"1.0\" encoding=\"UTF-16\"?>\n<givenName xmlns=\"http://datacite.org/schema/kernel-4\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">John</givenName>",
          "familyName" : "<?xml version=\"1.0\" encoding=\"UTF-16\"?>\n<familyName xmlns=\"http://datacite.org/schema/kernel-4\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">Smith</familyName>",
          "nameIdentifier" : [ ],
          "affiliation" : [ ]
        }, {
          "creatorName" : {
            "value" : "つまらないものですが",
            "nameType" : null
          },
          "givenName" : null,
          "familyName" : null,
          "nameIdentifier" : [ {
            "value" : "0000000134596520",
            "nameIdentifierScheme" : "ISNI",
            "schemeURI" : "http://isni.org/isni/"
          } ],
          "affiliation" : [ ]
        } ]
      },
      "titles" : {
        "title" : [ {
          "value" : "Właściwości rzutowań podprzestrzeniowych",
          "titleType" : null,
          "lang" : "pl"
        }, {
          "value" : "Translation of Polish titles",
          "titleType" : "TRANSLATED_TITLE",
          "lang" : "en"
        } ]
      },
      "publisher" : "Springer",
      "publicationYear" : "2010",
      "resourceType" : {
        "value" : "Monograph",
        "resourceTypeGeneral" : "TEXT"
      },
      "subjects" : {
        "subject" : [ {
          "value" : "830 German & related literatures",
          "subjectScheme" : "DDC",
          "schemeURI" : null,
          "valueURI" : null,
          "lang" : "en"
        }, {
          "value" : "Polish Literature",
          "subjectScheme" : null,
          "schemeURI" : null,
          "valueURI" : null,
          "lang" : "en"
        } ]
      },
      "contributors" : {
        "contributor" : [ {
          "contributorName" : {
            "value" : "Doe, John",
            "nameType" : "PERSONAL"
          },
          "givenName" : "<?xml version=\"1.0\" encoding=\"UTF-16\"?>\n<givenName xmlns=\"http://datacite.org/schema/kernel-4\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">John</givenName>",
          "familyName" : "<?xml version=\"1.0\" encoding=\"UTF-16\"?>\n<familyName xmlns=\"http://datacite.org/schema/kernel-4\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">Doe</familyName>",
          "nameIdentifier" : [ {
            "value" : "0000-0001-5393-1421",
            "nameIdentifierScheme" : "ORCID",
            "schemeURI" : "http://orcid.org/"
          } ],
          "affiliation" : [ ],
          "contributorType" : "DATA_COLLECTOR"
        } ]
      },
      "dates" : null,
      "language" : "de",
      "alternateIdentifiers" : {
        "alternateIdentifier" : [ {
          "value" : "937-0-4523-12357-6",
          "alternateIdentifierType" : "ISBN"
        } ]
      },
      "relatedIdentifiers" : {
        "relatedIdentifier" : [ {
          "value" : "10.5272/oldertestpub",
          "resourceTypeGeneral" : null,
          "relatedIdentifierType" : "DOI",
          "relationType" : "IS_PART_OF",
          "relatedMetadataScheme" : null,
          "schemeURI" : null,
          "schemeType" : null
        } ]
      },
      "sizes" : {
        "size" : [ "256 pages" ]
      },
      "formats" : {
        "format" : [ "pdf" ]
      },
      "version" : "2",
      "rightsList" : {
        "rights" : [ {
          "value" : "Creative Commons Attribution-NoDerivs 2.0 Generic",
          "rightsURI" : "http://creativecommons.org/licenses/by-nd/2.0/",
          "lang" : null
        } ]
      },
      "descriptions" : {
        "description" : [ {
          "content" : [ "\n      Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea\n      takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores\n      et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.\n    " ],
          "descriptionType" : "ABSTRACT",
          "lang" : "la"
        } ]
      },
      "geoLocations" : null,
      "fundingReferences" : null
    }

Zum Beispiel Eingabe XML:

  <?xml version="1.0" encoding="UTF-8"?>
  <resource xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://datacite.org/schema/kernel-4" xsi:schemaLocation="http://datacite.org/schema/kernel-4 http://schema.datacite.org/meta/kernel-4.1/metadata.xsd">
    <identifier identifierType="DOI">10.5072/testpub</identifier>
    <creators>
      <creator>
        <creatorName nameType="Personal">Smith, John</creatorName>
        <givenName>John</givenName>
        <familyName>Smith</familyName>
      </creator>
      <creator>
        <creatorName>つまらないものですが</creatorName>
        <nameIdentifier nameIdentifierScheme="ISNI" schemeURI="http://isni.org/isni/">0000000134596520</nameIdentifier>
      </creator>
    </creators>
    <titles>
      <title xml:lang="pl">Właściwości rzutowań podprzestrzeniowych</title>
      <title xml:lang="en" titleType="TranslatedTitle">Translation of Polish titles</title>
    </titles>
    <publisher>Springer</publisher>
    <publicationYear>2010</publicationYear>
    <subjects>
      <subject xml:lang="en" subjectScheme="DDC">830 German &amp; related literatures</subject>
      <subject xml:lang="en">Polish Literature</subject>
    </subjects>
    <contributors>
      <contributor contributorType="DataCollector">
        <contributorName nameType="Personal">Doe, John</contributorName>
        <givenName>John</givenName>
        <familyName>Doe</familyName>
        <nameIdentifier nameIdentifierScheme="ORCID" schemeURI="http://orcid.org/">0000-0001-5393-1421</nameIdentifier>
      </contributor>
    </contributors>
    <language>de</language>
    <resourceType resourceTypeGeneral="Text">Monograph</resourceType>
    <alternateIdentifiers>
      <alternateIdentifier alternateIdentifierType="ISBN">937-0-4523-12357-6</alternateIdentifier>
    </alternateIdentifiers>
    <relatedIdentifiers>
      <relatedIdentifier relatedIdentifierType="DOI" relationType="IsPartOf">10.5272/oldertestpub</relatedIdentifier>
    </relatedIdentifiers>
    <sizes>
      <size>256 pages</size>
    </sizes>
    <formats>
      <format>pdf</format>
    </formats>
    <version>2</version>
    <rightsList>
      <rights rightsURI="http://creativecommons.org/licenses/by-nd/2.0/">Creative Commons Attribution-NoDerivs 2.0 Generic</rights>
    </rightsList>
    <descriptions>
      <description xml:lang="la" descriptionType="Abstract">
        Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea
        takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores
        et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.
      </description>
    </descriptions>
  </resource>
0
jschnasse

Underscore-Java library hat die statische Methode xmlToJson. Ich bin der Betreuer des Projekts. Live-Beispiel

import com.github.underscore.lodash.U;

public class Main {
    public static void main(String[] args) {
        final String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<root>\n"
            + "  <FirstItem>1</FirstItem>\n  <SecondItem>2</SecondItem>\n</root>";
        System.out.println(U.xmlToJson(xml));
    }
}
0