Souhaitez-vous apprendre à lire et écrire un fichier XML à partir de Java ?
Les fichiers XML sont utilisés à diverses fins, y compris le stockage de données. Avant que JSON ne devienne populaire, XML était le format préféré pour représenter, stocker et transporter des données structurées. Même si la popularité de XML a diminué ces dernières années, vous pouvez le rencontrer occasionnellement, il est donc important d'apprendre à l'utiliser à partir du code.
Java Standard Edition (SE) inclut l'API Java pour le traitement XML (JAXP) , qui est un terme générique couvrant la plupart des aspects du traitement XML. Ceux-ci incluent :
Dans cet article, nous utilisons l'API DOM pour montrer comment lire et écrire des fichiers XML à partir de java. Nous couvrirons les deux autres API dans de futurs articles.
Pour les besoins de cet article, nous démontrons les concepts à l'aide de l'exemple XML suivant, qui peut être trouvé ici :
Gambardella, Matthieu
Guide du développeur XML
Ordinateur
44,95
2000-10-01
Un regard approfondi sur la création d'applications
avec XML.
Ralls, Kim
...
Examinons les étapes de base requises pour lire un fichier XML à l'aide de l'API DOM.
La première étape consiste à obtenir une instance de DocumentBuilder . Le constructeur est utilisé pour analyser les documents XML. Pour une utilisation de base, nous procédons ainsi :
DocumentBuilderFactory factory =DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(false);
factory.setValidating(false);
Générateur de DocumentBuilder =factory.newDocumentBuilder();
Nous pouvons maintenant charger tout le document en mémoire à partir de l'élément racine XML. Dans notre exemple, il s'agit du catalogue élément.
Fichier fichier =... ; // Fichier XML à lire
Document document =builder.parse(fichier);
Catalogue d'éléments =document.getDocumentElement();
Et c'est tout, les amis ! L'API DOM pour lire un XML est vraiment simple. Vous avez maintenant accès à l'ensemble du document XML à partir de son élément racine, catalog . Voyons maintenant comment travailler avec.
Maintenant que nous avons la racine XML Element , nous pouvons utiliser l'API DOM pour extraire des pépites d'informations intéressantes.
Obtenez tout le livre enfants de l'élément racine et bouclez dessus. Notez que getChildNodes() renvoie tout enfants, y compris le texte, les commentaires, etc. Pour notre propos, nous n'avons besoin que des éléments enfants, nous ignorons donc les autres.
NodeList livres =catalog.getChildNodes();
pour (int je =0, ii =0, n =livres.getLength(); je Nœud enfant =livres.item(i);
if ( enfant.getNodeType() !=Node.ELEMENT_NODE )
Continuez;
Livre d'élément =(élément) enfant ;
// travailler avec l'élément livre ici
}
Comment trouvez-vous un élément enfant spécifique, étant donné le parent ? La méthode statique suivante renvoie le premier élément correspondant s'il est trouvé, ou null. Comme vous pouvez le voir, la procédure implique d'obtenir la liste des nœuds enfants et de les parcourir en boucle en sélectionnant les nœuds d'élément avec le nom spécifié.
Nœud privé statique findFirstNamedElement(Node parent,String tagName)
{
NodeList enfants =parent.getChildNodes();
for (int je =0, in =children.getLength(); je Nœud enfant =children.item(i);
if ( enfant.getNodeType() !=Node.ELEMENT_NODE )
Continuez;
si ( enfant.getNodeName().equals(tagName) )
retour enfant;
}
renvoie nul ;
}
Notez que l'API DOM traite le contenu textuel d'un élément comme un nœud séparé de type TEXT_NODE . De plus, le contenu du texte peut être divisé en plusieurs nœuds de texte adjacents. Le traitement spécial suivant est donc nécessaire pour récupérer le contenu textuel d'un élément.
String privé statique getCharacterData(Node parent)
{
texte StringBuilder =new StringBuilder();
si ( parent ==null )
return text.toString();
NodeList enfants =parent.getChildNodes();
for (int k =0, kn =children.getLength(); k Nœud enfant =children.item(k);
if ( enfant.getNodeType() !=Node.TEXT_NODE )
Pause;
text.append(child.getNodeValue());
}
return text.toString();
}
Armés de ces fonctions pratiques, examinons maintenant un code pour répertorier certaines informations de notre exemple XML. Nous aimerions afficher des informations détaillées pour chaque livre, telles qu'elles seraient disponibles dans un catalogue de livres.
NodeList livres =catalog.getChildNodes();
pour (int je =0, ii =0, n =livres.getLength(); je Nœud enfant =livres.item(i);
if ( enfant.getNodeType() !=Node.ELEMENT_NODE )
Continuez;
Livre d'élément =(élément) enfant ;
ii++ ;
ID de chaîne =livre.getAttribute("id");
Chaîne auteur =getCharacterData(findFirstNamedElement(enfant,"auteur"));
Titre de la chaîne =getCharacterData(findFirstNamedElement(child,"title"));
Genre de chaîne =getCharacterData(findFirstNamedElement(child,"genre"));
Prix de chaîne =getCharacterData(findFirstNamedElement(enfant,"prix"));
Chaîne pubdate =getCharacterData(findFirstNamedElement(child,"pubdate"));
Chaîne descr =getCharacterData(findFirstNamedElement(child,"description"));
System.out.printf("%3d. ID de livre =%s
" +
" auteurs
" +
" titre :%s
" +
" genre :%s
" +
" des prix
" +
" publication :%s
" +
" description :%s
",
ii, id, auteur, titre, genre, prix, pubdate, descr);
}
Java fournit l'API XML Tranform pour transformer des données XML. Nous utilisons cette API avec la transformation d'identité pour générer une sortie.
Par exemple, ajoutons un nouveau livre élément de l'exemple de catalogue présenté ci-dessus. Les détails du livre (tels que auteur , titre , etc.) peuvent être obtenus en externe, peut-être à partir d'un fichier de propriétés ou d'une base de données. Nous utilisons le fichier de propriétés suivant pour charger les données.
id=bk113
auteur=Jane Austen
title=Orgueil et préjugés
genre=Romance
prix=6.99
date_publiée=2010-04-01
description="C'est une vérité universellement reconnue qu'un célibataire en possession d'une bonne fortune doit avoir besoin d'une femme." Ainsi commence Pride and Prejudice, la comédie pleine d'esprit de Jane Austen sur les mœurs - l'un des romans les plus populaires de tous les temps - qui met en scène des combats magnifiquement civilisés entre le fier M. Darcy et la prévenue Elizabeth Bennet alors qu'ils jouent leur cour fougueuse dans une série de intrigues de salon du XVIIIe siècle.
La première étape consiste à analyser le fichier XML existant en utilisant la méthode présentée ci-dessus. Le code est également affiché ci-dessous.
Fichier fichier =... ; // Fichier XML à lire
Document document =builder.parse(fichier);
Catalogue d'éléments =document.getDocumentElement();
Nous chargeons les données du fichier de propriétés en utilisant les Propriétés classe fournie avec java. Le code est assez simple et illustré ci-dessous.
String propsFile =...;
Propriétés props =new Properties();
essayez (FileReader in =new FileReader(propsFile)) {
props.load(dans);
}
Une fois les propriétés chargées, nous récupérons les valeurs que nous voulons ajouter à partir du fichier de propriétés.
ID de chaîne =props.getProperty("id");
chaîne auteur =props.getProperty("author");
Titre de la chaîne =props.getProperty("title");
Genre de chaîne =props.getProperty("genre");
prix de la chaîne =props.getProperty("prix");
Chaîne publier_date =props.getProperty("publish_date");
Chaîne descr =props.getProperty("description");
Créons maintenant un livre vide élément.
Élément livre =document.createElement("livre");
livre.setAttribute("id", id);
Ajouter les éléments enfants au livre est banal. Pour plus de commodité, nous collectons les noms d'éléments requis dans une Liste et ajoutez les valeurs dans une boucle.
List elnames =Arrays.asList("auteur", "titre", "genre", "prix",
"date_publier", "description");
for (String elname :elnames) {
Element el =document.createElement(elname);
Texte text =document.createTextNode(props.getProperty(elname));
el.appendChild(text);
livre.appendChild(el);
}
catalog.appendChild(livre);
Et c'est ainsi que cela se fait. Le catalogue l'élément a maintenant le nouveau livre élément ajouté. Il ne reste plus qu'à écrire le XML mis à jour.
Pour écrire le XML, nous avons besoin d'une instance de Transformer qui est créé comme indiqué ci-dessous. Notez que nous demandons l'indentation du XML de sortie à l'aide de setOutputProperty() méthode.
TransformerFactory tfact =TransformerFactory.newInstance();
Transformer tform =tfact.newTransformer();
tform.setOutputProperty(OutputKeys.INDENT, "oui");
tform.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "3");
La dernière étape de la génération de la sortie XML consiste à appliquer la transformation. Le résultat apparaît sur le flux de sortie, System.out .
tform.transform(new DOMSource(document), new StreamResult(System.out));
Pour écrire la sortie directement dans un fichier, utilisez ce qui suit.
tform.transform(new DOMSource(document), new StreamResult(new File("output.xml")));
Et cela conclut cet article sur la lecture et l'écriture de fichiers XML à l'aide de l'API DOM.
Avez-vous utilisé l'API DOM dans vos applications ? Comment a-t-il fonctionné ? Veuillez nous en informer dans les commentaires ci-dessous.