Manipulando Arquivo XML Parte II: JDOM
Este tutorial é a segunda parte dos tutoriais que farei sobre Java e arquivos XML. Neste tutorial vou exemplificar como manipular arquivos XML com as API’s JDOM. Veremos como criar um arquivo XML e como ler este arquivo. Esta biblioteca é externa e pode ser baixada em http://www.jdom.org/downloads/index.html, neste tutorial foi utilizada a versão JDOM-1.1.
1. Salvar arquivo
Antes de tudo, precisamos após criar o objeto XML para salvá-lo em um arquivo. Vamos então criar um método para isso. Crie uma classe MainTest e em seguida crie o método salvarArquivo(Document documento). Já irei informar neste primeiro passo todos os imports necessários.
Listagem 1. Classe MainTest, Imports e Método SalvarFile
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;
import java.io.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class MainTest {
private static void salvarArquivo(Document doc) {
try {
Writer out = new OutputStreamWriter(new FileOutputStream(file));
XMLOutputter xout = new XMLOutputter();
xout.setFormat(Format.getCompactFormat().setEncoding("ISO-8859-1"));
xout.output(doc, out);
System.out.println("XML criado com sucesso!");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}2. Estrutura do XML
Vamos utilizar três classes para manipular os dados que serão inseridos no XML. Nosso arquivo ficara com a estrutura do XML da figura 1.
Figura 1 – XML
Crie a classe Telefone, Endereco e Contato conforme a listagem 2 do tutorial Parte I. Como devem ter visto na Figura 1, teremos mais de um telefone no arquivo, então é por este motivo que foi criada uma coleção de telefones na classe Contato. Enquanto isso terá apenas um endereço no arquivo, por este motivo teremos um objeto Endereco na classe Contato.
3. Método gerarXML
Vamos gerar nosso XML a partir das classes da biblioteca JDOM. Todos os passos estão descritos nos comentários inseridos no código fonte.
Listagem 2. Método gerarXML e lerXML
public static void gerarXML(Contato contato) {
//Criamos o elemento(tag) raiz
Element tagContato = new Element("Contato");
//Criamos os elementos que ficam dentro da tag raiz
Element idContato = new Element("id");
Element nomeContato = new Element("nome");
Element emailContato = new Element("email");
//Inserimos os valores as tags criadas a cima
idContato.setText(String.valueOf(contato.getId()));
nomeContato.setText(contato.getNome());
emailContato.setText(contato.getEmail());
//Inserimos na tag raiz as tags já com valores
tagContato.addContent(idContato);
tagContato.addContent(nomeContato);
tagContato.addContent(emailContato);
//Criamos a tag Endereco
Element tagEndereco = new Element("Endereco");
//Criamos as tags filhas de Endereco
Element idEnd = new Element("id");
Element logradouroEnd = new Element("logradouro");
Element bairroEnd = new Element("bairro");
Element cepEnd = new Element("cep");
Element cidadeEnd = new Element("cidade");
Element complementoEnd = new Element("complemento");
Element numeroEnd = new Element("numero");
//Inserimos os valores as tags criadas
idEnd.setText(String.valueOf(contato.getEndereco().getId()));
logradouroEnd.setText(contato.getEndereco().getLogradouro());
bairroEnd.setText(contato.getEndereco().getBairro());
cepEnd.setText(contato.getEndereco().getCep());
cidadeEnd.setText(contato.getEndereco().getCidade());
complementoEnd.setText(contato.getEndereco().getComplemento());
numeroEnd.setText(String.valueOf(contato.getEndereco().getNumero()));
//Inseriomos na tag Endereco as tags filhas
tagEndereco.addContent(idEnd);
tagEndereco.addContent(logradouroEnd);
tagEndereco.addContent(bairroEnd);
tagEndereco.addContent(cepEnd);
tagEndereco.addContent(cidadeEnd);
tagEndereco.addContent(complementoEnd);
tagEndereco.addContent(numeroEnd);
//Inserimos na tag raiz as tag Endereco
tagContato.addContent(tagEndereco);
//Criamos a tag Telefones
Element tagFones = new Element("Telefones");
//Inserir a lista de telefones
for (Telefone fone : contato.getTelefones()) {
//Criamos a tag Telefone
Element tagFone = new Element("Telefone");
//Criamos as tags de Telefone
Element idFone = new Element("id");
Element dddFone = new Element("ddd");
Element numeroFone = new Element("numero");
//Insere os valores de telefones nas tags referentes
idFone.setText(String.valueOf(fone.getId()));
dddFone.setText(String.valueOf(fone.getDdd()));
numeroFone.setText(String.valueOf(fone.getNumero()));
//Insere as tags de telefone na tag Telefone
tagFone.addContent(idFone);
tagFone.addContent(dddFone);
tagFone.addContent(numeroFone);
//Insere a tag Telefone na tag pai Telefones
tagFones.addContent(tagFone);
}
//Insere a tag Telefones na tag raiz
tagContato.addContent(tagFones);
//Criamos um objeto Document
Document doc = new Document();
//Inserimos no elemento Document a
// tag raiz com todas as demais tags
doc.setRootElement(tagContato);
//Chamamos o método para salvar no arquivo
salvarArquivo(doc);
}Listagem 3. Método lerXml
public static void lerXML() throws JDOMException, IOException {
//Criamos um objeto SAXBuilder
// para ler o arquivo
SAXBuilder sb = new SAXBuilder();
//Criamos um objeto Document que
// recebe o conteúdo do arquivo
Document doc = sb.build(file);
//Criamos um objeto Element que
// recebe as tags do XML
Element elements = doc.getRootElement();
//Criamos um objeto Contato
// que recebe os valores
// através de element
Contato contato = new Contato();
contato.setId(Integer.parseInt(elements.getChildText("id")));
contato.setNome(elements.getChildText("nome"));
contato.setEmail(elements.getChildText("email"));
//Criamos um element que recebe a tag Endereco
Element endElemet = elements.getChild("Endereco");
//Criamos um objeto endereco
// que recebe os valores da
// do endElement
Endereco endereco = new Endereco();
endereco.setId(Integer.parseInt(endElemet.getChildText("id")));
endereco.setBairro(endElemet.getChildText("bairro"));
endereco.setCep(endElemet.getChildText("cep"));
endereco.setCidade(endElemet.getChildText("cidade"));
endereco.setComplemento(endElemet.getChildText("complemento"));
endereco.setLogradouro(endElemet.getChildText("logradouro"));
endereco.setNumero(Integer.parseInt(endElemet.getChildText("numero")));
//Inserimos no objeto contato o objeto Endereco
contato.setEndereco(endereco);
//Criamos um lista para receber
// os objetos Telefone
List telefones = new ArrayList();
//Criamos uma lista de Element
// para receber a tag Telefones
List fonesElement = elements.getChild("Telefones").getChildren();
//Loop em fonesElement para
// pegar as demais tags
for (Element fone : fonesElement) {
//Criamos um objeto telefone que
// recebe os valores em
// cada posicao de fonesElement
Telefone telefone = new Telefone();
telefone.setId(Integer.parseInt(fone.getChildText("id")));
telefone.setDdd(Integer.parseInt(fone.getChildText("ddd")));
telefone.setNumero(Integer.parseInt(fone.getChildText("numero")));
//Adicionamos na lista de Telefones o objeto Telefone
telefones.add(telefone);
}
//Adicionamos no objeto contato a
// lista telefones
contato.setTelefones(telefones);
//Imprimimos na tela o conteúdo de Contato
System.out.println( contato.toString() );
}4. Método main
Agora iremos criar o método main para criar o objeto Contato e passá-lo por parametro por uma chamada ao método gerarXml() e em seguida ler o conteúdo salvo no arquivo através do método lerXML() e exibi-lo no console.
Listagem 4. Método main
public static void main(String[] args) {
Telefone residencial = new Telefone();
residencial.setId(1);
residencial.setDdd(55);
residencial.setNumero(32214512);
Telefone celular = new Telefone();
celular.setId(2);
celular.setDdd(55);
celular.setNumero(99879885);
Collection telefones = new ArrayList();
telefones.add(residencial);
telefones.add(celular);
Endereco endereco = new Endereco();
endereco.setId(11);
endereco.setLogradouro("Rua dos Javanezes");
endereco.setBairro("Largo Zero");
endereco.setCep("97010600");
endereco.setCidade("Java City");
endereco.setNumero(65);
endereco.setComplemento("Ap.103A");
Contato contato = new Contato();
contato.setId(100);
contato.setNome("Fulano da Silva");
contato.setEmail("fulano@email.com");
contato.setEndereco(endereco);
contato.setTelefones(telefones);
gerarXML(contato);
try {
lerXML();
} catch (JDOMException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}Agora que criamos este método vamos executá-lo para gerar o arquivo XML e em seguida ler o conteúdo do arquivo gerado.
Conclusão
Vimos então como criar as tags XML e como inserir valores nelas, também vimos como recuperar essas informações de um arquivo. Utilizamos a biblioteca JDOM para isto e em comparação com o tutorial Parte I, onde usávamos apenas a API nativa do JDK, vimos que reduzimos muito o código fonte para gerar o mesmo XML.
No próximo tutorial, a Parte III, veremos como gerar e ler XML através de mais uma biblioteca externa, desta vez veremos as facilidades da biblioteca XStream.
