Qual é a melhor e mais simples maneira de ler em um arquivo XML em aplicação Java? [fechado]

Código XML:

<?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>

Código Java:

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

Resultado:

----------------

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

Recomendei-te que lesses isto: normalização no DOM parsing com java - como é que funciona?

Exemplo fonte.

Existe alguma razão em particular para ter escolhido ficheiros de configuração XML? Eu já fiz configurações XML no passado, e eles muitas vezes acabaram por ser mais uma dor de cabeça do que qualquer outra coisa.

Acho que a verdadeira questão é se usar algo como a API Preferências pode funcionar melhor na sua situação.

Razões para usar a API de preferências numa solução de roll-your-own XML:

• Evita a fealdade XML típica( DocumentFactory, etc.), juntamente com evitar bibliotecas de terceiros para fornecer a infra-estrutura XML

• Incorporado no suporte para os valores por omissão (não é necessário nenhum tratamento especial para os itens em falta / corrompidos / inválidos)

• Não é necessário limpar os valores do armazenamento em XML (embalagem de CDATA, etc.)

• Estado garantido da loja de suporte (não há necessidade de escrever constantemente XML para fora do disco)

• A Loja de suporte é configurável (ficheiro no disco, LDAP, etc.)

• Acesso Multi-roscado a todas as preferências de graça

Qual é a melhor e mais simples biblioteca para utilizar para ler os valores de este ficheiro?

Como você está pedindo a biblioteca mais simples , Eu sinto-me obrigado a adicionar uma abordagem bem diferente daquela na resposta Mais votada de Guillaume. (Das outras respostas, a menção JDOM de sjbotha é mais próxima do que eu sugiro).

Cheguei a pensar que para a manipulação de XML em Java, usar as ferramentas JDK padrão é certamente não a maneira mais simples, e que só em algumas circunstâncias (como não poder usar bibliotecas de terceiros, por alguma razão) é a melhor maneira.

Em vez disso, considere usar uma boa biblioteca XML, como XOM. Aqui está como ler um arquivo XML em um nu.xom.Document objecto:

import nu.xom.Builder;
import nu.xom.Document;
import java.io.File;

[...]

File file = new File("some/path");
Document document = new Builder().build(file);

Outros irão fornecer contra-argumentos ( como estes ) para saber porque é que a aderência às APIs XML padrão de Java pode valer a pena - estes provavelmente têm mérito, em pelo menos em alguns casos, embora pessoalmente eu não subscreva todos eles. Em qualquer caso, ao escolher uma maneira ou outra, é bom estar ciente de ambos os lados da história.

(esta resposta faz parte da minha avaliação do XOM, que é um forte concorrente na minha busca por encontrar a melhor biblioteca Java XML para substituir o dom4j .)

Olha para JAXB .

JAXB é simples de usar e está incluído no Java 6 SE. Com o JAXB, ou outras ligações de dados XML, como simples, você não tem que lidar com o XML você mesmo, a maioria do trabalho é feito pela biblioteca. A utilização básica é adicionar uma anotação ao seu POJO existente. Estas anotações são então usadas para gerar um esquema XML para os seus dados e também ao ler/escrever os seus dados de/para um ficheiro.

Vá aqui para obter documentação e baixá-la: http://www.jdom.org/

Se você tem um documento muito grande, então é melhor não ler tudo na memória, mas usar um analisador de SAX que chama seus métodos como ele atinge certas tags e atributos. Você tem que, em seguida, criar uma máquina de Estado para lidar com as chamadas recebidas.

Dependendo da sua aplicação e do âmbito do ficheiro cfg, um ficheiro de propriedades pode ser o mais fácil. Claro que não é tão elegante como xml, mas certamente mais fácil.

Uso java.beans.XMLDecoder, parte do Núcleo Java SE desde 1.4.

XMLDecoder input = new XMLDecoder(new FileInputStream("some/path.xml"));
MyConfig config = (MyConfig) input.readObject();
input.close();

É fácil escrever os ficheiros de configuração manualmente, ou usar os correspondentes XMLEncoder com alguma configuração para escrever novos objectos em tempo de execução.

O mais simples de longe será simples http://simple.sourceforge.net , você só precisa anotar um único objeto como so

@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;
   }
}

Então tudo o que tem de fazer para ler o ficheiro completo é indicar a localização e ele irá analisar e preencher os POJO anotados. isto irá fazer todas as conversões de tipo e validação. Você também pode anotar para callbacks persister se necessário. Lê-lo pode ser feito assim.

Serializer serializer = new Persister();
Configuration configuraiton = serializer.read(Configuration.class, fileLocation);

Isto é o que eu uso. http://marketmovers.blogspot.com/2014/02/the-easy-way-to-read-xml-in-java.html ele fica em cima das ferramentas JDK padrão, então se ele está faltando algum recurso você pode sempre usar a versão JDK.

Aqui está uma API muito simples que eu criei para ler arquivos XML simples em Java. É incrivelmente simples e fácil de usar. Espero que seja útil para ti.

Http://argonrain.wordpress.com/2009/10/27/000/