Comment configurer le fichier XML de persistance Java

Choisir un format

Écrire un fichier de configuration est une chose assez compliquée. J'ai essayé d'enregistrer les éléments de configuration dans un fichier texte séparé par des virgules et j'ai essayé d'enregistrer les éléments de configuration dans YAML et XML très détaillés. Pour les fichiers de configuration, le plus important est d'avoir de la cohérence et de la régularité. Ils permettent d'écrire du code facilement et rapidement et d'analyser les données du fichier de configuration en même temps, lorsque l'utilisateur décide d'apporter des modifications, il est facile de les enregistrer ; eux et mettre à jour la configuration.

Il existe actuellement plusieurs formats de fichiers de configuration populaires. Pour les formats de fichiers de configuration les plus courants, Java dispose de bibliothèques correspondantes. Dans cet article, j'utiliserai le format XML. Pour certains projets, vous pouvez choisir d'utiliser XML car l'une de ses fonctionnalités remarquables est sa capacité à fournir une multitude de métadonnées pertinentes pour les données qu'il contient, tandis que pour d'autres projets, vous ne pouvez pas choisir XML en raison de sa verbosité. Travailler avec XML en Java est très simple car il inclut par défaut de nombreuses bibliothèques XML robustes.

Bases de XML

Discuter de XML est un sujet important. J'ai un livre sur XML de plus de 700 pages. Heureusement, travailler avec XML ne nécessite pas une connaissance approfondie de ses nombreuses fonctionnalités. Tout comme HTML, XML est un langage de balisage en couches avec des balises d'ouverture et de fermeture, chacune pouvant contenir zéro ou plusieurs données. Voici un exemple simple d'extrait de XML :

<xml>
  <node>
    <element>Penguin</element>
  </node>
</xml>

Dans cet exemple autodescriptif, l'analyseur XML utilise les concepts suivants :

#🎜🎜 #
• Document Document : La balise b2a0af5a8fd26276da50279a1c63a57a marque le début d'un document et la balise 21118965b89073f60271ef4a3b5d3c58 marque la fin de ce document.

b2a0af5a8fd26276da50279a1c63a57a 标签标志着一个 文档 的开始，21118965b89073f60271ef4a3b5d3c58 标签标志着这个文档的结束。

• 节点Node：37493a7a244a2c0740719da11c0bbc72 标签代表了一个 节点。

• 元素Element：1dd643d91c792abd0a34d1b312e2f207Penguina24c0203f0ae689239f065103120aae7 中，从开头的 068bb6aff869d1ddc703642984eade01 表示了一个 元素。

• 内容Content： 在 1dd643d91c792abd0a34d1b312e2f207 元素里，字符串 Penguin 就是 内容。

不管你信不信，只要了解了以上几个概念，你就可以开始编写、解析 XML 文件了。

创建一个示例配置文件

要学习如何解析 XML 文件，只需要一个极简的示例文件就够了。假设现在有一个配置文件，里面保存的是关于一个图形界面窗口的属性：

<xml>
  <window>
    <theme>Dark</theme>
    <fullscreen>0</fullscreen>
    <icons>Tango</icons>
</window>
</xml>

创建一个名为 ~/.config/DemoXMLParser 的目录：

$ mkdir ~/.config/DemoXMLParser

在 Linux 中，~/.config 目录是存放配置文件的默认位置，这是在 自由桌面工作组 的规范中定义的。如果你正在使用一个不遵守 自由桌面工作组Freedesktop标准的操作系统，你也仍然可以使用这个目录，只不过你需要自己创建这些目录了。

复制 XML 的示例配置文件，粘贴并保存为 ~/.config/DemoXMLParser/myconfig.xml 文件。

使用 Java 解析 XML

如果你是 Java 的初学者，你可以先阅读我写的 面向 Java 入门开发者的 7 个小技巧。一旦你对 Java 比较熟悉了，打开你最喜爱的集成开发工具（IDE），创建一个新工程。我会把我的新工程命名为 myConfigParser。

刚开始先不要太关注依赖导入和异常捕获这些，你可以先尝试用 javax 和 java.io 包里的标准 Java 扩展来实例化一个解析器。如果你使用了 IDE，它会提示你导入合适的依赖。如果没有，你也可以在文章稍后的部分找到完整的代码，里面就有完整的依赖列表。

Path configPath = Paths.get(System.getProperty("user.home"), ".config", "DemoXMLParser");
File configFile = new File(configPath.toString(), "myconfig.xml");
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = null;
builder = factory.newDocumentBuilder();
Document doc = null;
doc = builder.parse(configFile);
doc.getDocumentElement().normalize();

