Was ist die beste/einfachste Weise zu Lesen, die in einer XML-Datei in Java-Anwendung?

XML-Code:

<?xml version="1.0"?>
<company>
    <staff id="1001">
        <firstname>yong</firstname>
        <lastname>mook kim</lastname>
        <nickname>mkyong</nickname>
        <salary>100000</salary>
    </staff>
    <staff id="2001">
        <firstname>low</firstname>
        <lastname>yin fong</lastname>
        <nickname>fong fong</nickname>
        <salary>200000</salary>
    </staff>
</company>

Java-Code:

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;
import java.io.File;

public class ReadXMLFile {

  public static void main(String argv[]) {
    try {
    File fXmlFile = new File("/Users/mkyong/staff.xml");
    DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
    DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
    Document doc = dBuilder.parse(fXmlFile);
    doc.getDocumentElement().normalize();

    System.out.println("Root element :" + doc.getDocumentElement().getNodeName());
    NodeList nList = doc.getElementsByTagName("staff");
    System.out.println("----------------------------");

    for (int temp = 0; temp < nList.getLength(); temp++) {
        Node nNode = nList.item(temp);
        System.out.println("\nCurrent Element :" + nNode.getNodeName());
        if (nNode.getNodeType() == Node.ELEMENT_NODE) {
            Element eElement = (Element) nNode;
            System.out.println("Staff id : "
                               + eElement.getAttribute("id"));
            System.out.println("First Name : "
                               + eElement.getElementsByTagName("firstname")
                                 .item(0).getTextContent());
            System.out.println("Last Name : "
                               + eElement.getElementsByTagName("lastname")
                                 .item(0).getTextContent());
            System.out.println("Nick Name : "
                               + eElement.getElementsByTagName("nickname")
                                 .item(0).getTextContent());
            System.out.println("Salary : "
                               + eElement.getElementsByTagName("salary")
                                 .item(0).getTextContent());
        }
    }
    } catch (Exception e) {
    e.printStackTrace();
    }
  }
}

Ausgabe:

----------------

Root element :company
----------------------------

Current Element :staff
Staff id : 1001
First Name : yong
Last Name : mook kim
Nick Name : mkyong
Salary : 100000

Current Element :staff
Staff id : 2001
First Name : low
Last Name : yin fong
Nick Name : fong fong
Salary : 200000

Habe ich empfohlen, die dies Lesen: Normalisierung im DOM-parsing mit java - wie funktioniert das?

Beispiel Quelle.

InformationsquelleAutor der Antwort Ran Adler

Was ist die beste/einfachste Bibliothek
verwenden Sie, um zu Lesen, im Werte von
diese Datei?

Als Sie für Fragen der einfachste Bibliothek, fühle ich mich verpflichtet hinzuzufügen, ein Ansatz, ganz anders als im Guillaume top-Antwort gestimmt. (Die anderen Antworten, sjbotha ist JDOM erwähnen, die am nächsten ist, was ich vorschlagen).

Ich bin gekommen, zu glauben, dass für die XML-handling in Java mit dem standard-JDK-tools ist sicherlich nicht der einfachste Weg, und auch das nur unter bestimmten Umständen (z.B. nicht in der Lage, zu verwenden 3rd-party-Bibliotheken, aus irgendeinem Grund) es ist der beste Weg.

Erwägen Sie stattdessen, mit einem guten XML-Bibliothek, wie XOM. Hier ist, wie zu Lesen eine XML-Datei in eine nu.xom.Document Objekt:

import nu.xom.Builder;
import nu.xom.Document;
import java.io.File;

[...]

File file = new File("some/path");
Document document = new Builder().build(file);

So, dies war nur ein wenig einfacher, als das Lesen der Datei in org.w3c.dom.Document war nicht sehr kompliziert, die "Reine JDK" - Ansatz. Aber die Vorteile der Verwendung eine gute Bibliothek, nur starten Sie hier! Was auch immer Sie tun, mit Ihrem XML -, Sie werden oft Weg mit sehr viel einfachere Lösungen, und weniger von Ihren eigenen code zu halten, wenn Sie eine Bibliothek benutzen, wie XOM. Als Beispiele betrachten diese vs. dieseoder diese vs. dieseoder dieser Beitrag enthält sowohl XOM und W3C-DOM-Beispiele.

Andere bieten gegen-Argumente (wie diese) warum kleben Javas standard-XML-APIs kann es Wert sein - diese haben wahrscheinlich Verdienst, zumindest in einigen Fällen, obwohl ich persönlich nicht abonnieren Sie alle von Ihnen. In jedem Fall, bei der Wahl die eine oder andere Weise, es ist gut, sich bewusst zu sein, beide Seiten der Geschichte.

(Diese Antwort ist Teil meiner Bewertung des XOM, ist ein starker Anwärter in meinem Suche nach der besten Java-XML-Bibliothek zu ersetzen, dom4j.)

InformationsquelleAutor der Antwort Jonik

JAXB ist einfach zu bedienen, und es ist in Java 6 SE. Mit JAXB, oder anderen XML-Datenbindung, wie Einfach Sie nicht haben, um die XML selbst, ist die meiste Arbeit ist getan, die von der Bibliothek. Die grundlegende Verwendung ist auf Anmerkung hinzufügen, um Ihre bestehenden POJO. Diese Annotationen werden dann verwendet, um ein XML-Schema erstellen für Sie die Daten und auch beim Lesen/schreiben von Daten aus/in eine Datei.

InformationsquelleAutor der Antwort Pierre Buyle

Abhängig von Ihrer Anwendung und den Umfang der cfg-Datei, eine properties-Datei ist möglicherweise der einfachste. Sicher, es ist nicht so elegant wie xml, aber es sicherlich einfacher.

InformationsquelleAutor der Antwort tmeisenh

Einfachsten bei weitem, werden Einfache http://simple.sourceforge.netmüssen Sie nur kommentieren ein einzelnes Objekt wie so

@Root
public class Entry {

   @Attribute
   private String a
   @Attribute
   private int b;
   @Element
   private Date c;

   public String getSomething() {
      return a;
   }
} 

@Root
public class Configuration {

   @ElementList(inline=true)
   private List<Entry> entries;

   public List<Entry> getEntries() { 
      return entries;
   }
}

Dann alles, was Sie zu tun haben, Lesen die gesamte Datei geben Sie den Speicherort und es wird analysiert, und füllen Sie die annotierte POJO ist. Dieser wird alles tun, den Typ-Konvertierungen und-Validierung. Sie können auch Anmerkungen für die persister-Rückrufe, falls erforderlich. Lesen können Sie das wie so.

Serializer serializer = new Persister();
Configuration configuraiton = serializer.read(Configuration.class, fileLocation);

InformationsquelleAutor der Antwort ng.

Hier ist eine wirklich einfache API, die ich erstellt für das Lesen von XML-Dateien in Java. Es ist unglaublich einfach und leicht zu bedienen. Hoffe, es ist nützlich für Sie.

http://argonrain.wordpress.com/2009/10/27/000/

InformationsquelleAutor der Antwort Chris