Momenteel gebruikt onze Java-toepassing de waarden in een door tabs gescheiden *.cfg-bestand. We moeten deze toepassing wijzigen zodat deze nu een XML-bestand gebruikt.
Wat is de beste/eenvoudigste bibliotheek om te gebruiken om waarden uit dit bestand in te lezen?
Antwoord 1, autoriteit 100%
Er zijn natuurlijk veel goede oplossingen op basis van wat je nodig hebt. Als het alleen om configuratie gaat, moet je eens kijken naar Jakarta commons-configurationen commons-digester.
U kunt altijd de standaard JDK-methode gebruiken om een document te verkrijgen:
import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
[...]
File file = new File("some/path");
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document document = db.parse(file);
Antwoord 2, autoriteit 67%
XML-code:
<?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>
Java-code:
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();
}
}
}
Uitvoer:
----------------
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
Ik raad je aan dit te lezen: Normalisatie in DOM ontleden met java – hoe werkt het?
Antwoord 3, autoriteit 19%
Is er een bepaalde reden waarom u XML-configuratiebestanden hebt gekozen? Ik heb in het verleden XML-configuraties gedaan en ze bleken vaak meer hoofdpijn dan iets anders.
Ik denk dat de echte vraag is of je zoiets als de Preferences APIwerkt mogelijk beter in uw situatie.
Redenen om de Preferences API te gebruiken in plaats van een eigen XML-oplossing:
-
Vermijdt typische XML-lelijkheid (DocumentFactory, enz.), en vermijdt bibliotheken van derden om de XML-backend te leveren
-
Ingebouwde ondersteuning voor standaardwaarden (geen speciale behandeling vereist voor ontbrekende/corrupte/ongeldige invoer)
-
Het is niet nodig om waarden op te schonen voor XML-opslag (CDATA-wrapping, enz.)
-
Gegarandeerde status van de backing store (u hoeft niet constant XML naar schijf te schrijven)
-
Backing store is configureerbaar (bestand op schijf, LDAP, etc.)
-
Gratis toegang tot alle voorkeuren via meerdere threads
Antwoord 4, autoriteit 17%
Wat is de beste/eenvoudigste bibliotheek om te
gebruiken om waarden in te lezen van
dit bestand?
Omdat je om de eenvoudigstebibliotheek vraagt, voel ik me verplicht om een heel andere benadering toe te voegen dan die in Guillaume’s best gestemde antwoord. (Van de andere antwoorden komt de JDOM-vermelding van sjbotha het dichtst in de buurt van wat ik voorstel).
Ik ben gaan denken dat voor XML-verwerking in Java, het gebruik van de standaard JDK-tools zeker nietde eenvoudigste manier is, en dat alleen in bepaalde omstandigheden (zoals het niet kunnen gebruiken van 3e feestbibliotheken, om de een of andere reden) is dit de beste manier.
Overweeg in plaats daarvan een goede XML-bibliotheek te gebruiken, zoals XOM. Zo leest u een XML-bestand in een nu.xom.Document-object:
import nu.xom.Builder;
import nu.xom.Document;
import java.io.File;
[...]
File file = new File("some/path");
Document document = new Builder().build(file);
Dus, dit was slechts een klein beetje eenvoudiger, omdat het lezen van het bestand in org.w3c.dom.Documentwas niet erg gecompliceerd, in de “pure JDK” -benadering. Maar de voordelen van het gebruik van een goede bibliotheek beginnen hier alleen! Wat je ook met je XML doet, je komt vaak weg met veel eenvoudiger oplossingen, en minder van je eigen code om te handhaven, bij gebruik van een bibliotheek zoals XOM. Als voorbeelden, overwegen dit vs. deze , of Deze vs. Deze , of Deze post bevat zowel XOM- als W3C DOM-voorbeelden .
Andere anderen leveren tegen-argumenten (zoals deze ) voor Waarom kan vasthouden aan de standaard XML-API’s van Java de moeite waard zijn – deze hebben waarschijnlijk een verdienste, althans in sommige gevallen, hoewel persoonlijk ik me niet abonneer ik niet op allemaal. In ieder geval, bij het kiezen van de een of andere manier, is het goed om zich bewust te zijn van beide kanten van het verhaal.
(Dit antwoord maakt deel uit van mijn evaluatie van XOM, die een sterke mededinger is in mijn Quest voor het vinden van de beste Java XML-bibliotheek om Dom4j te vervangen.)
Antwoord 5, Autoriteit 7%
jaxb is eenvoudig te gebruiken en is opgenomen in Java 6 SE. Met JAXB of andere XML-gegevensbinding zoals simpel hoeft u de XML zelf niet aan te pakken, het grootste deel van het werk wordt gedaan door de bibliotheek. Het basisgebruik is om annotatie aan uw bestaande pojo toe te voegen. Deze annotatie wordt vervolgens gebruikt om een XML-schema voor u te genereren en ook bij het lezen / schrijven / schrijven van uw gegevens van / naar een bestand.
Antwoord 6, Autoriteit 6%
Kijk in jaxb .
Antwoord 7, Autoriteit 4%
Ik heb alleen jdom gebruikt. Het is vrij eenvoudig.
Ga hier voor documentatie en om het te downloaden: http://www.jdom.org/
Als u een zeer zeer groot document hebt, is het beter om het niet allemaal in het geheugen te lezen, maar gebruik een SAX-parser die uw methoden oproept, omdat deze bepaalde tags en attributen raakt. U moet vervolgens een staatsmachine maken om de inkomende oproepen aan te pakken.
Antwoord 8, Autoriteit 2%
De eenvoudigste veruit zal eenvoudig worden http://simple.sourceforge.net , hoeft u alleen maar Annoteer een enkel object zoals het
@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;
}
}
Het enige dat u hoeft te doen om het hele bestand te lezen, is de locatie specificeren en het zal de geannoteerde POJO’s ontleden en vullen. Hiermee worden alle typeconversies en validatie uitgevoerd. U kunt indien nodig ook annoteren voor persistente callbacks. Lezen kan zo.
Serializer serializer = new Persister();
Configuration configuraiton = serializer.read(Configuration.class, fileLocation);
Antwoord 9, autoriteit 2%
Afhankelijk van uw toepassing en de omvang van het cfg-bestand, is een eigenschappenbestand wellicht het gemakkelijkst. Natuurlijk is het niet zo elegant als XML, maar het is zeker makkelijker.
Antwoord 10, autoriteit 2%
Gebruik java.beans.XMLDecoder, onderdeel van Java SE sinds 1.4.
XMLDecoder input = new XMLDecoder(new FileInputStream("some/path.xml"));
MyConfig config = (MyConfig) input.readObject();
input.close();
Het is gemakkelijk om de configuratiebestanden met de hand te schrijven, of gebruik de bijbehorende XMLEncodermet wat instellingen om tijdens runtime nieuwe objecten te schrijven.
Antwoord 11
Dit is wat ik gebruik. http://marketmovers.blogspot .com/2014/02/the-easy-way-to-read-xml-in-java.htmlHet zit bovenop de standaard JDK-tools, dus als het een functie mist, kun je altijd de JDK gebruiken versie.
Dit maakt het voor mij echt gemakkelijker. Het is vooral leuk als ik een configuratiebestand lees dat is opgeslagen door een oudere versie van de software, of handmatig is bewerkt door een gebruiker. Het is zeer robuust en zal geen uitzondering genereren als sommige gegevens niet precies in het formaat zijn dat u verwacht.
Antwoord 12
Hier is een heel eenvoudige API die ik heb gemaakt voor het lezen van eenvoudige XML-bestanden in Java. Het is ongelooflijk eenvoudig en gemakkelijk te gebruiken. Ik hoop dat het nuttig voor je is.