Bagaimana untuk mengkonfigurasi fail XML ketekunan Java

Pilih format

Menulis fail konfigurasi adalah perkara yang agak rumit. Saya telah cuba menyimpan item konfigurasi dalam fail teks yang dipisahkan koma dan saya telah cuba menyimpan item konfigurasi dalam YAML dan XML yang sangat bertele-tele. Untuk fail konfigurasi, perkara yang paling penting ialah mempunyai konsistensi dan keteraturan Mereka membolehkan anda menulis kod dengan mudah dan cepat dan menghuraikan data dari fail konfigurasi pada masa yang sama, apabila pengguna memutuskan untuk membuat perubahan, ia mudah disimpan mereka dan kemas kini konfigurasi.

Pada masa ini terdapat beberapa format fail konfigurasi yang popular. Untuk kebanyakan format fail konfigurasi biasa, Java mempunyai perpustakaan yang sepadan. Dalam artikel ini, saya akan menggunakan format XML. Untuk sesetengah projek, anda boleh memilih untuk menggunakan XML kerana salah satu ciri menonjolnya ialah keupayaannya untuk menyediakan banyak metadata yang berkaitan untuk data yang terkandung di dalamnya, manakala untuk projek lain anda mungkin tidak memilih XML kerana keterlanjurannya. Bekerja dengan XML dalam Java adalah sangat mudah kerana ia termasuk banyak perpustakaan XML yang mantap secara lalai.

Asas XML

Membincangkan XML ialah topik besar. Saya mempunyai buku tentang XML yang panjangnya lebih daripada 700 halaman. Nasib baik, bekerja dengan XML tidak memerlukan pengetahuan mendalam tentang banyak cirinya. Sama seperti HTML, XML ialah bahasa penanda berlapis dengan teg pembukaan dan penutup, yang setiap satunya boleh mengandungi sifar atau lebih data. Berikut ialah coretan contoh mudah XML:

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

Dalam contoh deskriptif kendiri ini, penghurai XML menggunakan konsep berikut:

• Dokumen Dokumen: b2a0af5a8fd26276da50279a1c63a57a tag menandakan permulaan dokumen, dan tag 21118965b89073f60271ef4a3b5d3c58 menandakan berakhirnya dokumen.

• Nod: Label 37493a7a244a2c0740719da11c0bbc72 mewakili nod.

• Elemen: Dalam 1dd643d91c792abd0a34d1b312e2f207Penguina24c0203f0ae689239f065103120aae7, dari awal 557204192d2d42fc602e1017325ca505 mewakili unsur.

• Kandungan: Dalam elemen 1dd643d91c792abd0a34d1b312e2f207, rentetan Penguin ialah kandungan.

Percaya atau tidak, selagi anda memahami konsep di atas, anda boleh mula menulis dan menghuraikan fail XML.

Buat contoh fail konfigurasi

Untuk mengetahui cara menghuraikan fail XML, anda hanya perlukan fail sampel minimalis. Katakan terdapat fail konfigurasi yang menyimpan sifat tetingkap antara muka grafik:

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

Buat direktori bernama ~/.config/DemoXMLParser:

$ mkdir ~/.config/DemoXMLParser

Dalam Linux, ~/.config Direktori ialah lokasi lalai untuk fail konfigurasi, seperti yang ditakrifkan dalam spesifikasi Kumpulan Kerja Desktop Percuma. Jika anda menggunakan sistem pengendalian yang tidak mematuhi piawaian Freedesktop, anda masih boleh menggunakan direktori ini, tetapi anda perlu membuat direktori ini sendiri.

Salin fail konfigurasi sampel XML, tampal dan simpan sebagai fail ~/.config/DemoXMLParser/myconfig.xml.

Gunakan Java untuk menghuraikan XML

Jika anda seorang pemula dalam Java, anda boleh membaca 7 Petua saya untuk Pembangun Java Pemula. Sebaik sahaja anda lebih mengenali Java, buka alat pembangunan bersepadu (IDE) kegemaran anda dan buat projek baharu. Saya akan menamakan projek baharu saya myConfigParser.

Jangan terlalu memberi perhatian kepada import pergantungan dan penangkapan pengecualian pada mulanya Anda boleh cuba membuat instantiate penghurai menggunakan sambungan Java standard dalam pakej javax dan java.io. Jika anda menggunakan IDE, ia akan menggesa anda untuk mengimport kebergantungan yang sesuai. Jika tidak, anda boleh mencari kod lengkap kemudian dalam artikel, yang mempunyai senarai lengkap kebergantungan.

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

Kod contoh ini menggunakan kelas java.nio.Paths untuk mencari direktori rumah pengguna dan kemudian menggabungkan laluan ke fail konfigurasi lalai. Seterusnya, ia menggunakan kelas java.io.File untuk mentakrifkan fail konfigurasi sebagai objek File.

Seterusnya, ia menggunakan kelas javax.xml.parsers.DocumentBuilder dan javax.xml.parsers.DocumentBuilderFactory untuk mencipta pembina dokumen dalaman supaya program Java boleh mengimport dan menghuraikan data XML.

Akhir sekali, Java mencipta objek dokumen yang dipanggil doc dan memuatkan fail configFile ke dalam objek ini. Menggunakan pakej org.w3c.dom, ia membaca dan menormalkan data XML.

Itu pada asasnya. Secara teorinya, anda telah menyelesaikan kerja analisis data. Walau bagaimanapun, penghuraian data tidak berguna jika anda tidak mempunyai akses kepada data. Jadi, mari tulis beberapa lagi pertanyaan untuk membaca nilai sifat penting daripada konfigurasi anda.

使用 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 这种高度结构化的格式帮助了代码保持可靠性，这对用户和开发者来说都是有好处的。

Atas ialah kandungan terperinci Bagaimana untuk mengkonfigurasi fail XML ketekunan Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!