Parseando XML com o DOM

Introdução
Oi pessoal! Neste tutorial vou mostrar em um exemplo bem prático como se faz para ler
um documento XML bem estruturado, com Java, jogando-se os dados dentro de uma
instância de classe mapeada pelo XML. Para tanto usaremos a API DOM, disponível no
JDK 1.4 da SUN. Esta API é muito mais interessante de usar do que a SAX, já que ela
mapeia diretamente um XML na memória. Mas como vocês podem deduzir, o gasto de
memória é alto, não aconselhado para XMLs gigantescos. Caso você não tenha java 1.4,
pode utilizar algum dos parsers XML padrão DOM criados pela Apache. Como por
exemplo o xerces.
O problema
Você tem um XML, e a estrutura deste XML é muito parecida com a estrutura de uma
classe sua, e você quer crar objetos de acordo com esse XML. Para nosso exemplo
prático vamos tomar como dados do XML o código:

1. <guj>
2. <usuario id="0">
3. <nome>Daniel Destro do Carmo</nome>
4. <idade>23</idade>
5. <email>danieldestro@uol.com.br</email>
6. </usuario>
7.
8. <usuario id="1">
9. <nome>Paulo Silveira</nome>
10. <idade>22</idade>
11. <email>paulo@paulo.com.br</email>
12. </usuario>
13.
14. <usuario id="2">
15. <nome>Rafael Steil</nome>
16. <idade>20</idade>
17. <email>xxx@yyy.com</email>
18. </usuario>
19.
20. <usuario id="3">
21. <nome>Guilherme Silveira</nome>
22. <idade>20</idade>
23. <email>aaaaaa@bbbbb.de</email>
24. </usuario>
25. </guj>

Iremos mapear o XML acima para objetos da classe UsuarioGUJ, descrita pelo código
Java a seguir:

1. public class UsuarioGUJ {

2. public int id;
3. public String nome;
4. public Integer idade;
 5. public String email;
6.
7. // construtor da classe
8. public UsuarioGUJ( int id, String nome, Integer idade, String email ) {
9. this.id = id;
10. this.nome = nome;
11. this.idade = idade;
12. this.email = email;
13. }
14. }

Decidi definir o atributo id como int pois leva-se em conta que ele é obrigatório; já os
outros atributos estão como tipos abstratos e suportam o valor null ou um valor do
mesmo tipo definido. Apenas uma questão de análise do seu problema. Nosso objetivo
aqui será ler o XML, e para cada item (tag) usuario encontrada no XML ele cria uma
instância da classe UsuarioGUJ e informa os valores lidos do XML e então adiciona
esta instância em um conjunto de objetos (Vector) compondo os usuários do guj
cadastrados no XML. A classe GujXmlReader terá a responsabilidade de ler o conteúdo
do arquivo XML e popular os dados da intância da classe UsuarioGUJ. É neste exato
ponto deste artigo que será exemplificado o código Java para que o conteúdo do XML
seja lido e populado no nosso programa.

