XML. Introdução UNIDADEB

(1)

15

Sistema Universidade

Aberta do Brasil - UAB | IF Sul-rio-grandense

Nesta unidade, você irá conhecer a linguagem XML (Extensible Markut Language). A XML é, na atualidade,

ex-tremamente popular, pois permite codificar dados, independente da linguagem de programação, para a troca de

dados entre diferentes programas de forma padronizada.

Os objetivos que norteiam a unidade B são:

• Conhecer a XML entendendo os seus elementos e atributos;

• Entender o conceito de um analisador sintático de XML;

• Ler, gravar e modificar documentos XML com a Linguagem Java.

Introdução

Muitas vezes necessitamos armazenar informações de uma forma mais simples que o uso de um banco de

dados. Os bancos de dados são excelentes para armazenar informações, porém não são adequados quando se

faz necessário para armazenar a configuração de algum sistema ou transmitir alguma informação para outro

programa.

Uma forma utilizada é o uso de arquivos. Podemos utilizar arquivos texto, por exemplo. A Figura B.1 apresenta

um exemplo de um arquivo que contém todas as configurações de um determinado laboratório de uma escola.

Este arquivo pode ser útil para o administrador do laboratório, mantendo nesse arquivo o registro dos

compu-tadores do laboratório. Contudo, o formato deste arquivo é ad hoc, ou seja, não possui um padrão conhecido

universalmente, o padrão foi definido pelo próprio administrador do laboratório.

Além disso, há problemas com essa codificação, nós não conseguimos delimitar as informações de um

compu-tador do laboratório. Torna-se difícil analisar sintaticamente e de forma automatizada (por um programa) esse

arquivo com as configurações dos computadores, uma vez que não possuímos delimitação entre as informações

contidas em uma linha. A análise sintática (também conhecida pelo termo em parsing) é o processo de analisar

uma sequência de entrada (lida de um arquivo, por exemplo) para determinar sua estrutura gramatical segundo

uma determinada gramática.

Você poderá pensar: por que não colocamos um delimitador entre as diferentes informações dos computadores

(exemplo na Figura B.2). Porém, mesmo assim esse arquivo apresenta dificuldades de análise e não possui uma

forma padronizada.

XML

(2)

Desenvolvimento de Aplicações Orientado a Objetos | Unidade B

Nesta unidade, será apresentada a Extensible Markut Language (XML), que é um mecanismo padronizado para

codificação de dados e não depende de nenhuma linguagem de programação. A XML permite codificar os dados

de forma que os destinatários dos dados possam de forma simples fazer a análise sintática. A XML é

extrema-mente popular para a troca de dados e permite que uma grande variedade de programas possam facilextrema-mente

manipular dados XML.

A XML possui uma estrutura aninhada que pode ser utilizada para descrever conjunto de dados hierárquicos.

Como o formato de XML é padronizado, existem diversas bibliotecas em diversas linguagens de programação

que permitem manipular com documentos XML tornando fácil, para serem utilizados pelos programadores.

Documentos XML

Os documentos XML são legíveis por programas de computador e também por pessoas. Vamos apresentar um

exemplo bem simples de dados que podem ser codificados em XML. Por exemplo, necessitamos codificar os

da-dos de nome e idade de uma pessoa. No exemplo mostrado Figura B.3, colocaríamos uma informação em cada

linha para não necessitar a manipulação de espaços em branco.

Em XML, a codificação de tais dados será da forma apresentada na Figura B.4. A vantagem da codificação XML é

que você pode examinar os dados e entender o que significam. Isso facilita o entendimento do programador e

consequentemente a sua programação. Outra vantagem, é a flexibilidade para alteração e inclusão de novos

da-dos. Por exemplo, se fosse necessário incluir o endereço da pessoa seria extremamente simples (apenas incluir

mais uma linha).

Durante o seu curso superior de Tecnologia de Sistemas para Internet, você já manipulou muitas vezes arquivos

