Na verdade, o Java suporta 4 métodos para analisar o XML imediatamente:
Analisador / Construtor de DOM: Toda a estrutura XML é carregada na memória e você pode usar os métodos conhecidos do DOM para trabalhar com ela. O DOM também permite gravar no documento com transformações Xslt. Exemplo:
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.
}
Analisador SAX: Somente para ler um documento XML. O analisador Sax analisa o documento e chama os métodos de retorno de chamada do usuário. Existem métodos para o início / fim de um documento, elemento e assim por diante. Eles são definidos em org.xml.sax.ContentHandler e há uma classe auxiliar vazia 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
}
Leitor / Gravador StAx: Funciona com uma interface orientada ao fluxo de dados. O programa solicita o próximo elemento quando estiver pronto, como um cursor / iterador. Você também pode criar documentos com ele. Leia o 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
}
}
}
Escrever 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: A implementação mais recente para ler documentos XML: faz parte do Java 6 na v2. Isso nos permite serializar objetos java de um documento. Você lê o documento com uma classe que implementa uma interface para javax.xml.bind.Unmarshaller (você obtém uma classe para isso em JAXBContext.newInstance). O contexto deve ser inicializado com as classes usadas, mas você apenas precisa especificar as classes raiz e não precisa se preocupar com as classes referenciadas estáticas. Você usa anotações para especificar quais classes devem ser elementos (@XmlRootElement) e quais campos são elementos (@XmlElement) ou atributos (@XmlAttribute, que surpresa!)
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);
}
}
Escrever 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);
}
}
Exemplos copiados descaradamente de alguns slides antigos de palestras ;-)
Editar: sobre "qual API devo usar?". Bem, isso depende - nem todas as APIs têm os mesmos recursos que você vê, mas se você tem controle sobre as classes que usa para mapear o documento XML, JAXB é minha solução favorita pessoal, realmente elegante e simples (embora eu não a tenha usado para documentos muito grandes, pode ficar um pouco complexo). O SAX também é muito fácil de usar e fique longe do DOM se você não tiver um bom motivo para usá-lo - API antiga e desajeitada na minha opinião. Acho que não existem bibliotecas modernas de terceiros que apresentem algo especialmente útil que falta na STL e as bibliotecas padrão têm as vantagens usuais de serem extremamente bem testadas, documentadas e estáveis.