Wyszukiwanie w witrynie

Analizowanie plików konfiguracyjnych za pomocą języka Java


Implementuj trwałe ustawienia podczas pisania oprogramowania w Javie.

Kiedy piszesz aplikację, często chcesz, aby użytkownicy mogli konfigurować sposób, w jaki z nią współdziałają i jak ona współdziała z ich systemem. Są one powszechnie nazywane „preferencjami” lub „ustawieniami” i są przechowywane w „plikach preferencji” lub „plikach konfiguracyjnych” lub po prostu „konfiguracjach”. Istnieje wiele różnych formatów plików konfiguracyjnych, w tym INI, JSON, YAML i XML, a każdy język analizuje te języki inaczej. W tym artykule omówiono niektóre sposoby implementowania trwałych ustawień podczas pisania oprogramowania w języku programowania Java.

Wybierz format

Zapisywanie plików konfiguracyjnych jest zaskakująco elastyczne. Opcje konfiguracyjne zachowałem w prostym pliku tekstowym rozdzielanym przecinkami, a opcje w bardzo szczegółowym formacie YAML lub XML. Najważniejszą rzeczą w plikach konfiguracyjnych jest to, że są spójne i przewidywalne. Ułatwia to napisanie kodu, który będzie w stanie szybko i łatwo wyodrębnić dane z pliku konfiguracyjnego, a także zapisać i zaktualizować opcje, gdy użytkownik zdecyduje się na dokonanie zmiany.

Istnieje kilka popularnych formatów plików konfiguracyjnych. Java ma biblioteki dla większości popularnych formatów konfiguracyjnych, ale w tym artykule użyję formatu XML. W przypadku niektórych projektów możesz zdecydować się na użycie formatu XML ze względu na jego nieodłączną zdolność do dostarczania dużej ilości metadanych na temat zawartych w nim danych, podczas gdy w przypadku innych możesz go uniknąć ze względu na jego gadatliwość. Java sprawia, że praca z XML jest stosunkowo łatwa, ponieważ domyślnie zawiera solidne biblioteki XML.

Podstawy XML-a

XML to duży temat. Tylko jedna z posiadanych przeze mnie książek o XML ma ponad 700 stron. Na szczęście używanie języka XML nie wymaga dogłębnej znajomości wszystkich jego funkcji. Podobnie jak HTML, XML jest hierarchicznym językiem znaczników ze znacznikami otwierającymi i zamykającymi, które mogą zawierać zero lub więcej danych. Oto przykładowy fragment kodu XML:

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

W tym raczej samoopisowym przykładzie poniżej znajdują się terminy używane przez parsery XML:

  • Dokument: tag <xml> otwiera dokument, a tag zamyka go.
  • Węzeł: tag <node> to węzeł.
  • Element: Pingwin, od pierwszego < do ostatniego >, to element.
  • Treść: w elemencie <element> ciąg Pingwin oznacza treść.

Wierz lub nie, ale to wszystko, co musisz wiedzieć o formacie XML, aby móc go zapisywać i analizować.

Utwórz przykładowy plik konfiguracyjny

Aby nauczyć się analizować XML, wystarczy minimalny przykład pliku konfiguracyjnego. Wyobraź sobie plik konfiguracyjny śledzący niektóre właściwości wyświetlania okna GUI:

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

Utwórz katalog o nazwie ~/.config/DemoXMLParser:

$ mkdir ~/.config/DemoXMLParser

W systemie Linux katalog ~/.config jest domyślną lokalizacją pliku konfiguracyjnego, zgodnie ze specyfikacją Freedesktop. Jeśli korzystasz z systemu operacyjnego, który nie spełnia standardów Freedesktop, nadal możesz korzystać z tej lokalizacji, ale konieczne może być samodzielne utworzenie wszystkich katalogów.

Skopiuj i wklej przykładowy plik XML konfiguracji do pliku i zapisz go jako ~/.config/DemoXMLParser/myconfig.xml.

Analizuj XML za pomocą Java

Jeśli dopiero zaczynasz przygodę z Javą, zacznij od przeczytania mojego artykułu z 7 wskazówkami dla nowych programistów Java. Kiedy już oswoisz się z Javą, otwórz swoje ulubione zintegrowane środowisko programistyczne (IDE) i utwórz nowy projekt. Nazywam mój myConfigParser.

Nie martwiąc się zbytnio o import i wychwytywanie błędów, możesz utworzyć instancję parsera, korzystając ze standardowych rozszerzeń Java dostępnych w bibliotekach javax i java.io. Jeśli używasz IDE, zostaniesz poproszony o zaimportowanie odpowiednich bibliotek; w przeciwnym razie pełną listę bibliotek w pełnej wersji tego kodu znajdziesz w dalszej części tego artykułu.

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