这段示例代码使用了 java.nio.Paths 类来找到用户的主目录，然后在拼接上默认配置文件的路径。接着，它用 java.io.File 类来把配置文件定义为一个 File 对象。

紧接着，它使用了 javax.xml.parsers.DocumentBuilder 和 javax.xml.parsers.DocumentBuilderFactory 这两个类来创建一个内部的文档构造器，这样 Java 程序就可以导入并解析 XML 数据了。

最后，Java 创建一个叫 doc 的文档对象，并且把 configFile 文件加载到这个对象里。通过使用 org.w3c.dom

Node Node : 37493a7a244a2c0740719da11c0bbc72 Le label représente un nœud.

#🎜🎜#Element : 1dd643d91c792abd0a34d1b312e2f207Penguina24c0203f0ae689239f065103120aae7 , du début 62e230f9eae9ba3a0c6a3b81caf0b20c représente un élément. #🎜🎜##🎜🎜##🎜🎜#Content : Dans l'élément 1dd643d91c792abd0a34d1b312e2f207, la chaîne Penguin est le contenu. #🎜🎜##🎜🎜#Croyez-le ou non, tant que vous comprenez les concepts ci-dessus, vous pouvez commencer à écrire et à analyser des fichiers XML. #🎜🎜##🎜🎜#Créez un exemple de fichier de configuration #🎜🎜##🎜🎜#Pour apprendre à analyser les fichiers XML, tout ce dont vous avez besoin est un exemple de fichier minimaliste. Supposons qu'il existe un fichier de configuration qui enregistre les propriétés d'une fenêtre d'interface graphique : #🎜🎜#

NodeList nodes = doc.getElementsByTagName("window");
for (int i = 0; i < nodes.getLength(); i++) {
 Node mynode = nodes.item(i);
 System.out.println("Property = " + mynode.getNodeName());
 if (mynode.getNodeType() == Node.ELEMENT_NODE) {
   Element myelement = (Element) mynode;
   System.out.println("Theme = " + myelement.getElementsByTagName("theme").item(0).getTextContent());
   System.out.println("Fullscreen = " + myelement.getElementsByTagName("fullscreen").item(0).getTextContent());
   System.out.println("Icon set = " + myelement.getElementsByTagName("icons").item(0).getTextContent());
 }
}

#🎜🎜#Créez un répertoire nommé ~/.config/DemoXMLParser : #🎜 🎜#

$ java ./DemoXMLParser.java
Property = window
Theme = Dark
Fullscreen = 0
Icon set = Tango

# 🎜🎜#Sous Linux, le répertoire ~/.config est l'emplacement par défaut pour stocker les fichiers de configuration, qui est défini dans les spécifications du Free Desktop Working Group. Si vous utilisez un système d'exploitation qui n'adhère pas aux standards Freedesktop, vous pouvez toujours utiliser ce répertoire, mais vous devrez créer vous-même ces répertoires. #🎜🎜##🎜🎜#Copiez l'exemple de fichier de configuration XML, collez-le et enregistrez-le sous le nom de fichier ~/.config/DemoXMLParser/myconfig.xml. #🎜🎜##🎜🎜#Utiliser Java pour analyser XML#🎜🎜##🎜🎜#Si vous êtes débutant en Java, vous pouvez d'abord lire mes 7 conseils pour les développeurs Java débutants. Une fois que vous êtes plus familier avec Java, ouvrez votre outil de développement intégré (IDE) préféré et créez un nouveau projet. Je nommerai mon nouveau projet myConfigParser. #🎜🎜##🎜🎜#Ne prêtez pas trop attention aux importations de dépendances et à la capture d'exceptions au début. Vous pouvez essayer d'utiliser Java standard dans javax et java.io<.> paquets en premier Extension pour instancier un analyseur. Si vous utilisez un IDE, il vous demandera d'importer les dépendances appropriées. Sinon, vous pouvez trouver le code complet plus loin dans l’article, qui contient une liste complète des dépendances. #🎜🎜#<pre class="brush:java;">package myConfigParser; import java.io.File; import java.io.IOException; import java.nio.file.Path; import java.nio.file.Paths; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.NamedNodeMap; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import org.xml.sax.SAXException; public class ConfigParser { public static void main(String[] args) { Path configPath = Paths.get(System.getProperty(&quot;user.home&quot;), &quot;.config&quot;, &quot;DemoXMLParser&quot;); File configFile = new File(configPath.toString(), &quot;myconfig.xml&quot;); DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = null; try { builder = factory.newDocumentBuilder(); } catch (ParserConfigurationException e) { e.printStackTrace(); } Document doc = null; try { doc = builder.parse(configFile); } catch (SAXException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } doc.getDocumentElement().normalize(); NodeList nodes = doc.getElementsByTagName(&quot;window&quot;); for (int i = 0; i &lt; nodes.getLength(); i++) { Node mynode = nodes.item(i); System.out.println(&quot;Property = &quot; + mynode.getNodeName()); if (mynode.getNodeType() == Node.ELEMENT_NODE) { Element myelement = (Element) mynode; System.out.println(&quot;Theme = &quot; + myelement.getElementsByTagName(&quot;theme&quot;).item(0).getTextContent()); System.out.println(&quot;Fullscreen = &quot; + myelement.getElementsByTagName(&quot;fullscreen&quot;).item(0).getTextContent()); System.out.println(&quot;Icon set = &quot; + myelement.getElementsByTagName(&quot;icons&quot;).item(0).getTextContent()); } // close if } // close for } // close method } //close class</pre>#🎜🎜#Cet exemple de code utilise la classe <code>java.nio.Paths pour trouver le répertoire personnel de l'utilisateur, puis découpe le chemin d'accès au fichier de configuration par défaut. Ensuite, il utilise la classe java.io.File pour définir le fichier de configuration en tant qu'objet File. #🎜🎜##🎜🎜#Ensuite, il utilise les deux classes javax.xml.parsers.DocumentBuilder et javax.xml.parsers.DocumentBuilderFactory pour créer un constructeur de document interne afin que les programmes Java puissent importer et analyser des données XML. #🎜🎜##🎜🎜#Enfin, Java crée un objet document appelé doc et charge le fichier configFile dans cet objet. Il lit et normalise les données XML à l'aide du package org.w3c.dom. #🎜🎜##🎜🎜#C'est essentiellement ça. En théorie, vous avez terminé le travail d’analyse des données. Cependant, l'analyse des données est de peu d'utilité si vous n'avez pas accès aux données. Alors, écrivons quelques requêtes supplémentaires pour lire les valeurs de propriétés importantes de votre configuration. #🎜🎜#

使用 Java 访问 XML 的值

从你已经读取的 XML 文档中获取数据，其实就是要先找到一个特定的节点，然后遍历它包含的所有元素。通常我们会使用多个循环语句来遍历节点中的元素，但是为了保持代码可读性，我会尽可能少地使用循环语句：

NodeList nodes = doc.getElementsByTagName("window");
for (int i = 0; i < nodes.getLength(); i++) {
 Node mynode = nodes.item(i);
 System.out.println("Property = " + mynode.getNodeName());
 if (mynode.getNodeType() == Node.ELEMENT_NODE) {
   Element myelement = (Element) mynode;
   System.out.println("Theme = " + myelement.getElementsByTagName("theme").item(0).getTextContent());
   System.out.println("Fullscreen = " + myelement.getElementsByTagName("fullscreen").item(0).getTextContent());
   System.out.println("Icon set = " + myelement.getElementsByTagName("icons").item(0).getTextContent());
 }
}

这段示例代码使用了 org.w3c.dom.NodeList 类，创建了一个名为 nodes 的 NodeList 对象。这个对象包含了所有名字匹配字符串 window 的子节点，实际上这样的节点只有一个，因为本文的示例配置文件中只配置了一个。

紧接着，它使用了一个 for 循环来遍历 nodes 列表。具体过程是：根据节点出现的顺序逐个取出，然后交给一个 if-then 子句处理。这个 if-then 子句创建了一个名为 myelement 的 Element 对象，其中包含了当前节点下的所有元素。你可以使用例如 getChildNodes 和 getElementById 方法来查询这些元素，项目中还 记录了 其他查询方法。

在这个示例中，每个元素就是配置的键。而配置的值储存在元素的内容中，你可以使用 .getTextContent 方法来提取出配置的值。

在你的 IDE 中运行代码（或者运行编译后的二进制文件）：

$ java ./DemoXMLParser.java
Property = window
Theme = Dark
Fullscreen = 0
Icon set = Tango

下面是完整的代码示例：

