XML com XStream

Procurando sobre como criar e ler um arquivo XML através do Java, me deparei com a biblioteca XStream, que nos faz todo o trabalho de criar o arquivo.

Baixando o JAR

Primeiro temos que baixar o .jar da biblioteca, então entre no site do XStream, vá em Download e depois em XStream Core only. Lembre-se que a versão que estarei utilizando aqui é a versão 1.4.2. Você terá um arquivo chamado “xstream-1.4.2.jar” no seu computador.

Criando o projeto

Crie um novo projeto e dê o nome de Parser. Clique com o botão direito no seu projeto, em seguida em Properties. No item Libraries, clique em Add JAR/Folder (Figura 1).

Selecione nosso arquivo “xstream-1.4.2.jar”, e dê OK.

Objetos

O XStream cria nosso XML baseando-se em objetos, então devemos criar um objeto para o nosso XML. Eu o chamei de Animal, com as propriedades nome, especie e peso.

public class Animal {

    private String nome;
    private String especie;
    private float peso;

    public String getEspecie() {
        return especie;
    }

    public void setEspecie(String especie) {
        this.especie = especie;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public float getPeso() {
        return peso;
    }

    public void setPeso(float peso) {
        this.peso = peso;
    }
}

Criando o XML

Agora que podemos criar nosso XML, iremos criar um List para nossos animais, e criaremos 3 animais para ficar divertida a brincadeira.

import java.util.ArrayList;
import java.util.List;

public class Parser {

    public static void main(String[] args) {
        List<Animal> animais = new ArrayList<Animal>();

        Animal a1 = new Animal();
        a1.setNome("Gato");
        a1.setEspecie("Felis silvestris");
        a1.setPeso(2.3f);

        Animal a2 = new Animal();
        a2.setNome("Cavalo");
        a2.setEspecie("Equus ferus");
        a2.setPeso(103.1f);

        Animal a3 = new Animal();
        a3.setNome("Cão");
        a3.setEspecie("Canis lupus");
        a3.setPeso(5.3f);

        animais.add(a1);
        animais.add(a2);
        animais.add(a3);
    }
}

Instancie a classe XStream com o nome da variável de parser e em modo NO_REFERENCES. Para criarmos o XML, o método toXML() nos retorna uma string do XML pronto, porém precisamos passar como parâmetro nossa List. Então criemos uma variável do tipo String que receba esta string do método toXML().

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
import java.util.ArrayList;
import java.util.List;

public class Parser {

    public static void main(String[] args) {
        List<Animal> animais = new ArrayList<Animal>();
        XStream parser = new XStream(new DomDriver());
        parser.setMode(XStream.NO_REFERENCES);

        Animal a1 = new Animal();
        a1.setNome("Gato");
        a1.setEspecie("Felis silvestris");
        a1.setPeso(2.3f);

        Animal a2 = new Animal();
        a2.setNome("Cavalo");
        a2.setEspecie("Equus ferus");
        a2.setPeso(103.1f);

        Animal a3 = new Animal();
        a3.setNome("Cão");
        a3.setEspecie("Canis lupus");
        a3.setPeso(5.3f);
        
        animais.add(a1);
        animais.add(a2);
        animais.add(a3);
        
        String xml = parser.toXML(animais);
        System.out.println(xml);
    }
}

Se rodarmos, veremos o xml prontinho no Output.

  <parser.Animal>
    <nome>Gato</nome>
    <especie>Felis silvestris</especie>
    <peso>2.3</peso>
  </parser.Animal>
  <parser.Animal>
    <nome>Cavalo</nome>
    <especie>Equus ferus</especie>
    <peso>103.1</peso>
  </parser.Animal>
  <parser.Animal>
    <nome>C?o</nome>
    <especie>Canis lupus</especie>
    <peso>5.3</peso>
  </parser.Animal>
</list>

Com a string do XML pronta, é só salvar em um arquivo, mas ai deixo para você.

Lendo o XML

Já sabemos criar, agora iremos aprender a ler um XML, o que é simples também. Como nós criamos uma List que contém todos os nossos animais, devemos criar uma nova List, mas que receba o objeto do método fromXML(), lembrando de fazer o cast.

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
import java.util.ArrayList;
import java.util.List;

public class Parser {