HTML e deve ter notado que há similaridade entre o formato XML e HTML. Por exemplo, nas marcas <nome> e

</nome> e nas marcas de HTML como <h1> </h1>. Tanto em HTML como XML as marcas são incluídas entre os

sinais maior e menor (< e >) e a marca de abertura vem acompanhada de uma marca de fechamento que começa

com a barra (/).

(3)

17 Tanto XML como HTML são descendentes da SGML (Standard Generalized Markup Language). A SGML foi

desen-volvida nos anos 70 para especificar conjuntos de regras e criar documentos que se ajustam ao um conjunto de

regras. Em 1996, o World Wide Web Consorsium (http://www.w3.org) iniciou discussões sobre o uso da SGML na

web. Como resultado desta discussão nasceu a XML. Em 1998, foi lançada a especificação da XML 1.0 (bem mais

simples que a especificação da SGML).

Algumas das especificações da XML:

• Em XML, existe diferença entre letras maiúsculas e minúsculas das marcas, ou seja, <li> e <LI> são completamente

dife-rentes para XML;

• Cada marca deve ter a correspondente final, ou seja, sempre a abertura de uma marca possui o seu fechamento

(exemplo: <marca> </marca>);

• Se não tiver marca de fechamento, ela deve fechar com />, por exemplo, <img src =”marca.jpg”/>;

• Os valores do atributos devem aparecer entre aspas, por exemplo, <img src =”marca.jpg” width=”400” height=”300”/>.

Não serão aceitos os valores dos atributos sem aspas.

Um conjunto de dados XML é chamado de documento. Este documento com um cabeçalho contém elementos

de texto. O padrão XML recomenda que cada documento XML comece com um cabeçalho da seguinte forma:

<?xml version=”1.0”>

Em seguida, os documentos contêm dados propriamente ditos e esses dados estão contidos em um elemento

raiz como apresentado da seguinte forma:

<?xml version=”1.0”>

<pessoa>

outros dados

</pessoa>

Um elemento pode apresentar duas formas válidas:

<marcaDoElemento atributos opcionais> dados </ marcaDoElemento >

ou

<marcaDoElemento atributos opcionais/>

No primeiro caso acima, o elemento contém elementos, texto ou uma combinação de ambos (conteúdo misto).

As Figuras B.5 e B.6 apresentam exemplos, utilizando conteúdo misto (Figura B.5) e sem conteúdo misto (Figura

B.6). Evite misturar conteúdos para descrição de dados, ou seja, para representar dados, utilize a forma da Figura

B.6. Utilize a forma mista (utilizando atributos) para descrever como interpretar o conteúdo do elemento.

(4)

Desenvolvimento de Aplicações Orientado a Objetos | Unidade B

Um exemplo de uso de elementos com atributos é apresentado na Figura B.7. Neste exemplo, cada pessoa

po-deria ter um identificador (id).

Por fim, a Figura B.8 apresenta o exemplo do arquivo XML que descreve os dados do laboratório de uma escola

descritos na Figura B.1.

(5)

19 D

ica

http://www.w3.org/standards/xml/

Lendo Documentos XML

Neste item, você encontrará subsídios para aprender a ler documentos XML na linguagem Java e utilizar os dados

lidos em um programa. É bastante fácil ler (e também gravar) documentos XML em Java. Na verdade, geralmente

é mais fácil utilizar arquivos XML do que no formato ad hoc. Desta maneira os seus programas se tornam mais

profissionais e fáceis de programar.

Para ler um documento XML, é necessário um analisador sintático (parser) de XML. Os analisadores são

progra-mas que leem o documento e verificam se ele está sintaticamente correto e realizam alguma ação à medida que

processam o documento.

Existem dois tipos de analisadores sintáticos comumente utilizados em XML. Um deles segue a especificação

chamada SAX (Simple Access to XML) e outro segue a especificação chamada DOM (Document Object Model).

Os analisadores SAX são baseados em eventos e os analisadores DOM constroem uma árvore que representa o

documento analisado sintaticamente.

Os analisadores SAX apresentam uma vantagem: são mais eficientes para processar grandes documentos XML

(pois não necessitam construir uma árvore sintática). Já os analisadores DOM são mais fáceis de utilizar na

maio-ria dos aplicativos. Nesta unidade, serão utilizados os analisadores DOM.

O padrão DOM define uma interface Document no pacote org.w3c.dom. Tal interface fornece métodos para

ana-lisar e modificar a estrutura da árvore que representa o documento XML. Uma árvore DOM contém um número

de nós (Node). Node é uma interface e é um tipo de dado base do DOM. Tudo em uma árvore é um Node. O DOM

define algumas sub-interfaces da interface Node:

• Element: representa um elemento XML;

• Attr: representa um atributo do elemento XML;

• Text: é o conteúdo de um elemento. Isso significa que um elemento com informação do tipo texto contém um filho do

tipo nó de texto;

A interface Document representa todo o documento XML. Apenas um objeto Document existe em cada XML que

você faz o parsing. Geralmente será necessário chamar seguintes métodos:

Document.getDocumentElement(): retorna o elemento raiz da árvore DOM;

Node.getFirstChild() e Node.getLastChild(): retorna o primeiro elemento filho ou o último elemento filho de um

determinado nó.

A Figura B.9 apresenta um documento XML que representa uma agenda de contatos com nome, telefone e

ida-de. Já a Figura B.10 mostra a árvore que será gerada a partir da interface Document. Essa árvore será de grande

utilidade para o entendimento da manipulação dos documentos XML em Java.

(6)

Desenvolvimento de Aplicações Orientado a Objetos | Unidade B

O exemplo a seguir apresenta a leitura do documento XML, descrito na Figura B9 e armazena estes dados em

uma coleção de objetos (ArrayList). Para ler este documento de um arquivo XML, são necessárias várias etapas:

• A interface Document descreve a estrutura em árvore de um documento XML. Para gerar um objeto que implementa a

interface Document, você necessita de um DocumentBuilder. O DocumentBuilder pode ler um documento XML a partir

de um arquivo URL ou fluxo de entrada e o resultado é um objeto Document, que contém uma árvore (linhas 17-19);

• É utilizada a classe File para realizar a leitura do XML a partir de um arquivo (linha 21);

• Após a criação do documento, é realizado o parsing (análise) do XML (linha 23);

• Depois de lido o documento XML, você pode analisá-lo ou modificá-lo. Para isso, você deve utilizar o método

getDocu-mentElement() da interface Document para retornar o elemento raiz (linha 25). A árvore de documento é composta de

nodos. Os tipos de nodos mais importantes são Element e Text;

• A partir do elemento raiz, você pode obter a lista de elementos filhos. O DOM fornece um tipo especial de interface de

coleção chamada NodeList usada para referenciar uma lista de referências do tipo Node. Ou seja, sempre que

desejar-mos obter os filhos de um elemento, devedesejar-mos utilizar esse método, mesmo sabendo que este determinado elemento

possui apenas um sub-elemento (linha 27);

(7)

21 • Como temos uma coleção de elementos contato, vamos percorrer cada um deles para obter as informações que

que-remos através de um laço (linha 29);

• Para cada contato, vamos obter um NodeList com os elementos do tipo “nome”. Sabendo que o arquivo XML tem

apenas um elemento do tipo nome para cada elemento do tipo contato, podemos fazer referência diretamente para o

primeiro elemento dessa lista (item(0)). Para pegar o valor deste nó texto, devemos utilizar o método getFirstChild() e

após o método getNodeValue() para obter o valor do nodo (linhas 32-34);

• O mesmo processo deve ser repetido para os elementos do tipo “telefone” e “idade” (linhas 36-38 e 40-42). Apenas

observe que sempre o método getNodeValue() retorno um tipo String, porém se desejamos converter o valor para int

devemos utilizar o método Integer.parseInt() que converte um valor String para int;

• Após obter os dados do documento XML, as variáveis novoNome, novoTelefone e novaIdade armazenam os dados

obtidos do XML;

• Para armazenarmos estes dados em uma coleção de objetos, necessitamos primeiro criar um objeto da classe Contato

(linha 44-45) e armazenar na coleção de objetos - agenda (linha 47);

• Nas linhas 50-53, é realizada a impressão dos itens armazenados na coleção agenda;

• Por fim, observe que foi necessário importar uma série de classes e interfaces da API Java (linha 3-10).

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. package ifsul.tsiad.exemplosXML; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import java.util.ArrayList; import java.io.File;

public class LeitorXML1 {

public static void main(String[] args) throws Exception { // Irá armazenar os contatos em um ArrayList (agenda) ArrayList agenda = new ArrayList();

// 1. Criar o documento XML DocumentBuilderFactory factory =

DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newDocumentBuilder();

// 2. Ler o XML a partir de um arquivo File f = new File("agenda.xml");

// 3. Realizar a analise do documento XML Document doc = builder.parse(f);

// 4. Obter o elemento raiz

Element raiz = doc.getDocumentElement();

// 5. Obter os elemento da agenda (os contatos)

NodeList contatos = raiz.getElementsByTagName("contato");

// 6. Obter os elementos (nome, telefone, idade) de cada contato for (int i=0; i<contatos.getLength(); i++){

Element contato = (Element) contatos.item(i); // 7. Obter o primeiro elemento do contato (nome) NodeList nomes = contato.getElementsByTagName("nome"); Node nome = nomes.item(0).getFirstChild();

String novoNome = nome.getNodeValue();

// 8. Obter o segundo elemento do contato (telefone)

NodeList telefones = contato.getElementsByTagName("telefone"); Node telefone = telefones.item(0).getFirstChild();

String novoTelefone = telefone.getNodeValue(); // 9. Obter o terceiro elemento do contato (idade) NodeList idades = contato.getElementsByTagName("idade"); Node idade = idades.item(0).getFirstChild();

int novaIdade = Integer.parseInt(idade.getNodeValue()); // 10. Criar um objeto de Contato a partir dos dados lidos Contato novoContato = new Contato(novoNome,

novoTelefone, novaIdade); // 11. Adicinar o objeto na agenda (ArrayList)

agenda.add(novoContato); }

// Imprimir os dados armazenados na agenda (ArrayList) for(int i=0;i<agenda.size();i++){

Contato contato = (Contato) agenda.get(i); System.out.println(contato);

} } }

