Qual é a melhor biblioteca para análise de XML em java [fechada]

Estou pesquisando na biblioteca java para analisar XML (configuração complexa e arquivos de dados), pesquisei um pouco, mas não encontrei outro que não o dom4j (parece que eles estão trabalhando na V2). Outros projetos apache em XML parecem estar em hibernação. Eu não avaliei o dom4j sozinho, mas só queria saber - o java tem outras (boas) bibliotecas de análise de código aberto de XML? e como está sua experiência com dom4j?

Após a resposta do @ Voo, deixe-me perguntar a outra - Devo usar as classes internas do java ou qualquer biblioteca de terceiros como dom4j .. Quais são as vantagens?

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.

Java suporta dois métodos para análise XML fora da caixa.

SAXParser

Você pode usar esse analisador se desejar analisar arquivos XML grandes e / ou não desejar usar muita memória.

http://download.oracle.com/javase/6/docs/api/javax/xml/parsers/SAXParserFactory.html

Exemplo: http://www.mkyong.com/java/how-to-read-xml-file-in-java-sax-parser/

DOMParser

Você pode usar esse analisador se precisar fazer consultas XPath ou se o DOM completo estiver disponível.

http://download.oracle.com/javase/6/docs/api/javax/xml/parsers/DocumentBuilderFactory.html

Exemplo: http://www.mkyong.com/java/how-to-read-xml-file-in-java-dom-parser/

Se você deseja uma API do tipo DOM - ou seja, aquela em que o analisador XML transforma o documento em uma árvore de nós de Elemento e Atributo -, há pelo menos quatro para escolher: DOM em si, JDOM, DOM4J e XOM. A única razão possível para usar o DOM é porque é percebido como um padrão e é fornecido no JDK: em todos os outros aspectos, os outros são todos superiores. Minha própria preferência, por sua combinação de simplicidade, poder e desempenho, é o XOM.

E, é claro, existem outros estilos de processamento: interfaces de analisador de baixo nível (SAX e StAX), interfaces de ligação de objeto de dados (JAXB) e linguagens declarativas de alto nível (XSLT, XQuery, XPath). O que é melhor para você depende dos requisitos do seu projeto e do seu gosto pessoal.

O ponto de Nikita é excelente: não confunda maduro com ruim. XML não mudou muito.

O JDOM seria outra alternativa ao DOM4J.

Você não precisa de uma biblioteca externa para analisar XML em Java. O Java vem com implementações integradas para SAX e DOM há muito tempo.

Para as pessoas interessadas em usar o JDOM, mas com medo de que não sejam atualizadas há algum tempo (principalmente não alavancando os genéricos Java), existe um fork chamado CoffeeDOM que aborda exatamente esses aspectos e moderniza a API do JDOM, leia mais aqui:

http://cdmckay.org/blog/2011/05/20/introducing-coffeedom-a-jdom-fork-for-java-5/

e faça o download na página do projeto em:

https://github.com/cdmckay/coffeedom

VTD-XML é a lib de análise de XML pesada ... é melhor do que outras em praticamente todos os aspectos ... aqui está um artigo de 2013 que analisa todas as estruturas de processamento XML disponíveis na plataforma java ...

http://sdiwc.us/digitlib/journal_paper.php?paper=00000582.pdf