Quel est le meilleur moyen/le plus simple de lire dans un fichier XML dans une application Java? [fermé]

Code XML:

<?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>

Code Java:

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

Sortie:

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

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

Je vous ai recommandé de lire ceci: Normalisation dans l'analyse DOM avec java - comment ça marche?

Exemple de source.

Y a-t-il une raison particulière pour laquelle vous avez choisi des fichiers de configuration XML? J'ai fait des configs XML dans le passé, et ils se sont souvent avérés être plus un mal de tête que toute autre chose.

Je suppose que la vraie question est de savoir si l'utilisation de quelque chose comme l'API Preferences pourrait mieux fonctionner dans votre situation.

Raisons d'utiliser l'API Preferences sur une solution XML roll-your-own:

• Évite la laideur XML typique (DocumentFactory, etc.), tout en évitant la 3ème bibliothèques de parties pour fournir le backend XML

• Prise en charge intégrée des valeurs par défaut (aucune manipulation spéciale requise pour les entrées manquantes/corrompues/invalides)

• Pas besoin de désinfecter les valeurs pour le stockage XML (encapsulation CDATA, etc.)

• Statut garanti du magasin de sauvegarde (pas besoin d'écrire constamment XML sur le disque)

• Le magasin de sauvegarde est configurable (fichier sur disque, LDAP, etc.)

• Accès multithread à toutes les préférences gratuitement

Quelle est la meilleure/la plus simple bibliothèque pour utiliser pour lire les valeurs de ce fichier?

Comme vous demandez la bibliothèquela plus simple , je me sens obligé d'ajouter une approche tout à fait différente de celle deLa réponse la plus votée de Guillaume . (Parmi les autres réponses, la mention JDOM de sjbotha est la plus proche de ce que je suggère).

J'en suis venu à penser que pour la gestion XML en Java, l'utilisation des outils JDK standard est certainement pas le moyen le plus simple, et que seulement dans certaines circonstances (comme ne pas pouvoir utiliser des bibliothèques tierces, pour une raison quelconque), c'est le meilleur moyen.

Au lieu de cela, envisagez d'utiliser une bonne bibliothèque XML, telle que XOM. Voici comment lire un fichier XML dans un nu.xom.Document objet:

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

[...]

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

Donc, c'était juste un peu plus simple, car la lecture du fichier dans org.w3c.dom.Document n'était pas très compliquée non plus, dans l'approche "pure JDK". Mais les avantages d'utiliser une bonne bibliothèque ne commencent qu'ici! Quoi vous faites avec votre XML, vous vous en sortirez souvent avec des solutions beaucoup plus simples, et moins de votre propre code à maintenir, lorsque vous utilisez une bibliothèque comme XOM. À titre d'exemples, envisager ce vs ce, ou ce vs ce, ou ce post contenant à la fois XOM et DOM du W3C exemples.

D'autres fourniront des contre-arguments (comme ceux-ci) pour expliquer pourquoi s'en tenir aux API XML standard de Java peut en valoir la peine - celles-ci ont probablement du mérite, au moins dans certains cas, même si personnellement je ne suis pas abonné à tous. Dans tous les cas, lors du choix d'une manière ou l'autre, il est bon d'être conscient des deux côtés de l'histoire.

(Cette réponse fait partie de mon évaluation de XOM, qui est un concurrent sérieux dans ma quête pour trouver la meilleure bibliothèque XML Java pour remplacer dom4j.)

Regardez dansJAXB .

JAXB est simple à utiliser et est inclus dans Java 6 SE. Avec JAXB, ou d'autres liaisons de données XML telles que Simple, vous n'avez pas à gérer le XML vous-même, la plupart du travail est effectué par la bibliothèque. L'utilisation de base est d'ajouter une annotation à votre POJO existant. Ces annotations sont ensuite utilisées pour générer un Schéma XML pour les données et également lors de la lecture/écriture de vos données depuis/vers un fichier.

Je n'ai utilisé que jdom. Il est assez facile.

Aller ici pour la documentation et pour le télécharger: http://www.jdom.org/

Si vous avez un document très très volumineux, il est préférable de ne pas tout lire en mémoire, mais d'utiliser un analyseur SAX qui appelle vos méthodes lorsqu'il frappe certaines balises et attributs. Vous devez ensuite créer une machine d'état pour traiter les appels entrants.

Selon votre application et la portée du fichier cfg, un fichier de propriétés peut être le plus simple. Bien sûr, ce n'est pas aussi élégant que xml, mais c'est certainement plus facile.

Utilisation java.beans.XMLDecoder, partie du noyau Java SE depuis 1.4.

XMLDecoder input = new XMLDecoder(new FileInputStream("some/path.xml"));
MyConfig config = (MyConfig) input.readObject();
input.close();

, Il est facile de écrire les fichiers de configuration à la main, ou utilisez le raccourci XMLEncoder avec une configuration à écrire de nouveaux objets au moment de l'exécution.

Le plus simple de loin sera Simple http://simple.sourceforge.net , il vous suffit d'annoter un seul objet comme ceci

@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;
   }
}

Ensuite, tout ce que vous avez à faire pour lire le fichier entier est de spécifier l'emplacement et il analysera et remplira les POJO annotés. Cela fera toutes les conversions de type et la validation. Vous pouvez également annoter pour les rappels persistants si nécessaire. La lecture peut être faite comme ça.

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

C'est ce que j'utilise. http://marketmovers.blogspot.com/2014/02/the-easy-way-to-read-xml-in-java.html Il se trouve au-dessus des outils JDK standard, donc s'il manque une fonctionnalité, vous pouvez toujours utiliser la version JDK.

Cela rend vraiment les choses plus faciles pour moi. C'est particulièrement agréable quand je lis un fichier de configuration qui a été enregistré par une ancienne version du logiciel ou qui a été modifié manuellement par un utilisateur. Il est très robuste et ne lèvera une exception si certaines données ne sont pas exactement dans le format que vous attendez.

Voici une API très simple que j'ai créée pour lire des fichiers XML simples en Java. C'est incroyablement simple et facile à utiliser. J'espère que c'est utile pour vous.

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