(8)

Desenvolvimento de Aplicações Orientado a Objetos | Unidade B

O código a seguir apresenta a classe Contato necessária para criar os objetos do tipo Contato.

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. package ifsul.tsiad.exemplosXML;

public class Contato { private String nome; private String telefone; private int idade;

public Contato(String nome, String telefone, int idade) { this.nome = nome;

this.telefone = telefone; this.idade = idade; }

public int getIdade() { return idade; }

public void setIdade(int idade) { this.idade = idade;

}

public String getNome() { return nome;

}

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

}

public String getTelefone() { return telefone;

}

public void setTelefone(String telefone) { this.telefone = telefone;

}

public String toString(){

return (this.nome + "\n" + this.telefone + "\n" + this.idade); }

}

O código a seguir apresenta o mesmo código apresentado anteriormente para ler um documento XML. Porém

este programa Java é bem melhor estruturado, sendo organizado em diferentes métodos e utilizando o correto

tratamento de exceções.

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. package ifsul.tsiad.exemplosXML; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import java.util.ArrayList; import java.io.File;

public static void main(String[] args) throws Exception { // Irá armazenar os contatos em um ArrayList (agenda) ArrayList agenda = new ArrayList();

// 1. Criar o documento XML DocumentBuilderFactory factory =

// 2. Ler o XML a partir de um arquivo File f = new File("agenda.xml");

// 3. Realizar a analise do documento XML Document doc = builder.parse(f);

// 4. Obter o elemento raiz

// 5. Obter os elemento da agenda (os contatos)

// 6. Obter os elementos (nome, telefone, idade) de cada contato for (int i=0; i<contatos.getLength(); i++){

Element contato = (Element) contatos.item(i); // 7. Obter o primeiro elemento do contato (nome) NodeList nomes = contato.getElementsByTagName("nome"); Node nome = nomes.item(0).getFirstChild();

String novoNome = nome.getNodeValue();

// 8. Obter o segundo elemento do contato (telefone)

NodeList telefones = contato.getElementsByTagName("telefone"); Node telefone = telefones.item(0).getFirstChild();

String novoTelefone = telefone.getNodeValue(); // 9. Obter o terceiro elemento do contato (idade) NodeList idades = contato.getElementsByTagName("idade"); Node idade = idades.item(0).getFirstChild();

int novaIdade = Integer.parseInt(idade.getNodeValue()); // 10. Criar um objeto de Contato a partir dos dados lidos Contato novoContato = new Contato(novoNome,

novoTelefone, novaIdade); // 11. Adicinar o objeto na agenda (ArrayList)