package myConfigParser;
import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
public class ConfigParser {
        public static void main(String[] args) {
                Path configPath = Paths.get(System.getProperty("user.home"), ".config", "DemoXMLParser");
                File configFile = new File(configPath.toString(), "myconfig.xml");
                DocumentBuilderFactory factory =
                DocumentBuilderFactory.newInstance();
                DocumentBuilder builder = null;
                try {
                        builder = factory.newDocumentBuilder();
                } catch (ParserConfigurationException e) {
                        e.printStackTrace();
                }
                Document doc = null;
                try {
                        doc = builder.parse(configFile);
                } catch (SAXException e) {
                        e.printStackTrace();
                } catch (IOException e) {
                        e.printStackTrace();
                }
        doc.getDocumentElement().normalize();
        NodeList nodes = doc.getElementsByTagName("window");
        for (int i = 0; i < nodes.getLength(); i++) {
           Node mynode = nodes.item(i);
           System.out.println("Property = " + mynode.getNodeName());
           if (mynode.getNodeType() == Node.ELEMENT_NODE) {
               Element myelement = (Element) mynode;
               System.out.println("Theme = " + myelement.getElementsByTagName("theme").item(0).getTextContent());
               System.out.println("Fullscreen = " + myelement.getElementsByTagName("fullscreen").item(0).getTextContent());
               System.out.println("Icon set = " + myelement.getElementsByTagName("icons").item(0).getTextContent());
           } // close if
        } // close for
    } // close method
} //close class

使用 Java 更新 XML

用户时不时地会改变某个偏好项，这时候 org.w3c.dom 库就可以帮助你更新某个 XML 元素的内容。你只需要选择这个 XML 元素，就像你读取它时那样。不过，此时你不再使用 .getTextContent 方法，而是使用 .setTextContent 方法。

updatePref = myelement.getElementsByTagName("fullscreen").item(0);
updatePref.setTextContent("1");
System.out.println("Updated fullscreen to " + myelement.getElementsByTagName("fullscreen").item(0).getTextContent());

这么做会改变应用程序内存中的 XML 文档，但是还没有把数据写回到磁盘上。配合使用 javax 和 w3c 库，你就可以把读取到的 XML 内容写回到配置文件中。

TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer xtransform;
xtransform = transformerFactory.newTransformer();
DOMSource mydom = new DOMSource(doc);
StreamResult streamResult = new StreamResult(configFile);
xtransform.transform(mydom, streamResult);

这么做会没有警告地写入转换后的数据，并覆盖掉之前的配置。

下面是完整的代码，包括更新 XML 的操作：

package myConfigParser;
import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
public class ConfigParser {
        public static void main(String[] args) {
                Path configPath = Paths.get(System.getProperty("user.home"), ".config", "DemoXMLParser");
                File configFile = new File(configPath.toString(), "myconfig.xml");
                DocumentBuilderFactory factory =
                DocumentBuilderFactory.newInstance();
                DocumentBuilder builder = null;
                try {
                        builder = factory.newDocumentBuilder();
                } catch (ParserConfigurationException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                Document doc = null;
                try {
                        doc = builder.parse(configFile);
                } catch (SAXException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        doc.getDocumentElement().normalize();
        Node updatePref = null;
//        NodeList nodes = doc.getChildNodes();
        NodeList nodes = doc.getElementsByTagName("window");
        for (int i = 0; i < nodes.getLength(); i++) {
           Node mynode = nodes.item(i);
           System.out.println("Property = " + mynode.getNodeName());
           if (mynode.getNodeType() == Node.ELEMENT_NODE) {
               Element myelement = (Element) mynode;
               System.out.println("Theme = " + myelement.getElementsByTagName("theme").item(0).getTextContent());
               System.out.println("Fullscreen = " + myelement.getElementsByTagName("fullscreen").item(0).getTextContent());
               System.out.println("Icon set = " + myelement.getElementsByTagName("icons").item(0).getTextContent());
               updatePref = myelement.getElementsByTagName("fullscreen").item(0);
               updatePref.setTextContent("2");
               System.out.println("Updated fullscreen to " + myelement.getElementsByTagName("fullscreen").item(0).getTextContent());          
           } // close if
        }// close for
        // write DOM back to the file
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer xtransform;
        DOMSource mydom = new DOMSource(doc);
        StreamResult streamResult = new StreamResult(configFile);
        try {
                xtransform = transformerFactory.newTransformer();
                xtransform.transform(mydom, streamResult);
        } catch (TransformerException e) {
                e.printStackTrace();
        }
    } // close method
} //close class

如何保证配置不出问题

编写配置文件看上去是一个还挺简单的任务。一开始，你可能会用一个简单的文本格式，因为你的应用程序只要寥寥几个配置项而已。但是，随着你引入了更多的配置项，读取或者写入错误的数据可能会给你的应用程序带来意料之外的错误。一种帮助你保持配置过程安全、不出错的方法，就是使用类似 XML 的规范格式，然后依靠你用的编程语言的内置功能来处理这些复杂的事情。

这也正是我喜欢使用 Java 和 XML 的原因。每当我试图读取错误的配置值时，Java 就会提醒我。通常，这是由于我在代码中试图获取的节点，并不存在于我期望的 XML 路径中。XML 这种高度结构化的格式帮助了代码保持可靠性，这对用户和开发者来说都是有好处的。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!