1. import java.io.*;
2. import java.net.*;
3. import java.util.*;
4. import javax.xml.parsers.*;
5. import org.w3c.dom.*;
6.
7. public class GujXmlReader {
8.
9. // caminho (path) do arquivo XML
10. private String xmlPathname;
11.
12. // construtor que seta o caminho do XML
13. public GujXmlReader( String path ) {
14. xmlPathname = path;
15. }

Até aqui muti simples. Criamos a classe que irá ler o XML, e com um construtor que
recebe o caminho para o arquivo que iremos ler. Vamos começar a criar o método que
nos retorna o Vector de UsuarioGUJ:

1. // le o XML carregando os dados dos usuários em um Vector.

2. // retorna o vector contendo os usuários cadastrados no XML.
3. public Vector lerUsuariosGuj() throws Exception {
4. DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
5. DocumentBuilder db = dbf.newDocumentBuilder();
6. Document doc = db.parse( xmlPathname );
Pela classe DocumentBuildFactory, você pega uma factory e depois consegue um
DocumentBuilder, que vai fazer o parse do XML. Após a chamada do parser, temos um
objeto do tipo Document. DocumentBuilder e a sua Factory estão no pacote
javax.xml.parsers do java 1.4. Se você não tem java 1.4, vai precisar puxar um parser do
apache: xerces ou xalan, e colocar o .jar no classpath. lembre de modificar o import.
Essas interfaces estão no pacote org.w3c.dom. Agora é o ótimo momento para que você
leia as classes do pacote org.w3c.dom. Clique aqui para a API. Vamos pegar o elemento
principal do documento, que é o , e depois explodi-lo em uma lista de nós, cada um
representado um usuário!

1. Element elem = doc.getDocumentElement();

2. // pega todos os elementos usuario do XML
3. NodeList nl = elem.getElementsByTagName( "usuario" );
4.
5. // prepara o vetor
6. Vector usuarios = new Vector();

Tendo todos os nós do XML, percorremos esses nós e começamos a pegar os dados,
através dos elementos desses nós! Criamos um usuarioGUJ para cada nó e vamos
colocando eles no Vector, para depois retorná-lo.

1. // percorre cada elemento usuario encontrado

2. for( int i=0; i<nl.getLength(); i++ ) {
3. Element tagUsuario = (Element) nl.item( i );
4.
5. // pega os dados cadastrado para o usuario atual
6. int id = Integer.parseInt( tagUsuario.getAttribute( "id" ) );
7. String nome = getChildTagValue( tagUsuario, "nome" );
8. Integer idade = new Integer( getChildTagValue( tagUsuario, "idade" ) );
9. String email = getChildTagValue( tagUsuario, "email" );
10.
11. // cria uma nova instancia do UsuarioGuj com os dados do xml
12. UsuarioGUJ usuarioGuj = new UsuarioGUJ( id, nome, idade, email );
13.
14. // adiciona o usuario na coleção (vector) de usuários do guj
15. usuarios.addElement( usuarioGuj );
16. }
17.
18. return usuarios;
19. }

A chamada getChildTagValue retorna o texto que esta contido dentro de uma

determinada tag, o método está a seguir:

1. // este método lê e retorna o conteúdo (texto) de uma tag (elemento)

2. // filho da tag informada como parâmetro. A tag filho a ser pesquisada
3. // é a tag informada pelo nome (string)
 4. private String getChildTagValue( Element elem, String tagName ) throws Exc
eption {
5. NodeList children = elem.getElementsByTagName( tagName );
6. if( children == null ) return null;
7. Element child = (Element) children.item(0);
8. if( child == null ) return null;
9. return child.getFirstChild().getNodeValue();
10. }
11. }

Fim do reader! A gente só precisa usá-lo! Para finalizarmos o código do nosso

programa teremos mais uma classe, a CadastroUsuariosGUJ. Ela apenas lê o XML e
roda o nosso programa!

1. import java.util.Vector;
2.
3. public class CadastroUsuariosGUJ {
4.
5. public CadastroUsuariosGUJ() {
6. try {
7. // informe o caminho correto do seu arquivo xml
8. GujXmlReader reader = new GujXmlReader( "C:\\cadastro_guj.xml" );
9.
10. Vector usuarios = reader.lerUsuariosGuj();
11.
12. // imprime na tela os usuarios cadastrados
13. for( int i=0; i<usuarios.size(); i++ ) {
14. UsuarioGUJ usuario = (UsuarioGUJ) usuarios.get( i );
15.
16. System.out.println( "Usuario id: " + usuario.id );
17. System.out.println( " nome: " + usuario.nome );
18. System.out.println( " idade: " + usuario.idade );
19. System.out.println( " email: " + usuario.email );
20. }
21. } catch( Exception e ) {
22. e.printStackTrace();
23. }
24. }
25.
26. public static void main( String[] args ) {
27. new CadastroUsuariosGUJ();
28. }
29. }

Conclusão
Esta solução é trivial e não muito performática, mas funciona. Pela experiência que tive
com o DOM XML eu consegui resolvi assim o meu problema para ler o conteúdo de
uma estrutra em XML e popular os dados no meu aplicativo. Os arquivos supracitados
estão disponíveis para download aqui. Bom, espero que este tutorial tenha sido bem
proveitoso.