    public static void main(String[] args) {
        List<Animal> animais = new ArrayList<Animal>();
        XStream parser = new XStream(new DomDriver());
        parser.setMode(XStream.NO_REFERENCES);

        Animal a1 = new Animal();
        a1.setNome("Gato");
        a1.setEspecie("Felis silvestris");
        a1.setPeso(2.3f);

        Animal a2 = new Animal();
        a2.setNome("Cavalo");
        a2.setEspecie("Equus ferus");
        a2.setPeso(103.1f);

        Animal a3 = new Animal();
        a3.setNome("Cão");
        a3.setEspecie("Canis lupus");
        a3.setPeso(5.3f);

        animais.add(a1);
        animais.add(a2);
        animais.add(a3);

        String xml = parser.toXML(animais);
        System.out.println(xml);

        List<Animal> animais2 = (List<Animal>) parser.fromXML(xml);
    }
}

Vamos exibir todos os animais no List, então criemos um novo objeto Animal e através de um laço for, exibimos todos os animais.

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
import java.util.ArrayList;
import java.util.List;

public class Parser {

    public static void main(String[] args) {
        List<Animal> animais = new ArrayList<Animal>();
        XStream parser = new XStream(new DomDriver());
        parser.setMode(XStream.NO_REFERENCES);

        Animal a1 = new Animal();
        a1.setNome("Gato");
        a1.setEspecie("Felis silvestris");
        a1.setPeso(2.3f);

        Animal a2 = new Animal();
        a2.setNome("Cavalo");
        a2.setEspecie("Equus ferus");
        a2.setPeso(103.1f);

        Animal a3 = new Animal();
        a3.setNome("Cão");
        a3.setEspecie("Canis lupus");
        a3.setPeso(5.3f);

        animais.add(a1);
        animais.add(a2);
        animais.add(a3);

        String xml = parser.toXML(animais);
        System.out.println(xml);

        List<Animal> animais2 = (List<Animal>) parser.fromXML(xml);
        Animal a4 = null;
        for (int i = 0; i < animais2.size(); i++) {
            a4 = (Animal) animais2.get(i);
            System.out.println("Animal #" + i);
            System.out.println("tNome: " + a4.getNome());
            System.out.println("tEsp?cie: " + a4.getEspecie());
            System.out.println("tPeso: " + a4.getPeso());
        }
    }
}

Rodando o programa, teremos um Output assim:

Animal #0
	Nome: Gato
	Espécie: Felis silvestris
	Peso: 2.3
Animal #1
	Nome: Cavalo
	Espécie: Equus ferus
	Peso: 103.1
Animal #2
	Nome: Cão
	Espécie: Canis lupus
	Peso: 5.3

Melhorando o XML

Notou que quando o XStream nos retorna o XML, nas tags Animal aparece um “parser.Animal”? Pois é, tem como mudar isso! O método alias() faz isto para nós. Vamos mudar algumas coisas, como ao invés de “list”, fazer aparecer “zoo” e no lugar de “parser.Animal”, aparecer “animal”.

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
import java.util.ArrayList;
import java.util.List;

public class Parser {

    public static void main(String[] args) {
        List<Animal> animais = new ArrayList<Animal>();
        XStream parser = new XStream(new DomDriver());
        parser.setMode(XStream.NO_REFERENCES);
        
        parser.alias("zoo", List.class);
        parser.alias("animal", Animal.class);

        Animal a1 = new Animal();
        a1.setNome("Gato");
        a1.setEspecie("Felis silvestris");
        a1.setPeso(2.3f);

        Animal a2 = new Animal();
        a2.setNome("Cavalo");
        a2.setEspecie("Equus ferus");
        a2.setPeso(103.1f);

        Animal a3 = new Animal();
        a3.setNome("Cão");
        a3.setEspecie("Canis lupus");
        a3.setPeso(5.3f);

        animais.add(a1);
        animais.add(a2);
        animais.add(a3);

        String xml = parser.toXML(animais);
        System.out.println(xml);

        List<Animal> animais2 = (List<Animal>) parser.fromXML(xml);
        Animal a4 = null;
        for (int i = 0; i < animais2.size(); i++) {
            a4 = (Animal) animais2.get(i);
            System.out.println("Animal #" + i);
            System.out.println("tNome: " + a4.getNome());
            System.out.println("tEsp?cie: " + a4.getEspecie());
            System.out.println("tPeso: " + a4.getPeso());
        }
    }
}

Pronto! Nosso XML está mais bonito agora:

<zoo>
  <animal>
    <nome>Gato</nome>
    <especie>Felis silvestris</especie>
    <peso>2.3</peso>
  </animal>
  <animal>
    <nome>Cavalo</nome>
    <especie>Equus ferus</especie>
    <peso>103.1</peso>
  </animal>
  <animal>
    <nome>Cão</nome>
    <especie>Canis lupus</especie>
    <peso>5.3</peso>
  </animal>
</zoo>

Conclusão

O XStream facilita muito nossa vida na hora de criar/ler um XML, porém deve-se prestar muita atenção na hora de ler o XML, pois a estrutura deve ser a mesma, senão pode causar erros. Mas no geral, é uma excelente biblioteca, recomendo.

Até mais.