agenda.add(novoContato); }

// Imprimir os dados armazenados na agenda (ArrayList) for(int i=0;i<agenda.size();i++){

} } }

(9)

23

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. package ifsul.tsiad.exemplosXML; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import org.xml.sax.SAXException; import java.util.ArrayList; import java.io.IOException; import java.io.File;

public ArrayList lerXML(String nomeArquivoXML) throws

ParserConfigurationException, SAXException, IOException { DocumentBuilderFactory factory =

File f = new File(nomeArquivoXML); Document doc = builder.parse(f);

NodeList contatos = raiz.getElementsByTagName("contato"); ArrayList agenda = new ArrayList();

for (int i=0; i<contatos.getLength(); i++){ Element contato = (Element) contatos.item(i); Contato novoContato =

new Contato(obtemItensContato(contato, "nome"), obtemItensContato(contato, "telefone"), Integer.parseInt(obtemItensContato(contato, "idade"))); agenda.add(novoContato); } return agenda; }

public String obtemItensContato(Element contato, String itemContato){ NodeList listaItens = contato.getElementsByTagName(itemContato); Node item = listaItens.item(0).getFirstChild();

return item.getNodeValue(); }

public static void main(String[] args) { try {

LeitorXML2 leitor = new LeitorXML2();

ArrayList agenda = leitor.lerXML("agenda.xml"); for(int i=0;i<agenda.size();i++){

}

} catch (ParserConfigurationException e) {

System.out.println("parser não foi configurado corretamente"); } catch (SAXException e) {

System.out.println("problema ao analisar o arquivo XML"); } catch (IOException e) {

System.out.println("arquivo não pode ser lido"); }

} }

