Qual é a melhor e mais simples maneira de ler em um arquivo XML em aplicação Java? [fechado]
de momento, a nossa aplicação Java usa os valores contidos numa página delimitada *.ficheiro cfg. Precisamos mudar esta aplicação para que ela agora use um arquivo XML.
Qual é a melhor / mais simples biblioteca a usar para ler os valores deste ficheiro?
12 answers
Pode sempre utilizar o método JDK padrão para obter um documento:
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);
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?
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);
Então, isso foi um pouco mais simples, pois ler o arquivo em org.w3c.dom.Document
também não foi muito complicado, na abordagem do "JDK puro". Mas as vantagens de usar uma boa biblioteca só começam aqui! O que quer que você esteja fazendo com o seu XML, você muitas vezes vai escapar com soluções muito mais simples, e menos de seu próprio código para manter, ao usar uma biblioteca como o XOM. Como exemplos, considere isto vs. isto , ou isto vs. isto , ou Este post contendo ambos os exemplos XOM e W3C DOM.
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 .)
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.
Isto torna as coisas mais fáceis para mim. É especialmente bom quando estou lendo um arquivo de configuração que foi salvo por e mais antiga versão do software, ou foi editado manualmente por um usuário. É muito robusto e não vai abrir uma exceção se alguns dados não é exactamente no formato que esperas.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.