XML. Introdução UNIDADEB

Transcrição

1 Nesta unidade, você irá conhecer a linguagem XML (Extensible Markut Language). A XML é, na atualidade, extremamente 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. UNIDADEB XML 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 computadores 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 computador 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. 15

2 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 é extremamente popular para a troca de dados e permite que uma grande variedade de programas possam facilmente 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 dados 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 dados. 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 (/). 16

3 Tanto XML como HTML são descendentes da SGML (Standard Generalized Markup Language). A SGML foi desenvolvida 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 ( 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 diferentes 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. 17

4 Um exemplo de uso de elementos com atributos é apresentado na Figura B.7. Neste exemplo, cada pessoa poderia 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. 18

5 Dica Leia mais sobre a especificação da XML (em inglês): 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 programas 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 maioria 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 analisar 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 idade. 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. 19

6 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 getdocumentelement() 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 desejarmos obter os filhos de um elemento, devemos utilizar esse método, mesmo sabendo que este determinado elemento possui apenas um sub-elemento (linha 27); 20

7 Como temos uma coleção de elementos contato, vamos percorrer cada um deles para obter as informações que queremos 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 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) 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(); 21

8 O código a seguir apresenta a classe Contato necessária para criar os objetos do tipo Contato package ifsul.tsiad.exemplosxml; public class Contato { private String nome; private String telefone; private int idade; // 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); 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. 22

9 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 class LeitorXML2 { public ArrayList lerxml(string nomearquivoxml) throws ParserConfigurationException, SAXException, IOException { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newdocumentbuilder(); File f = new File(nomeArquivoXML); Document doc = builder.parse(f); Element raiz = doc.getdocumentelement(); 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++){ Contato contato = (Contato) agenda.get(i); System.out.println(contato); 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. Dica Para entender melhor as classes e interfaces utilizadas, acesse a documentação da API Java: 23

10 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 seguintes 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 transforme o Document em uma DMSource, e seu fluxo de saída em uma StreamResult. O Transformer 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 coleçã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 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 = 24

11 DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newdocumentbuilder(); // 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); 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")); catalogofilmes.add(new Filme("Os Sete Crimes Capitais", "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) { System.out.println("problema ao analisar o arquivo XML"); catch (IOException e) { System.out.println("arquivo não pode ser lido"); 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). 25

12 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. Durante a modificação do documento no programa a seguir, devem-se salientar os seguintes pontos: 26

13 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) 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); Element raiz = doc.getdocumentelement(); NodeList contatos = raiz.getelementsbytagname("contato"); // 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 = TransformerFactory.newInstance(); Transformer transformer = transfactory.newtransformer(); DOMSource source = new DOMSource(doc); StreamResult result = new StreamResult( new FileOutputStream(nomeArquivoXML)); transformer.transform(source, result); 27

14 Dica 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) { System.out.println("problema ao analisar o arquivo XML"); catch (IOException e) { System.out.println("arquivo não pode ser lido"); 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. 28

15 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: Leia e armazene em uma estrutura de dados (como objetos) cinco dados de alunos; 29

16 A classe Aluno deve conter no mínimo três atributos (sendo um deles o valor de uma nota); Imprima a média das notas dos alunos; Armazene os dados dos alunos em documento XML (turma.xml). 30