1. _D

_ica

}

Para entender melhor as classes e interfaces utilizadas, acesse a documentação da API Java:

http://download.oracle.com/javase/6/docs/api/index.html

(10)

24 Desenvolvimento de Aplicações Orientado a Objetos | Unidade B

Criando Documentos XML

No item 3, você aprendeu ler um documento XML e armazenar em uma estrutura de dados dentro do Java.

Neste item, você irá aprender como criar e salvar dados um documento XML.

O processo é bem similar ao processo anterior. Porém, necessitamos criar o documento XML e criar os nodos.

No exemplo anterior, foi utilizado o objeto DocumentBuilder para interpretar um documento XML. Você também

necessita deste objeto para criar um documento novo e vazio.

A classe Document também possui métodos para criar nodos de elementos e de texto. Para isto, utilize os

se-guintes métodos:

• createElement(): este método permite a criação de nodos de elementos;

• createTextNode(): este método permite a criar nodos de texto.

Por fim, para salvar um documento XML em um fluxo (por exemplo, um arquivo) são utilizadas algumas classes

de transformação de XML. Isto é um tópico avançado, porém para esta finalidade você não necessita saber muito

sobre transformações.

O código a seguir apresenta a transformação (escrita) de uma coleção de objetos em um documento XML. Neste