W tym przykładowym kodzie użyto biblioteki java.nio.Paths do zlokalizowania katalogu domowego użytkownika, dodając do ścieżki domyślną lokalizację konfiguracji. Następnie definiuje plik konfiguracyjny, który ma być analizowany jako obiekt File przy użyciu biblioteki java.io.File.

Następnie używa bibliotek javax.xml.parsers.DocumentBuilder i javax.xml.parsers.DocumentBuilderFactory do utworzenia wewnętrznego narzędzia do tworzenia dokumentów, dzięki czemu program Java może przyjmować i analizować Dane XML.

Na koniec Java tworzy dokument o nazwie doc i ładuje do niego plik configFile. Używając bibliotek org.w3c.dom, normalizuje przyjęte dane XML.

To w zasadzie tyle. Technicznie rzecz biorąc, analiza danych została zakończona. Jednak przeanalizowane dane nie będą dla Ciebie zbyt przydatne, jeśli nie będziesz mieć do nich dostępu, więc napisz kilka zapytań, aby wyodrębnić ważne wartości z konfiguracji.

Dostęp do wartości XML za pomocą języka Java

Pobieranie danych z przetworzonego dokumentu XML polega na odwoływaniu się do konkretnego węzła, a następnie „przechodzeniu” przez zawarte w nim elementy. Do iteracji elementów w węzłach często używa się serii pętli, ale tutaj ograniczę to do minimum, aby kod był łatwy do odczytania:

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

Ten przykładowy kod tworzy obiekt NodeList o nazwie nodes przy użyciu biblioteki org.w3c.dom.NodeList;. Ten obiekt zawiera dowolny węzeł podrzędny o nazwie pasującej do ciągu window, który jest jedynym węzłem w przykładowym pliku konfiguracyjnym utworzonym w tym artykule.

Następnie tworzy pętlę for do iteracji po liście nodes, biorąc każdy węzeł w kolejności występowania i przetwarzając go za pomocą pętli if-then. Pętla if-then tworzy obiekt Element o nazwie myelement, który zawiera wszystkie elementy w bieżącym węźle. Możesz wysyłać zapytania do elementów, używając metod takich jak getChildNodes, getElementById i innych, zgodnie z dokumentacją projektu.

W tym przykładzie elementy są zasadniczo kluczami konfiguracyjnymi. Wartości przechowywane są jako zawartość elementu, którą można wyodrębnić metodą .getTextContent.

Uruchom kod w swoim IDE lub jako plik binarny:

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

Oto pełny kod:

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

Aktualizacja XML za pomocą Java

Od czasu do czasu użytkownik zmieni preferencje. Biblioteki org.w3c.dom mogą aktualizować zawartość elementu XML; wystarczy, że wybierzesz element XML w taki sam sposób, jak podczas jego czytania. Zamiast używać metody .getTextContent, użyj metody .setTextContent:

updatePref = myelement.getElementsByTagName("fullscreen").item(0);
updatePref.setTextContent("1");

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

Spowoduje to zmianę dokumentu XML w pamięci aplikacji, ale nie spowoduje ponownego zapisania danych na dysku. Używając kombinacji bibliotek javax i w3c, możesz umieścić przetworzony plik XML z powrotem w pliku konfiguracyjnym:

TransformerFactory transformerFactory = TransformerFactory.newInstance();

Transformer xtransform;
xtransform = transformerFactory.newTransformer();

DOMSource mydom = new DOMSource(doc);
StreamResult streamResult = new StreamResult(configFile);

xtransform.transform(mydom, streamResult);

Spowoduje to ciche zastąpienie poprzedniego pliku konfiguracyjnego przekształconymi danymi.

Oto pełny kod wraz z aktualizatorem:

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

Zachowaj bezproblemową konfigurację

Konfiguracja może być zwodniczo prostą procedurą. Możesz zacząć od prostego formatu konfiguracji w postaci zwykłego tekstu, gdy aplikacja ma tylko kilka konfigurowalnych funkcji, ale w miarę wprowadzania większej liczby opcji odczytywanie lub zapisywanie nieprawidłowych danych może spowodować nieoczekiwane zachowanie aplikacji. Jednym ze sposobów zabezpieczenia procesu konfiguracji przed awarią jest użycie ścisłego formatu, takiego jak XML, i wykorzystanie wbudowanych funkcji języka programowania w celu poradzenia sobie ze złożonością.

Właśnie z tego powodu lubię używać języka Java i XML. Kiedy próbuję odczytać niewłaściwą wartość konfiguracyjną, Java mnie o tym informuje, często dlatego, że węzeł, który mój kod ma chcieć odczytać, nie istnieje w oczekiwanej ścieżce XML. Wysoce zorganizowany format XML pomaga mi zachować niezawodność mojego kodu, co jest korzystne zarówno dla użytkowników, jak i programisty.

Powiązane artykuły: