In realtà Java supporta 4 metodi per analizzare XML out of the box:
Parser / builder DOM: l'intera struttura XML viene caricata in memoria e puoi utilizzare i noti metodi DOM per lavorare con essa. DOM consente inoltre di scrivere nel documento con trasformazioni Xslt. Esempio:
public static void parse() throws ParserConfigurationException, IOException, SAXException {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(true);
factory.setIgnoringElementContentWhitespace(true);
DocumentBuilder builder = factory.newDocumentBuilder();
File file = new File("test.xml");
Document doc = builder.parse(file);
// Do something with the document here.
}
Parser SAX: solo per leggere un documento XML. Il parser Sax esegue il documento e chiama i metodi di callback dell'utente. Esistono metodi per l'inizio / la fine di un documento, un elemento e così via. Sono definiti in org.xml.sax.ContentHandler e c'è una classe di supporto vuota DefaultHandler.
public static void parse() throws ParserConfigurationException, SAXException {
SAXParserFactory factory = SAXParserFactory.newInstance();
factory.setValidating(true);
SAXParser saxParser = factory.newSAXParser();
File file = new File("test.xml");
saxParser.parse(file, new ElementHandler()); // specify handler
}
StAx Reader / Writer: funziona con un'interfaccia orientata al flusso di dati. Il programma richiede l'elemento successivo quando è pronto proprio come un cursore / iteratore. Puoi anche creare documenti con esso. Leggi il documento:
public static void parse() throws XMLStreamException, IOException {
try (FileInputStream fis = new FileInputStream("test.xml")) {
XMLInputFactory xmlInFact = XMLInputFactory.newInstance();
XMLStreamReader reader = xmlInFact.createXMLStreamReader(fis);
while(reader.hasNext()) {
reader.next(); // do something here
}
}
}
Scrivi documento:
public static void parse() throws XMLStreamException, IOException {
try (FileOutputStream fos = new FileOutputStream("test.xml")){
XMLOutputFactory xmlOutFact = XMLOutputFactory.newInstance();
XMLStreamWriter writer = xmlOutFact.createXMLStreamWriter(fos);
writer.writeStartDocument();
writer.writeStartElement("test");
// write stuff
writer.writeEndElement();
}
}
JAXB: la più recente implementazione per leggere documenti XML: fa parte di Java 6 in v2. Questo ci consente di serializzare oggetti Java da un documento. Leggi il documento con una classe che implementa un'interfaccia per javax.xml.bind.Unmarshaller (ottieni una classe per questo da JAXBContext.newInstance). Il contesto deve essere inizializzato con le classi utilizzate, ma devi solo specificare le classi radice e non devi preoccuparti delle classi con riferimento statico. Usa le annotazioni per specificare quali classi dovrebbero essere elementi (@XmlRootElement) e quali campi sono elementi (@XmlElement) o attributi (@XmlAttribute, che sorpresa!)
public static void parse() throws JAXBException, IOException {
try (FileInputStream adrFile = new FileInputStream("test")) {
JAXBContext ctx = JAXBContext.newInstance(RootElementClass.class);
Unmarshaller um = ctx.createUnmarshaller();
RootElementClass rootElement = (RootElementClass) um.unmarshal(adrFile);
}
}
Scrivi documento:
public static void parse(RootElementClass out) throws IOException, JAXBException {
try (FileOutputStream adrFile = new FileOutputStream("test.xml")) {
JAXBContext ctx = JAXBContext.newInstance(RootElementClass.class);
Marshaller ma = ctx.createMarshaller();
ma.marshal(out, adrFile);
}
}
Esempi copiati spudoratamente da alcune vecchie diapositive delle lezioni ;-)
Modifica: Informazioni su "quale API dovrei usare?". Bene dipende - non tutte le API hanno le stesse capacità che vedi, ma se hai il controllo sulle classi che usi per mappare il documento XML JAXB è la mia soluzione preferita personale, davvero elegante e semplice (anche se non l'ho usata per documenti molto grandi, potrebbe diventare un po 'complesso). SAX è anche abbastanza facile da usare e stai lontano da DOM se non hai davvero un buon motivo per usarlo - API vecchia e goffa secondo me. Non credo che ci siano librerie di terze parti moderne che presentano qualcosa di particolarmente utile che manca all'STL e le librerie standard hanno i soliti vantaggi di essere estremamente ben testate, documentate e stabili.