exemplo, a coleção catalogoDeFilmes armazena objetos do tipo Filme, os quais são armazenados em um arquivo

XML.

Durante a escrita devem-se salientar os seguintes pontos:

• Para criar um novo documento, primeiro crie a fábrica de construtores de documento, em seguida o construtor de

documentos e por fim o documento vazio através do método newDocument() (linhas 23-27);

• Iniciamos a criação dos nodos pelo elemento raiz através do método createElement() (linha 29);

• Após devemos criar toda a estrutura da árvore: criando os nodos através do método createElement() e realizando as

ligações da árvore (adicionado os filhos) através do método appendChild() (linhas 36-45);

• São necessárias as classes de transformação para escrever no documento XML. Crie um Transformer e após a

trans-forme o Document em uma DMSource, e seu fluxo de saída em uma StreamResult. O Transtrans-former grava o documento

XML sem espaços e quebras de linha (linhas 49-55);

• Já que o programa está organizado em métodos no método main são criados os objetos Filme e armazenados na

cole-ção (ArrayList) catalogoDeFilmes, também é realizada a impressão dos elementos da colecole-ção;

• Por fim, na linha 73 é chamado o método armazenar() que armazena os elementos da coleção em um arquivo XML de

nome catalogo.xml.

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. package ifsul.tsiad.exemplosXML; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; import javax.xml.transform.Transformer; import javax.xml.transform.TransformerException; import javax.xml.transform.TransformerFactory; import javax.xml.transform.dom.DOMSource; import javax.xml.transform.stream.StreamResult; import java.io.FileOutputStream; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.Text; import org.xml.sax.SAXException; import java.io.IOException; import java.util.ArrayList;

public class CriarXML {

public void armazenar(ArrayList catalago, String nomeArquivoXML) throws ParserConfigurationException, SAXException, IOException, TransformerException {

DocumentBuilderFactory factory =

// 1. Criar um novo documento através do método newDocument() Document doc = builder.newDocument();

// 2. Criar o elemento raiz

Element catalogoElement = doc.createElement("catalogo"); // 3. Criar a estrutura de árvore para cada Filme // armazenado na coleção

// - deve ser criar os nodos e inserido o texto // (nomes e genero dos filmes)

for(int i=0;i<catalago.size();i++){

Filme filme = (Filme) catalago.get(i);

Element filmeElement = doc.createElement("filme"); Element tituloElement = doc.createElement("titulo"); Text valorTitulo = doc.createTextNode(filme.getTitulo()); tituloElement.appendChild(valorTitulo);

Element generoElement = doc.createElement("genero"); Text valorGenero = doc.createTextNode(filme.getGenero()); generoElement.appendChild(valorGenero); filmeElement.appendChild(tituloElement); filmeElement.appendChild(generoElement); catalogoElement.appendChild(filmeElement); } doc.appendChild(catalogoElement);

// 4. Uso das classes de transformação para escrever no arquivo TransformerFactory transFactory =

TransformerFactory.newInstance(); Transformer transformer = transFactory.newTransformer();

DOMSource source = new DOMSource(doc); StreamResult result = new StreamResult(

new FileOutputStream(nomeArquivoXML)); transformer.transform(source, result);

}

(11)

25 Desenvolvimento de Aplicações Orientado a Objetos | Unidade B

64. 65. 66. 67. 68. 69. 70. 71. 72. 73. 74. 75. 76. 77. 78. 79. 80. 81. 82. 83. 84. "Policial"));

// Imprime para verificar

for(int i=0;i<catalogoFilmes.size();i++){

Filme filme = (Filme) catalogoFilmes.get(i); System.out.println(filme);

} try {

CriarXML criarXML = new CriarXML();

// Salva os dados da coleção no arquivo XML

criarXML.armazenar(catalogoFilmes, "catalogo.xml"); } catch (ParserConfigurationException e) {

System.out.println("parser não foi configurado corretamente"); } catch (TransformerException e) {

System.out.println("transformação da árvore XML sem sucesso"); } catch (SAXException e) {

} }

O código a seguir apresenta a classe Filme, necessária para o funcionamento da classe anterior (que realizava a

gravação em um documento XML).

2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; import javax.xml.transform.Transformer; import javax.xml.transform.TransformerException; import javax.xml.transform.TransformerFactory; import javax.xml.transform.dom.DOMSource; import javax.xml.transform.stream.StreamResult; import java.io.FileOutputStream; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.Text; import org.xml.sax.SAXException; import java.io.IOException; import java.util.ArrayList;

public class CriarXML {

public void armazenar(ArrayList catalago, String nomeArquivoXML) throws ParserConfigurationException, SAXException, IOException, TransformerException {

DocumentBuilderFactory factory =

// 1. Criar um novo documento através do método newDocument() Document doc = builder.newDocument();

// 2. Criar o elemento raiz

Element catalogoElement = doc.createElement("catalogo"); // 3. Criar a estrutura de árvore para cada Filme // armazenado na coleção

// - deve ser criar os nodos e inserido o texto // (nomes e genero dos filmes)

for(int i=0;i<catalago.size();i++){

Filme filme = (Filme) catalago.get(i);

Element filmeElement = doc.createElement("filme"); Element tituloElement = doc.createElement("titulo"); Text valorTitulo = doc.createTextNode(filme.getTitulo()); tituloElement.appendChild(valorTitulo);

Element generoElement = doc.createElement("genero"); Text valorGenero = doc.createTextNode(filme.getGenero()); generoElement.appendChild(valorGenero); filmeElement.appendChild(tituloElement); filmeElement.appendChild(generoElement); catalogoElement.appendChild(filmeElement); } doc.appendChild(catalogoElement);

// 4. Uso das classes de transformação para escrever no arquivo TransformerFactory transFactory =

}

public static void main(String[] args) {

ArrayList catalogoFilmes = new ArrayList(); // Armazena os filmes na coleção

catalogoFilmes.add(new Filme("O Poderoso Chefao", "Drama")); catalogoFilmes.add(new Filme("Tootsie", "Comedia"));

(12)

Desenvolvimento de Aplicações Orientado a Objetos | Unidade B

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. package ifsul.tsiad.exemplosXML;

public class Filme { private String titulo; private String genero;

public Filme(String titulo, String genero) { this.titulo = titulo;

this.genero = genero; }

public String getGenero() { return genero;

}

public void setGenero(String genero) { this.genero = genero;

}

public String getTitulo() { return titulo;

}

public void setTitulo(String titulo) { this.titulo = titulo;

}

public String toString(){

return (this.titulo + "\n" + this.genero); }

}

A Figura B.11 apresenta o documento XML gerado pelo programa. Cabe salientar que não apresenta espaços em

branco e quebras de linha (foram inseridos para melhor visualização).

Modificando Documentos XML

A modificação de um documento XML é muito similar a sua leitura e criação. O que é realizado é a alteração de

alguns nodos ou inserção de outros na árvore e, após, o documento XML deve ser salvo novamente.

O código a seguir apresenta um exemplo que modifica o documento XML da Figura B9. O objetivo do programa

é encontrar o nome “Jose da Silva” e substituir por “Jose Bueno da Silva”. Para tanto, deve ser lido o documento

XML como já aprendemos. Após, devemos localizar o nodo que possui o texto “Jose da Silva” e substituí-lo por

“Jose Bueno da Silva”.

(13)

27 • Obter os contatos a partir do elemento raiz como já realizado na leitura (linhas 30-31);

• Para cada elemento do contato, encontrar o nome com o tipo “nome” e verificar se é o que procuramos (linhas 33-40);

• Se o valor do nodo for igual ao nome procurado (linha 40), criar um novo nodo com elemento e texto (linhas 43-44);

• Após, substituir o nodo antigo pelo novo nodo (com a informação atualizada) através do método replaceChild() (linha

48);

• Por fim, gravar o documento XML através das classes de transformação (linhas 52-58).

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. package ifsul.tsiad.exemplosXML; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; import javax.xml.transform.Transformer; import javax.xml.transform.TransformerException; import javax.xml.transform.TransformerFactory; import javax.xml.transform.dom.DOMSource; import javax.xml.transform.stream.StreamResult; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import org.w3c.dom.Text; import org.xml.sax.SAXException; import java.io.IOException; import java.io.FileOutputStream; import java.io.File;

public class ModificarXML {

public void lerEmodificarXML(String nomeArquivoXML) throws

ParserConfigurationException, SAXException, IOException, TransformerException {

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

DocumentBuilder builder = factory.newDocumentBuilder(); File f = new File(nomeArquivoXML);

Document doc = builder.parse(f);

// Para cada contato deve verificar o nome que deseja substituir for (int i=0; i<contatos.getLength(); i++){

Element elementoContato = (Element) contatos.item(i); // Obtem o nodo que possui o elemento do tipo "nome" Node nome =

elementoContato.getElementsByTagName("nome").item(0); System.out.println(nome.getFirstChild().getNodeValue()); // Verifica se o nome é o que se deseja alterar

if(nome.getFirstChild().getNodeValue().equals("Jose da

Silva")){ // Cria um novo nodo com elemento e texto

Element novoNome = doc.createElement("nome"); Text valorNome = doc.createTextNode("Jose Bueno da

Silva"); novoNome.appendChild(valorNome);

// Troca o nodo filho antigo pelo novo

elementoContato.replaceChild(novoNome, nome); }

}

TransformerFactory transFactory =

(14)

Desenvolvimento de Aplicações Orientado a Objetos | Unidade B

60. 61. 62. 63. 64. 65. 66. 67. 68. 69. 70. 71. 72. 73. 74. 75.

public static void main(String[] args) { try {

ModificarXML modifica = new ModificarXML(); modifica.lerEmodificarXML("agenda.xml");

} catch (ParserConfigurationException e) {

System.out.println("parser não foi configurado corretamente"); } catch (TransformerException e) {

System.out.println("transformação da árvore XML sem sucesso"); } catch (SAXException e) {

} }

D

ica

Estude mais sobre XML. Procure se informar sobre como produzir Definições de Tipos de Documento (DTD). DTD

é uma sequência de regras que descreve os elementos filhos e atributos válidos para cada tipo de elemento.

(15)

29 Atividade 2

Prezado(a) aluno(a), as atividades da Unidade B (XML) versam sobre o desenvolvimento de dois programas em

Java que manipulam documentos XML. Desta forma, você deve desenvolver esses programas na linguagem Java

e os executar no NetBeans.

1. Desenvolva um programa em Java que leia o documento XML, apresentado a seguir, e armazene em uma estrutura de

dados do tipo coleção. Após a leitura e armazenamento das informações, escreva estes dados na tela (console).

<?xml version=”1.0”>

<laboratorio>

<computador>

<modelo>Pentium 4</modelo>

<frequencia>3.0GHZ</frequencia>

<memoria>256 MB</memoria>

<hd>250GB</hd>

</computador>

<computador>

<modelo>Intel Dual Core</modelo>

<frequencia>1.8GHZ</frequencia>

<memoria>3GB</memoria>

<hd>500GB</hd>

</computador>

<computador>

<modelo>Phenom II X4</modelo>

<frequencia>3.0GHZ</frequencia>

<memoria>3GB</memoria>

<hd>500GB</hd>

</computador>

<computador>

<modelo> Celeron </modelo>

<frequencia>2.8GHZ </frequencia>

<memoria>512MB </memoria>

<hd>250GB</hd>

</computador>

</laboratorio>

2. Desenvolva um programa na linguagem Java que:

(16)