Manipulando Arquivo XML Parte III: XStream

Neste tutorial vou exemplificar como manipular arquivos XML com as API XStream do Java. Veremos como criar um arquivo XML e como ler este arquivo. Esta biblioteca é externa e pode ser baixada em http://xstream.codehaus.org/download.html, neste tutorial foi utilizada a versão XStream-1.3.1.

1. Salvar arquivo

Antes de tudo, precisamos após criar o objeto XML 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(String documento, String file). Já irei informar neste primeiro passo todos os imports necessários.

public class MainTest {

	private static void salvarArquivo(String documento, String file) {
		File path = new File("C:\\TutorialArquivos\\" + file);
		try {
			PrintWriter writer = new PrintWriter(path);
			writer.println(
			""
			);           
			writer.println(documento);
			writer.flush();
			writer.close();
		} catch (FileNotFoundException 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.

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 XStream. Todos os passos estão descritos nos comentários inseridos no código fonte. O primeiro método mostra a forma mais simples de gerar o XML, porém trás um problema na nomeação das tags.

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;

import java.io.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public static void gerarXml001(Contato contato) {
	//Criamos o objeto que vai fazer o trabalho de gerar o xml
	XStream xStream = new XStream(new DomDriver());
	//O metodo toXML() transforma nosso objeto
	//contato em um padrao de saida no formato XML.
	String documento = xStream.toXML(contato);
	//A chamada ao metodo salvaArquivo passando por parametro
	//a String com o XML gerado e o nome do arquivo     
	salvarArquivo(documento, "gerarXml001.xml");
}

Após a execução do método da listagem 2, teremos um arquivo gerado conforme a listagem 3. Veja que as tags e  possuem o nome dos pacotes que as contém, mais o nome da classe referente. Já as tags  e  não possuem essa particularidade por serem atributos da classe Contato, o atributo telefones é uma coleção composta por objetos do tipo Telefone, por isso, as tags filhas de possuem a descrição do pacote e da classe a qual pertencem.

<?xml version="1.0" encoding="ISO-8859-1"?>
<br.mb.tutorialArquivos.xml.Contato>
  <id>100</id>
  <nome>Fulano da Silva</nome>
  <email>fulano@email.com</email>
  <endereco>
    <id>11</id>
    <logradouro>Rua dos Javanezes</logradouro>
    <bairro>Largo Zero</bairro>
    <cep>97010600</cep>
    <cidade>Java City</cidade>
    <complemento>Ap.103A</complemento>
    <numero>65</numero>
  </endereco>
  <telefones>
    <br.mb.tutorialArquivos.xml.Telefone>
      <id>1</id>
      <ddd>55</ddd>
      <numero>32214512</numero>
    </br.mb.tutorialArquivos.xml.Telefone>
    <br.mb.tutorialArquivos.xml.Telefone>
      <id>2</id>
      <ddd>55</ddd>
      <numero>99879885</numero>
    </br.mb.tutorialArquivos.xml.Telefone>
  </telefones>
</br.mb.tutorialArquivos.xml.Contato>

No método seguinte, mostrarei como alterar o nome das tags para ser possível utilizar qualquer nome desejado.

private static void gerarXml002(Contato contato) {
	//Criamos o objeto xStrem
	XStream xStream = new XStream(new DomDriver());
	//Vamos renomear nossa tag root para Contato
	//O 1° parametro indica o novo nome da Tag e
	//o 2° parametro indica a classe desta tag
	xStream.alias("Contato", Contato.class);
	//Varemos o mesmo com a tag Endereco.
	//Porém utilizando desta vez o método aliasField().
	//O 1° parametro recebe o nome que queremos dar a tag.
	//O 2° parametro indicamos a qual classe essa tag pertence
	//o 3° parametro indicamos o nome do atributo endereco na classe Contato,
	//no caso estamos referenciando o atributo endereco criado dentro da
	//classe Contato.
	xStream.aliasField("Endereco", Contato.class, "endereco");
	//Fazemos o mesmo processo para o atributo telefones
	xStream.aliasField("Telefones", Contato.class, "telefones");
	//Como telefones é uma lista temos
	// a tag pai  e as filhas .
	//Precisamos renomear também as tag filhas, para isso,
	//usamos o metodo alias() indicando a classe Telefone
	xStream.alias("Telefone", Telefone.class);

	String documento = xStream.toXML(contato);
	salvarArquivo(xStream.toXML(contato), "gerarXml002.xml");
}

Agora veja na listagem 5 o resultado após a execução do método gerarXml002().

<?xml version="1.0" encoding="ISO-8859-1">
<Contato>
  <id>100</id>
  <nome>Fulano da Silva</nome>
  <email>fulano@email.com</email>
  <Endereco>
    <id>11</id>
    <logradouro>Rua dos Javanezes</logradouro>
    <bairro>Largo Zero</bairro>
    <cep>97010600</cep>
    <cidade>Java City</cidade>
    <complemento>Ap.103A</complemento>
    <numero>65</numero>
  </Endereco>
  <Telefones>
    <Telefone>
      <id>1</id>
      <ddd>55</ddd>
      <numero>32214512</numero>
    </Telefone>
    <Telefone>
      <id>2</id>
      <ddd>55</ddd>
      <numero>99879885</numero>
    </Telefone>
  </Telefones>
</Contato>

Na listagem 6 temos o método que irá ler o conteúdo dos arquivos gerados, nesse exemplo estou lendo o arquivo gerarXml002.xml.

private static void lerXml() {
	FileReader reader = null;
	try {
		//carrega o arquivo XML para um objeto reader
		reader = new FileReader("C:\\TutorialArquivos\\gerarXml002.xml");
	} catch (FileNotFoundException e) {
		e.printStackTrace();
	}
	//Cria o objeto xstream
	XStream xStream = new XStream(new DomDriver());
	//informamos as tags que serao lidas
	//como foi feito no metodo gerarXml002
	xStream.alias("Contato", Contato.class);
	xStream.aliasField("Endereco", Contato.class, "endereco");
	xStream.aliasField("Telefones", Contato.class, "telefones");
	xStream.alias("Telefone", Telefone.class);
	//cria um objeto Contato,
	//contendo os dados do xml
	Contato contato = (Contato) xStream.fromXML(reader);
	//Exibimos no console o resultado
	System.out.println(contato.toString());
}

4. Método main

No método main() iremos criar os objetos Contato, Endereco e Telefone e adicionar a eles os valores necessários.

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

	gerarXML001(contato);
	gerarXML002(contato);
	lerXML();
}

Agora que criamos este método vamos executá-lo para gerar o arquivo XML e em seguida ler o conteúdo do arquivo gerado.

5. Gerando o XML através de anotações

Outra função da biblioteca XStream é que podemos anotar as classes que queremos gerar os XML’s, o que facilita ainda mais o nosso trabalho.

Vamos adicionar a classe Contato, Endereco e Telefone as anotações conforme a listagem 8.

import com.thoughtworks.xstream.annotations.XStreamAlias;

import java.util.ArrayList;
import java.util.Collection;

@XStreamAlias("Contato")
public class Contato {
    private int id;
    private String nome;
    private String email;

    @XStreamAlias("Telefones")
    private Collection telefones = new ArrayList();
    @XStreamAlias("Endereco")
    private Endereco endereco;

	//demais metodos get, set e toString()
}

//Coloque a anotação também nas classes Endereco e Telefone
@XStreamAlias("Telefone")
public class Telefone { ... }

@XStreamAlias("Endereco")
public class Endereco { ... }

Criaremos agora o método que utilizara as anotações para a criação do XML, veja na listagem 9.

public static void gerarXml003(Contato contato) {
	XStream xStream = new XStream();
	//Usamos o método que detecta as classes anotadas
	xStream.autodetectAnnotations(true);
	String documento = xStream.toXML(contato);
	salvarArquivo(xStream.toXML(contato), "gerarXml003.xml");
}

private static void lerXmlAnnotation() {
	FileReader reader = null;
	try {
		//carrega o arquivo XML para um objeto reader
		reader = new FileReader(
		"C:\\TutorialArquivos\\gerarXml003.xml"
		);
	} catch (FileNotFoundException e) {
		e.printStackTrace();
	}
	//Cria o objeto xstream
	XStream xStream = new XStream(new DomDriver());
	//Para ler vamos utilizar outro metodo o
	//processAnnotations() e como parametro passamos
	//a classe que possui as anotacoes
	xStream.processAnnotations(Contato.class);

	Contato contato = (Contato) xStream.fromXML(reader);
	System.out.println(contato.toString());
}

Conclusão

Neste tutorial podemos ver as facilidades de trabalhar com a biblioteca XStream. Vimos como gerar e ler arquivos XML com e sem o uso de anotações. Fica como sugestão um leitura adicional, na página oficial da biblioteca XStream, dos tutoriais lá adicionados. Leia também a documentação sempre que tiver dúvidas sobre o que um método pode fazer.

Saiba mais

Documentação das classes da biblioteca XStream http://xstream.codehaus.org/javadoc/index.html