ESTUDO DA LINGUAGEM XML E SUA INTEGRAÇÃO COM A

Tatianne Domingues de Faria Bini Dias
RA. 0301758 - 8° sem
ESTUDO DA LINGUAGEM XML E SUA INTEGRAÇÃO COM
A PLATAFORMA JAVA
Jaguariúna
2006
Tatianne Domingues de Faria Bini Dias
RA. 0301758 - 8° sem
ESTUDO DA LINGUAGEM XML E SUA INTEGRAÇÃO COM
A PLATAFORMA JAVA
Monografia apresentada à disciplina Trabalho
de Graduação III, do curso de Ciência da
Computação da Faculdade de Jaguariúna, sob
orientação do Prof. Ms. Peter Jandl Júnior,
como exigência parcial para conclusão do curso
de graduação.
Jaguariúna
2006
1
DIAS, Tatianne Domingues de Faria Bini Dias. Estudo da Linguagem
XML e sua integração com a Plataforma Java. 2006. Monografia
(Bacharelado em Ciência da Computação) – Curso de Ciência da
Computação da Faculdade de Jaguariúna, Jaguariúna.
2
Dedico este trabalho a Deus, que foi meu baluarte nas horas difíceis,
tenho certeza que graças a Ele tenho a oportunidade de hoje estar aqui
finalizando este curso.
3
Agradecimentos
Gostaria de agradecer a Deus que me faz acordar a cada
dia e ter forçar para enfrentar o novo amanhã.
Agradeço ao professor, orientador, amigo e coordenador
Peter Jandl Junior, pela atenção e confiança depositada e
aos professores do curso de Ciência da Computação da
FAJ pelo curso proporcionado e tudo que foi somado na
minha vida através do ensino de cada matéria.
Gostaria de agradecer aos meus pais e irmão que sempre
me ajudaram com suas palavras de encorajamento e suas
orações.
Agradeço também meus amigos que estiveram comigo
sempre me dando forças para continuar a caminhada, e
aos meus amigos que me acompanharam esses 4 anos.
4
DIAS, Tatianne Domingues de Faria Bini Dias. Estudo da Linguagem
XML e sua integração com a Plataforma Java. 2006. Monografia
(Bacharelado em Ciência da Computação) – Curso de Ciência da
Computação da Faculdade de Jaguariúna, Jaguariúna.
RESUMO
ESTUDO DA LINGUAGEM XML E SUA INTEGRAÇÃO COM A
PLATAFORMA JAVA
Nesta monografia, será considerada a questão-problema de como
aplicar XML no desenvolvimento de aplicações através da Plataforma
Java, ou seja, um estudo da área de desenvolvimento de sistemas. A
pesquisa foi desenvolvida de forma bibliográfica com enfoque na
linguagem XML, sua estruturação e aplicação como linguagem e
também nas APIs Java destinadas a manipulação de dados do XML.
Analisando as duas tecnologias envolvidas é possível verificar que
o Java que se tornou a linguagem, a plataforma e a arquitetura para
computação na rede, além de ser a linguagem de programação
preferida pelas empresas brasileiras. De outro lado o aparecimento do
XML que é uma tecnologia de ponta, que devido a sua grande
versatilidade, marca uma mudança importante no gerenciamento de
dados e vem se destacando na implementação de sistemas.
Palavras-chave: XML, JAVA, APIS.
5
ABSTRACT
RESEARCH OF THE XML LANGUAGE AND ITS INTERACTION WITH
THE JAVA PLATFORM
In this monograph, will be considered the problem-question how
to apply XML into an application development using JAVA Platform, that
is, an study of the systems development. The research was developed
using a bibliographic form with focus at the XML language, its structure
and application as a language and also at the JAVA APIs designated to
XML data manipulation.
Analyzing both involved technologies, its possible to verify that
Java, witch became the language, the platform and the architecture for
the network computing, besides being the preferred programming
language of the Brazilian enterprises.
In the other hand, the appearance of the XML, witch is a latest
used technology, due to its huge versatility, marks an important change
to the data management and became an outstanding system
implementation.
Keywords: XML, JAVA, APIS.
6
LISTA DE SIGLAS
Java Me: Java 2 Platform Micro Edition
Java Se: Java 2 Platform Standard Edition
Java EE: Java 2 Platform, Enterprise Edition
XML: eXtensible Markup Language
SAX: Simple API for XML
DOM: Document Object Model
API: Application Programming Interface
DTS: Definition Type Scheme
DTD: Definition Type Document
SGM: General Markup Language
7
SUMÁRIO
1.
INTRODUÇÃO............................................................................................................... 9
1.1.
Introdução .............................................................................................................. 9
1.2.
Objetivos ................................................................................................................ 9
1.3.
Motivações ........................................................................................................... 10
1.4.
Estrutura do trabalho ............................................................................................ 10
2. XML ............................................................................................................................. 11
2.1.
DTD e DTS........................................................................................................... 11
2.2.
História do XML.................................................................................................... 12
2.3.
Características do XML ........................................................................................ 12
2.4.
Regras do XML .................................................................................................... 13
2.5.
Benefícios de Utilização do XML .......................................................................... 14
3. DEFINIÇÕES E NOTAÇÕES BÁSICAS DO XML ........................................................ 16
3.1.
Tags de Inicio e de Fim ........................................................................................ 16
3.2.
Atributos nas Tags ............................................................................................... 16
3.3.
Sensibilidade ao caixa.......................................................................................... 17
3.4.
Aninhamento ........................................................................................................ 17
3.5.
Comentários em XML........................................................................................... 17
3.6.
Características de documentos bem estruturados................................................ 18
4. SINTAXE E BLOCOS DE CONSTRUÇÃO DTD .......................................................... 19
4.1.
Bloco de Construção DTD .................................................................................... 20
4.2.
Seções CDATA .................................................................................................... 21
4.3.
Declaração de elementos..................................................................................... 21
5. APIS JAVA PARA XML ................................................................................................ 22
5.1.
API DOM .............................................................................................................. 23
5.1.1 Classes DOM ...................................................................................................... 24
5.1.2 Descrição das Classes DOM............................................................................... 25
5.1.3 Exemplo de utilização DOM ................................................................................ 26
5.1.4 Utilização do DOM em Java ................................................................................ 26
5.1.5 Localizando Nodos Filhos ................................................................................... 28
5.1.6 Navegando entre irmãos ..................................................................................... 28
5.1.7 Acessando Atributos por nome............................................................................ 29
5.1.8 Modificando um DOM.......................................................................................... 29
5.2.
API SAX ............................................................................................................... 30
5.2.1 Interface Sax ....................................................................................................... 30
5.2.2 Eventos disparados pelo parser SAX .................................................................. 31
5.2.3 Exemplo de SAX ................................................................................................. 32
5.2.4 Utilização do SAX em Java ................................................................................. 32
5.2.5 Localizando Parse Errors .................................................................................... 34
6. CONSTRUÇÃO DO PROTÓTIPO ............................................................................... 35
6.1.
Caso de Uso ........................................................................................................ 37
6.2.
Desenvolvimento.................................................................................................. 37
6.3.
As APIS no protótipo ............................................................................................ 39
6.4.
Os testes do protótipo .......................................................................................... 40
6.5.
Ambiente de Desenvolvimento ............................................................................. 40
7. CONCLUSÕES............................................................................................................ 41
7.1.
Conclusão ............................................................................................................ 41
7.2.
Melhoramentos..................................................................................................... 41
8. REFERÊNCIAS BIBLIOGRÁFICAS ............................................................................. 42
8
1. INTRODUÇÃO
1.1. Introdução
Neste trabalho de graduação, será considerada a questão-problema de como aplicar
XML(eXtensible Markup Language) no desenvolvimento de aplicações através da
Plataforma Java.
O Java é uma verdadeira plataforma, com soluções para dispositivos pequenos e
portáteis dados pelo Java ME (Java 2 Platform Micro Edition) e Java Card, aplicações
desktop Java SE (Java 2 Platform Standard Edition) e para desenvolvimento de software
empresarial J2EE (Java 2 Platform, Enterprise Edition) (JANDL, 2002). Como disse Scott
McNealy, "O Java tornou-se a linguagem, a plataforma e a arquitetura para computação na
rede” (SUN, 2005 A). No futuro bem próximo o mundo todo estará hiperconectado em rede e
somente uma tecnologia foi criada desde o começo para lidar com as necessidades da
computação de maneira segura e independente do dispositivo utilizado - o Java (SUN, 2005
C).
Java é a linguagem de programação preferida pelas empresas brasileiras, segundo
revela a pesquisa “Desenvolvimento de Sistemas das Grandes Corporações”, realizada pelo
Grupo Impacta Tecnologia junto às duas mil maiores companhias do Brasil de diversos
segmentos (IMPACTA, 2005).
De outro lado o aparecimento do XML marca uma mudança importante no
gerenciamento de dados. Baseadas nas redes de computadores globais, as estruturas de
dados simples do passado estão dando lugar a estruturas complexas, definidas por
esquemas. O XML é uma tecnologia de ponta, que devido a sua grande versatilidade vem
se destacando na implementação de sistemas (FARIA, 2005).
Essa pesquisa se torna viável, devido ao grande interesse em estudar Java, pois é
uma tecnologia promissora para o desenvolvimento de software e é essencial para o
ingresso no mercado de trabalho atual, além de disso o Java se torna um bom caminho para
o aprendizado de orientação a objeto.
1.2. Objetivos
Os objetivos deste trabalho foram estudar a linguagem XML, sua estruturação e
aplicação como linguagem neutra, portátil, extensível e dinâmica. Estudar as APIs
(Application Programming Interface) Java, DOM (Document Object Model) e SAX (Simple
API for XML), destinada a manipulação do XML e aplica-lás através da construção de um
protótipo envolvendo as duas tecnologias (Java e XML).
9
1.3. Motivações
Os interesses desse projeto foram acadêmicos, sendo que o principal foi estudar o
XML, uma tecnologia de ponta que vem se destacando na implementação de sistemas.
Outro interesse foi estudar a linguagem Java que segundo pesquisas é a tecnologia
preferida das empresas, além disso, o Java se torna um bom caminho para o aprendizado
de orientação a objeto.
1.4. Estrutura do trabalho
1º Capítulo – Introdução
É apresentado o objetivo, motivações e descreve as várias etapas da realização do projeto.
2º Capítulo – XML
Descreve o que é o XML, sua história, características, regras e benefícios de se utilizar a
linguagem XML.
3° Capítulo – Definições de notações básicas do XML
Define a estruturação formatação de um documento XML.
4° Capítulo – Sintaxe e bloco de construção DTD
Relata as regras de sintaxe do XML e o conjunto de regras estabelecidas por um DTD
(Document Type Definition).
5° Capítulo – APIS Java para XML
Descrição das APIs DOM e SAX e como utilizá-las na manipulação de dados em XML.
6º Capítulo – Construção do Protótipo
É feita uma descrição do algoritmo e do seu modo de funcionamento, bem como uma
exemplificação da sua utilização.
7° Capítulo – Conclusões
Neste capítulo são feitas a considerações finais sobre o projeto e ainda referenciados
possíveis melhoramentos a aplicação.
10
2. XML
O XML (eXtensible Markup Language) é uma linguagem de marcação que armazena
todo o tipo de dado, utilizando caracteres UNICODE1, que armazena qualquer tipo de
caracter ou símbolo. Essa capacidade de armazenar vários tipos de dados é chamada de
“Self-describe data” ou dados autodescritivos, que faz a representação de informações em
qualquer idioma (LIGHT, 1999).
O XML é um formato de texto simples, muito flexível derivado do SGML (Standard
General Markup Language) ISO 8879, é um padrão de formatação de dados de forma que
os dados fiquem organizados.
Todas as informações contidas no XML estão dentro de tags, que são marcações de
inicio e fim onde estão os elementos, as tags são demarcadas pelos símbolos < e > e na
final por uma barra \.
Através do XML podemos criar outras linguagens para especificar cada um dos usos
de XML, são as sublinguagens. Sublinguagens são linguagens que servem para definir
outras linguagens, ou seja, são metalinguagens.
Existem duas metalinguagens obtidas apartir do XML,
o DTD (Definition Type
Document) e o DTS (Definition Type Scheme) (FARIA, 2005).
2.1. DTD e DTS
O DTS e o DTD são regras do XML que ajudam a validar os dados quando a aplicação
que os recebe não possui internamente uma descrição do dado que está recebendo
(WIKIPEDIA, 2006).
O DTS, Definition Type Scheme estabelece um conjunto de regras que definem a
composição do documento a partir de uma gramática formal. Sua estrutura é a de base
hierárquica e granular, detalhando quais elementos podem ser usados e onde eles podem
ser aplicados.
O DTD, Definition Type Document, também estabelece o tipo de relacionamento que
um elemento possui com outros, indicando todas as partes, obrigatórias e opcionais, que o
documento XML deve seguir ao ser criado (CRIAR WEB, 2006).
1
Unicode é um esquema de codificação de caracteres com 16 bits, incluindo não apenas os alfabetos
gregos e romanos, mas também símbolos matemáticos, pontuação especial e conjuntos de
caracteres não romanos
11
2.2. História do XML
O XML provém de uma linguagem que a IBM criou por volta dos anos 70. Essa
linguagem chama-se GML (General Markup Language) e surgiu pela necessidade que a
IBM possuía de armazenar grandes quantidades de informação diversificadas.
O GML chamou a atenção da ISO (International Organization for Standardization) que
por volta do ano 1986 começou a trabalhar para normalizar a linguagem e criou a SGML,
que não era mais que o GML, porém, padrão (Standard em inglês). SGML é uma linguagem
muito rica, capaz de adaptar-se a grandes variedades de problemas (W3C, 2006).
Estimulado pela insatisfação com os formatos existentes (padronizados ou não), um
grupo de empresas e organizações que se autodenominou World Wide Web Consortium2
(W3C) começou a trabalhar em meados da década de 1990 em uma linguagem de
marcação que combinasse a flexibilidade da SGML com a simplicidade da HTML (Hyper
Text Markup Language). O princípio do projeto era criar uma linguagem que pudesse ser
lida por software, e integrar-se com as demais linguagens.
O mesmo W3C em 98 começou e continua até hoje o desenvolvimento do XML.
2.3. Características do XML
O XML se concentra na estrutura da informação e não em sua aparência, essa é a
principal característica o conteúdo separado, criou-se as seguintes características (PITTSMOULTIS, 2000): extensível, interpolar, universal, simples, transportável, flexível, portabil.
Extensível: Utilizado em todos dos campos do conhecimento. O programador cria
livremente as tags da forma que lhe pareça mais útil. Existe uma grande liberdade na
escolha da estrutura dos dados, o que facilita a troca dos mesmos. O Exemplo 1 mostra as
diversas formas de representar uma data.
date> 5 janeiro 2000 </date>
<date>
<ano> 2000 </ano>
<mes> 01 </mes>
<dia> 05 </dia>
</date>
<date format='ISO-8601'> 2000-01-05 </date>
Exemplo 1: Formas variadas de representar datas.
2
World Wide Web Consortium (W3C), foi criado em 1994 para levar a Web para o seu potencial máximo,
através do desenvolvimento de protocolos comuns e fóruns abertos que promovem sua evolução e asseguram a
sua interoperabilidade. O W3C desenvolve tecnologias, denominadas Web Standards (ou Padrões Web) para a
criação e a interpretação dos conteúdos para Web
12
Interpolaridade: Os dados são vistos como documentos XML e não como arquivos
em formatos específicos. Um simples editor de texto pode tratar de todos os dados de uma
determinada organização. A interpolaridade assegura que o documento será formal e
preciso do ponto de vista dos dados até a maneira como salvá-los. Com XML é possível
padronizar os dados, de forma que eles possam ser recuperados das mais diferentes fontes
sem que haja grandes problemas.
Universal: Os dados são idênticos tanto para enviar, receber e processar as
informações.
Simples: Os dados são escritos de maneira que seja fácil de ler e editar.
Transportável: É possível implantar, programar e aplicar aos distintos sistemas.
Flexível: É possível representar qualquer tipo de informação.
Portabilidade: projetado para ser usado com qualquer linguagem de programação e
em qualquer sistema operacional.
De acordo com esses objetivos criou-se uma linguagem neutra, portátil, extensível e
dinâmica que:
•
Separa conteúdo de formatação;
•
É legível tanto para humanos quanto para máquinas;
•
Possibilita a criação de tags sem limitações;
•
Faz comunicação entre distintos bancos de dados;
•
É simples;
Com XML, automaticamente os dados estão disponíveis para mais pessoas por uma
simples razão: XML é independente de hardware, software e aplicação.
2.4. Regras do XML
A padronização de formatos é a principal regra no XML. Uma outra regra está ligada
aos erros que podem acontrecer na hora da execução. O XML interrompe o processo se
encontra um erro de marcação, ele exibirá uma mensagem de erro. Esse modo rigoroso de
trar erros é conhecido como tratamento de erros draconianos.
As regras podem variar quanto a sua classificação: Regras específicas DTS e Sem
DTS.
Quando o documento contiver validação o processador fará a verificação de acordo
com as regras específicas DTS, se o documento não tiver validação o processdor fará a
verificação apenas com as regras do XML. A seguir algumas regras XML:
1. Um documento XML deve conter um ou mais elementos.
2. O nome de um elemento deve ser igual na marcação (tag) inicial e na final.
3. O XML é case-sensitive , há diferença entre letras maiúsculas e letras minúsculas.
13
4. O único elemento que não pode fazer parte do conteúdo de nenhum outro elemento
é o elemento raiz.
5. Os elementos que estão dentro da tag inicial e final devem estar alinhados. Se a
marcação inicial está dentro de um elemento a final deve estar também dentro do
mesmo elemento.
6. O nome dos elementos pode conter letras, dígitos, hífens ou underscores.
7. Os nomes dos elementos que começam com xml, XML ou outra combinação dessa
string são reservados por padrão.
8. O elemento pode conter vários atributos ou nenhum.
9. Os caracteres permitidos são os mesmos dos nomes de elementos.
10. O nome do atributo é seu valor são separados por um sinal de igual(“=”).
11. O valor dado ao atributo deve estar entre apóstrofes '...' ou aspas duplas "..." .
12. Caracteres “<” e “&” não podem ser usados no texto como são usados nas
marcações. Se esses caracteres são necessários utiliza-se “&lt;” ao invés de “<” e
“&amp;” ao invés de “&”.
13. É possível colocar comentários em qualquer lugar do documento fora de uma
marcação.
14. Seções CDATA são usadas para preservar blocos de texto com caracteres que
seriam interpretados como marcação. As seções CDATA começam com a string
"<![CDATA[" e terminam com a string "]]>". A seqüência ']]>' não pode ocorrer
dentro da seção CDATA.
15. Os documentos XML podem começar com uma declaração XML para especificar a
versão do XML que está sendo usada e o conjunto de caracteres que serão
utilizados.
2.5. Benefícios de Utilização do XML
O objetivo de utilizar XML é trazer flexibilidade. Dentre os benefícios para
desenvolvedores e usuários temos: buscas mais eficientes, integração de dados de fontes
diferentes, computação e manipulação local, múltiplas formas de visualizar os dados,
atualizações granulares dos documentos, escalabilidade, fácil compreensão.
O XML pode ser usado por uma infinidade de trabalhos e aponta amplas vantagens,
como (CRIAR, 2006): Comunicação de dados, migração de dados, busca mais eficiente,
computação e manipulação local, múltiplas formas de visualizar os dados, atualização
granular dos documentos, escalabilidade e fácil compreensão.
Comunicação de dados: Se a informação se transfere em XML, qualquer aplicação
pode escrever um documento de texto plano com os dados que está manejando no formato
XML e outra aplicação pode receber esta informação e trabalhar com ela. Um
14
desenvolvedor corrige com mais facilmente as aplicações, de forma que um simples editor
de textos pode ser usado para corrigir um erro em um arquivo XML.
Migração de Dados: Se for preciso mover os dados de uma base de dados à outra
seria muito simples se as duas trabalhassem em formato XML.
Então um banco de dados pode, através de uma aplicação escrever em um arquivo
XML e um outro banco distinto pode ler estes mesmos dados.
Buscas mais eficientes: Os dados em XML podem ser unicamente "etiquetados", o
que permite que, por exemplo, uma busca por livros seja feita em função do nome do autor.
Sem o XML é necessário para a aplicação de procura saber como é esquematizado e
construído cada banco de dados que armazena os dados de interesse, o que é impossível.
O XML permitiria definir livros por autor, título, assunto, etc., o que facilitaria enormemente a
busca.
Computação e manipulação local: Os dados XML recebidos por um cliente são
analisados e podem ser editados e manipulados de acordo com o interesse do usuário. Ao
contrário de somente visualizar os dados, os usuários podem manipulá-los de várias formas.
Os recursos disponíveis do Document Object Model (DOM) permitem que os dados sejam
manipulados via scripts ou outra linguagem de programação. A separação da interface visual
dos dados propriamente ditos permite a criação de aplicações mais poderosas, simples e
flexíveis.
Múltiplas formas de visualizar os dados: Os dados recebidos por um usuário podem
ser visualizados de diferentes formas uma vez que o XML define somente os dados e não o
visual. A interpretação visual poderia ser dada de várias maneiras diferentes, de acordo com
as aplicações.
Atualizações granulares dos documentos: Os dados podem ser atualizados de
forma granular evitando que uma pequena modificação no conjunto de dados implique na
busca do documento inteiro novamente.
Escalabilidade: Devido ao fato dos documentos XML separarem completamente os
dados da forma com a qual são visualizados, autores de aplicações de visualização de
dados podem torná-las muito poderosas e interativas, permitindo ao usuário visualizar os
dados da forma que lhe agrade.
Fácil Compressão: A compressão de documentos XML é fácil devido à natureza
repetitiva das tags usadas para definir a estrutura dos dados.
15
3. DEFINIÇÕES E NOTAÇÕES BÁSICAS DO XML
Um documento XML é um texto (em formato Unicode) com tags de marcação (markup
tags) e outras informações.
O documento XML é considerado bem formatado quando segue algumas regras
básicas. Tais regras são mais simples do que nos documentos HTML e permitem que os
dados sejam lidos e expostos sem nenhuma descrição externa ou conhecimento do sentido
dos dados XML.
3.1. Tags de Inicio e de Fim
Os elementos são formados por duas tags, uma indicando o inicio e a outra o fim.
As tags de inicio e fim, devem ter o mesmo nome. Toda tag de início é identificada
pelo caracter “<” seguido do nome e do caracter “>”. A tag de fim é diferenciada pelo
caracter “/” que será colocado após “>“ (FARIA, 2005).
<aluno> -tag de inicio
</aluno> - tag de finalização
Toda tag deve ser fechada na ordem correta que ela foi aberta.
3.2. Atributos nas Tags
Pode-se colocar atributos dentro da tag inicial. O valor do atributo deve ser
especificado entre aspas simples ou duplas (FARIA, 2005).
<aluno status="matriculado">
Tatianne Dias
</aluno>
Exemplo 2: Atributos dentro das Tags.
No Exemplo 2 o status é o nome do atributo e matriculado é o seu valor.
Antes de se especificar atributos nas tags é preciso observar algumas regras:
•
Atributos não podem conter elementos filhos;
•
Atributos não são expansíveis (para o caso de futuras mudanças);
•
Atributos são mais difíceis de manipular;
•
Atributos são difíceis de serem validados quando se usa DTD.
Os valores dos atributos podem conter espaços, começar com caractere numérico e
conter qualquer caractere de pontuação.
Em resumo, pode-se dizer que elementos devem ser usados para descreverem dados
e atributos são usados para representar informações secundárias.
16
3.3. Sensibilidade ao caixa
Os documentos XML são case-sensitive, ou seja, letras maiúsculas e minúsculas são
diferentes nas tags de XML, dessa forma a tag a seguir está correta, enquanto que a
segunda está incorreta. (FARIA, 2005). No Exemplo 3 a primeira linha está correta, já a
segunda contém um erro na tag de fim, pois o ‘S’ está maiúsculo diferente da tag inicial.
<assunto>XML</assunto>
<assunto>XML</AsSunTo>
Exemplo 3: Sensibilidade ao caixa.
3.4. Aninhamento
Deve-se ter muito cuidado com esta questão de aninhar elementos. É muito comum
em um documento extenso haver algumas tags desaninhadas; em HTML isso não causa
sérios problemas. Porém em XML o desaninhamento é proibido.
O documento não pode conter tags desaninhadas porque se no código existir erro
será muito difícil encontrá-lo.
<b><i>Este é um texto em negrito e itálico</b></i>
<b><i>Este é um texto em negrito e itálico</i></b>
Exemplo 4: desaninhamento e aninhamento das tags.
O primeiro fragmento de código no Exemplo 4 não funciona em XML, pois era preciso
ser fechado primeiro o <i> por que ele foi aberto por ultimo. O segundo fragmento funciona
corretamente, já que as tags estão aninhadas corretamente.
3.5. Comentários em XML
Os comentários escritos em XML são interpretados apenas pelo analisador do
documento e são ignorados por todos os processadores.
<!—comentário, posso escrever qualquer coisa -->
Exemplo 5: Comentário em XML.
Todos os dados entre essa marcação são ignorados pelo processador XML.
O comentário não pode estar antes da instrução de processamento (declaração XML)
que deve ser a primeira sentença de um documento, nem dentro de um elemento.
A seqüência -- não pode aparecer em um comentário, exceto como parte dos
delimitadores (Exemplo 5).
17
3.6. Características de documentos bem estruturados
Documentos XML bem estruturados apresentam as seguintes características:
•
Possuem casamentos das tags de início e de fim;
•
Possuem tags de elemento apropriadamente posicionadas;
•
Possui tags aninhadas para corrigir os erros com maior facilidade;
•
Possuem um elemento raiz;
•
Não possuem elementos sobrepostos.
Quando algumas das características acima não são atendidas pode ocorrer
sobreposição dos elementos. O Exemplo 6 é um exemplo de sobreposição.
<titulo>Descrição dos diversos modelos de carros
<sub>da marca Ford
</titulo>Alexandre Manso
</sub>
Exemplo 6: Fragmento de um documento mal estruturado.
E o Exemplo 7 mostra o erro corrigido.
<titulo>Descrição dos diversos modelos de carros
<sub>da marca Ford</sub>
<autor> Alexandre Manso</autor>
</titulo>
Exemplo 7: Fragmento de um documento bem estruturado.
18
4. SINTAXE E BLOCOS DE CONSTRUÇÃO DTD
As regras de sintaxe de XML são muito simples de serem entendidas. Documentos
XML usam uma sintaxe autodescritiva. Dentro de uma estrutura XML os DTDs (Document
Type Definition) são opcionais porém são conhecidos e válidos.
O DTD estabelece um conjunto de regras que definem uma gramática formal do
documento. Sua estrutura detalha quais elementos podem ser usados e onde podem ser
aplicados. O DTD indica todas as partes, obrigatórias e opcionais, que o documento XML
deve seguir ao ser criado (FARIA, 2005). É preciso abordar a diferença entre um documento
“bem formatado” e um documento “válido”.
Um documento XML “bem formado” é um documento que cumpre as regras de
sintaxe. Basicamente, as regras são as seguintes:
•
Contém um elemento raiz;
•
Todos os outros elementos são filhos do elemento raiz;
•
Todos os elementos têm um par correspondente;
•
Os nomes dos elementos em tags de início e de fim são os mesmos;
•
Nomes de atributos somente são usados dentro do mesmo elemento.
Um documento XML é considerado “válido” quando é “bem formado” e segui as regras
definidas em um DTD.
Pode-se dizer que a finalidade de um arquivo DTD é definir os possíveis elementos
para a construção de um documento XML. Basicamente, ele define a estrutura do
documento com uma lista de elementos disponíveis para uso. Um DTD pode ser declarado
no mesmo arquivo do documento XML ou fazendo uma referência a um arquivo externo.
Mas, se o que um DTD faz é definir os elementos que poderão ser utilizados no
documento XML, por que então simplesmente não construir o documento XML sem um
DTD? A explicação é que XML provê uma forma independente das aplicações
compartilharem dados.
Com DTD, desenvolvedores de diversos locais podem concordar em usar um DTD
único para a troca de dados. Assim, uma aplicação pode usar o DTD para verificar se os
dados recebidos de uma outra aplicação são realmente válidos, ou seja, são válidos para o
DTD pré-definido entre as partes.
A Figura 1 mostra o esquema de um documento XML com regras DTD. O DTD é uma
metalinguagem do XML e a partir dos DTDs de softwares, disciplina e laboratório é formado
o documento professor.xml, ele só é gerado porque os foram atendidas todas as regras do
DTD.
19
Figura 1 - Esquema de um documento nas Regras DTD.
4.1. Bloco de Construção DTD
A finalidade de um arquivo DTD é definir os possíveis elementos para a construção de
um documento XML. Basicamente, ele define a estrutura do documento com uma lista de
elementos disponíveis para uso. Um DTD pode ser declarado no mesmo arquivo do
documento XML ou fazendo uma referência a um arquivo externo.
Tabela 1 - Blocos de Construção do XML.
Blocos
Descrição
Elementos
Bloco de construção utilizado no XML, pode se referir a qualquer
tag criada.
Tags
Elementos de marcação que possuem abertura e encerramento
Atributos
Fornecem informações exatas sobre os elementos, sendo inseridos
em suas tags iniciais. Possuem um nome e um conteúdo.
Entidades
Variáveis designadas para conter textos ou documentos
Notação
Armazena textos que será interpretado pelo analisador do
documento
PCDATA
Significa “parsed character data”. Sobre “data character”, ou “dados
de caracteres”, entende-se que é o texto que está entre a tag de
início e a tag de fim em um elemento XML. PCDATA é o texto que
será analisado pelo parser.
CDATA
Também significa “character data”, entretanto CDATA representa o
texto que NÃO será analisado pelo parser
20
O DTD deve reconhecer os blocos de construção dados na Tabela 1.
4.2. Seções CDATA
Normalmente o texto que aparece entre os delimitadores < e> são considerados
marcações. Exceção é feita aos textos entre delimitadores de seções CDATA, que são
considerados caracteres de dado.
Os delimitadores de abertura e fechamento da seção são, respectivamente,
<![CDATA[ e ]]>
A única seqüência de caracteres que não pode aparecer em uma seção CDATA é ]]>
As seções CDATA são úteis quando se deseja que todos os caracteres de um texto
sejam interpretados como caracteres e não como elementos de marcação. Exemplos são
textos contendo os caracteres <, >, &, etc., comuns em trechos de código de programas. O
Exemplo 8 mostra alguns caracteres no código.
<![ CDATA[ Em XML a entidade &lt; eh built- in ]]>
Exemplo 8: Documento processado com CDATA.
No exemplo 8 podemos visualizar um fragmento com CDATA, o resultado depois que
o documento for processado será: "Em XML a entidade &lt; eh built- in".
4.3. Declaração de elementos
Em um DTD a declaração de um elemento é feita da forma seguinte:
<!ELEMENT nome-elemento (conteudo-elemento)>
Existem derivações dessa forma de declaração de elementos, respeitando a sintaxe.
Algumas formas são mostradas na Tabela 2.
Tabela 2 - Declaração de Elementos em DTD.
Descrição
Sintaxe
<!ELEMENT nome-elemento
Elementos vazios
(EMPTY)>
Elementos com
Dados
<!ELEMENT nome-elemento
(#CDATA)> ou
<!ELEMENT nome-elemento
(#PCDATA)> ou
<!ELEMENT nome-elemento
(ANY)>
Elementos com
filhos
<!ELEMENT nome-elemento
(nome-elemento-filho)> ou
<!ELEMENT nome-elemento
(nome-elemento-filho,nomeelemento-filho,.....)>
21
Exemplo
<!ELEMENT img (EMPTY)>
<!ELEMENT nota (#PCDATA)>
<!ELEMENT mensagem
(para,de,assunto,corpo)>
5. APIS JAVA PARA XML
XML é um formato de texto simples, uma linguagem onde os dados são gravados em
documentos. Para realizar ações com dados escritos em XML temos alguns mecanismos
específicos. O W3C especificou dois mecanismos para acessar a documentos XML e
trabalhar com eles. Esses mecanismos são normas que foram criadas para mostrar ao
desenvolvedor como acessar os documentos. Estas normas incluem uma hierarquia de
objetos que têm alguns métodos e atributos para podermos acessar as partes do documento
(W3C, 2006).
Estes dois mecanismos denominam-se SAX (Simple API for XML) e DOM (Document
Object Model). SAX é utilizado para fazer um percurso seqüencial dos elementos do
documento e DOM implica a criação de um organograma na memória que contem o
documento XML, e com ele na memória pode-se fazer qualquer tipo de percurso e ações
com os elementos (PITTS-MOULTIS, 2000).
Um exemplo simples para ilustrar esta situação é de uma aplicação que tem como
objetivo buscar os dados de determinado livro em um documento XML. Como o acesso é
feito serialmente, assim que o livro desejado é encontrado, o processamento pára (o SAX
permite isso) e o dado é retornado para o usuário. Podemos utilizar o SAX também para
aplicações onde não é necessário retornar o documento inteiro, mas sim parte dele. Caso
uma aplicação precise retornar os livros de determinado autor, o SAX percorre o documento
e retorna apenas os livros solicitados. Neste exemplo, a construção de uma árvore é
desnecessária, logo a utilização do DOM se torna inviável.
A linguagem de programação usada para acessar a um documento XML é de escolha
do programador, desde que essa possua umas APIs que cumpram as especificações de
XML.
Uma linguagem típica para trabalhar com o XML é o Java. A SUN se encarregou de
prover a API que o W3C especificou (SUN, 2006 D).
A Figura 2 mostra as principais diferenças entre DOM e SAX.
22
Figura 2 - Esquema DOM x SAX.
Nas seções 5.1 e 5.2 será possível identificar o funcionamento dos parsers SAX e
DOM. A principal diferença é que em DOM o arquivo XML é alocado na memória e as
informações são passadas para a aplicação que devolve um parser ao arquivo XML. Já no
SAX as informações são passadas a aplicação através de eventos (event handlers) que está
dentro da aplicação, essa por sua vez devolve o parser ao XML.
5.1. API DOM
O W3C definiu o DOM como o formato padrão para manipulação de documentos XML
(W3C, 2006).
O principio básico é que um documento XML é transformado em um DOM constituído
de objetos que implementam interfaces. Cada parte do documento é transformado em um
objeto, e as conexões entre os objetos refletem a hierarquia do documento.
No modelo DOM o documento XML inteiro é armazenado na memória num formato de
arvore de nodos, todos descendentes de uma raiz.
Para cada procura ou manipulação realizada no documento DOM, é preciso começar
pelo elemento raiz e ir subindo na hierarquia. Como todas as informações estão disponíveis
na memória, é possível combinar informações (PITTS-MOULTIS, 2000).
Na Figura 3 observa-se a estrutura do modelo conceitual de DOM.
23
Figura 3 - Modelo Conceitual DOM (PITTS-MOULTIS, 2000).
5.1.1 Classes DOM
Praticamente todas as classes do DOM herdam da classe Node. Esta classe, por sua
vez, possui dois atributos, denominados name e value, que serão herdados por todas as
outras classes. Além destes atributos, há um outro denominado childrenNode, que
representa um auto-relacionamento da classe Node. Logo, as outras classes também
herdarão este atributo. Desta forma, a navegação entre as classes do DOM é realizada
através do atributo childrenNode.
A interface Node é implementada por todas as diferentes subcategorias ilustradas na
Figura 2. Esta forma de representação é muito interessante para as linguagens como Java,
que são orientadas a objetos. Todos os tipos de Node possuem uma interface
correspondente em Java (SUN, 2005 B). Através da figura 4 é possível observar os subtipos
de nodes que encontramos no DOM.
24
Figura 4 - Subtipos de Node em DOM (PITTS-MOULTIS, 2000).
5.1.2 Descrição das Classes DOM
Tabela 3 - Resumo das Classes da API DOM
Classe
Descrição
Attr
Representa um atributo de um determinado elemento
CdataSection
Representa uma seção XML Cdata
CharacterData
Representa uma string genérica no DOM
Comment
Representa um comentário XML
Document
Representa um documento XML, o elemento raiz.
DocumentFragment
DocumentType
Representa uma árvore de nós que geralmente não é uma
árvore completa.
Representa o DTD na árvore do documento
Element
Representa a maioria dos objetos na árvore.
Entity
Representa uma entidade XML
EntityReference
Representa uma referência à uma entidade ainda não
expandida.
NamedNodeMap
Node
Contém uma coleção de nós que podem ser acessados pelo
nome
É a classe pai de todos os nós da árvore DOM
NodeContainer
Adiciona a capacidade de ter nós filhos
Notation
Representa uma notação XML
ProcessingInstruction
Representa o processamento de uma instrução que define o
comportamento do parser.
Representa o dado textual do documento, coleção de
caracteres de attr ou element.
Text
25
Na Tabela 3 a descrição resumida das classes da API DOM. Cada classe representa
uma função dentro do XML.
5.1.3 Exemplo de utilização DOM
No Exemplo 9 será utilizado o parser XML da Sun: o JAXP API parser toolkit, que
substitui diversos toolkits diferentes. A Sun buscou neste novo API flexibilidade, utilizandose apenas dois arquivos JAR – jaxp.jar e parser.jar - que devem ser colocados no diretório
de extensões padrão. Estes pacotes devem ser incluídos (PITTS-MOULTIS, 2000).
import java.io.*;
import java.util.*;
import javax.XML.parsers.*;
import org.XML.sax.*;
import org.w3c.dom.*;
Exemplo 9: Utilização do DOM.
Pelo fato do parser fazer todo o trabalho, tudo que se deve fazer é usar um
DocumentBuilderFactory para criar um DocumentBuilder e especificar o arquivo de
entrada. No Exemplo 10 é possível visualizar o procedimento para se criar um
DocumentBuilder.
File XMLFile = new File( src ); //onde src é uma string
DocumentBuilderFactory dbf = new DocumentBuilderFactory.newInstance();
DocumentBuider db = dbf.newDocumentBuilder();
Document doc = db.parse(XMLFile);
Exemplo 10: Criando um DocumentBuilder.
O Document é uma referência para um objeto que implementa a interface Document
definida no pacote org.w3c.dom (W3C, 2006). A classe específica é fornecida pelo
DocumentBuilder; mas não é preciso se preocupar com os detalhes internos porque a
interface Document fornece todos os métodos necessários.
5.1.4 Utilização do DOM em Java
O processo de utilização do DOM em Java consistem basicamente em três (3) etapas:
1º Criar o DocumentBuilderFactory. Este objeto criará o DocumentBuilder.
2º Criar o DocumentBuilder. O DocumentBuilder fará o parsing para criar o objeto
Document.
3º Fazer o parsing do arquivo para criar o objeto Document.
26
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;
import org.w3c.dom.Document;
public class OrderProcessor {
public static void main (String args[]) {
File docFile = new File("orders.xml");
Document doc = null;
try {
DocumentBuilderFactory dbf =
DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
doc = db.parse(docFile);
} catch (Exception e) {
System.out.print(“Erro ao analisar o arquivo.");
}
}
}
Exemplo 11: Utilização do XML em Java.
Os Exemplos 11 e 12 mostram como é utilizado o XML em Java.
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
public class OrderProcessor {
...
System.exit(1);
}
//Recupera o elemento raiz (root)
Element root = doc.getDocumentElement();
System.out.println(“O elemento raiz é " + root.getNodeName());
}
}
Exemplo 12: Consulta do elemento raiz.
27
5.1.5 Localizando Nodos Filhos
O texto de um Element pode ser armazenado no DOM em mais de um Node filho. No
Exemplo 13, uma seção CDATA é utilizada para que marcação HTML seja incorporada:
<Qtext>
<![CDATA[Please fill in <b>all</b> Fields
]]>
</Qtext>
Exemplo 13: Utilizando CDATA.
5.1.6 Navegando entre irmãos
Figura 5 -Navegação entre Nodes em DOM.
Um objeto Element também conhece seus relacionamentos próximos no DOM. É
possível localizar elementos anteriores e próximos no mesmo nível de hierarquia com o
método descrito no Exemplo 14.
Element prev = aE.getPreviousSibling();
Element next = aE.getNextSibling();
Exemplo 14: Método para navegação em documento DOM
Estes métodos retornam null quando depois de executados não acharem irmãos
naquele ponto.
28
5.1.7 Acessando Atributos por nome
Atributos pertencentes a um Element podem ser acessados por nome para recuperar
o seu valor, como em: String isbnStr = bookE.getAttribute(“isbn”);
A String retornada será vazia caso não exista atributo com aquele nome. Este método
funciona bem em XML quando os valores de atributos são apenas texto. Caso seu XML
tenha referências de entidades nos atributos, como a seguir, onde Attr é uma extensão da
interface Node: Attr isbnStr = bookE.getAttribute(“isbn”);
É possível recuperar todos os atributos relacionados com um elemento com um
NamedNodeMap, como a seguir: NamedNodeMap map = bookE.getAttributes();
O conteúdo de um determinado atributo pode ser acessado pelo nome:
Node nd = map.getNamedItem(“isbn”);
Note que será retornado um Node do tipo Attr, ou null caso o atributo não exista.
Para realmente recuperar o conteúdo do atributo faça o seguinte:
String value = nd.getNodeValue();
5.1.8 Modificando um DOM
Quando o Document está na memória, é possível modifica-lo através de diversas
maneiras. O Exemplo 15 mostra como adicionar um atributo printing no tag Edition de um
determinado livro.
NodeList editNL = bookE.getElementsByTagName(“Edition”);
Element edition = (Element) editNL.item( 0 );
Edition.setAttribute(“printing”, “3”);
Exemplo 15: Método Edition para modifica documento DOM.
A interface Document especifica métodos para criar objetos Node de todos os tipos.
Se for preciso adicionar um novo livro ao Document é possível também (exemplo 16).
Element addBook = doc.createElement(“Book”);
doc.appendChild( addBook );
Exemplo 16: Método criar objeto Node.
Title, Author e outros elementos podem ser criados e adicionados como filhos do
objeto addBook. Existe também um método de inserir um Node filho antes de um
determinado Node. Para extrair porções de um Document ou reagrupar partes de um
documento, DOM fornece a interface DocumentFragment.
29
5.2. API SAX
O padrão SAX (Simple API for XML) cresceu por que o método DOM era muito
complexo e inadequado para várias aplicações. O problema era que até então, cada parser
XML para Java tinha seu próprio padrão de interface. Com intenção de solucionar este
problema programadores produziram os primeiros rascunhos do SAX – num curto espaço
de tempo.
O padrão SAX é hoje aceito largamente e forma a base dos parsers do modelo DOM
bem como parsers que simplesmente provem uma interface SAX. O pacote que contém
todas essas interfaces é o org.XML.sax (ORG SAX, 2006).
Na Figura 6 podemos ver a estruturação do SAX, onde temos um XML que tem uma
DTD opcional, o SAX cria um parser handler e é através desse método que o arquivo será
acessado pelo programa.
Figura 6 - Modelo Conceitual SAX (PITTS-MOULTIS, 2000)
5.2.1 Interface Sax
É preciso criar um parser SAX para ler uma determinada fonte e registrar objetos
implementando as várias interfaces com o parser.
30
Quando o parser é executado, os objetos registrados são notificados quando os
eventos disparados pelo parser ocorrem.
Na Tabela 4 é possível visualizar alguns eventos que definem a interface Sax:
Tabela 4- Tabela de Interface SAX.
Parsing Event
Handler
StartDocument
Parsing do começo.
Descrição
EndDocument
Último evento disparado, o fim do documento foi alcançado.
StartElement
Um tag de elemento sofreu parsing. Uma lista de atributos é
fornecida.
EndElement
O tag de final de um elemento sofreu parsing.
Characters
O parser localizou um bloco de caracteres. Pode ser
chamada várias vezes para um elemento.
IgnorableWhitespace
O parser localizou um bloco de espaços em branco
geralmente ignorado no padrão XML.
processingInstruction O parser localizou uma processing instruction que é
retornada como uma String.
SetDocumentLocator
Esse evento retorna um objeto que implementa a interface
Locator que aponta o local no documento que disparou o
evento.
5.2.2 Eventos disparados pelo parser SAX
Tabela 5 - Eventos disparados pelo parser SAX.
Parsing Event Handler
Descrição
StartDocument
Parsing começou.
EndDocument
O fim do documento foi alcançado. Este é o último evento
disparado.
Um tag de elemento sofreu parsing. Uma lista de atributos
é fornecida.
O tag de final de um elemento sofreu parsing.
StartElement
EndElement
Characters
IgnorableWhitespace
processingInstruction
SetDocumentLocator
O parser localizou um bloco de caracteres. Pode ser
chamada várias vezes para um elemento.
O parser localizou um bloco de espaços em brancos
geralmente ignorado no padrão XML.
O parser localizou uma processing instruction que é
retornada como uma String.
Esse evento retorna um objeto que implementa a interface
Locator que aponta o local no documento que disparou o
evento.
31
5.2.3 Exemplo de SAX
Para se programar em SAX é preciso mudar o ponto de vista em relação a
programação DOM. O parser SAX passa apenas uma vez pelo documento fonte, e o
programador deve fazer tudo que ele precisa nesta única passagem. Uma das vantagens do
SAX é que ele requer pouca memória, e a quantidade não depende do tamanho do
documento XML. O Exemplo 17 nos mostra um documento XML de notícias.
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE moreovernews SYSTEM "moreovernews.dtd">
<moreovernews>
<article id="_8510757">
<url>http://c.moreover.com/click/here.pl?x8510756</url>
<headline_text>Cyclone Commerce Poised to Fulfill Promise
of E-Signature Legislation</headline_text>
<source>Java Industry Connection</source>
<media_type>text</media_type>
<cluster>Java news</cluster>
<tagline> </tagline>
<document_url>http://industry.java.sun.com/javanews/more/hotnews/
</document_url>
<harvest_time>Jul 25 2000 8:34AM</harvest_time>
<access_registration> </access_registration>
<access_status> </access_status>
</article>
<article id="_8514989">
Exemplo 17: Documento XML.
5.2.4 Utilização do SAX em Java
A implementação do parser SAX da Sun no pacote javax.xml.parsers é bastante
flexível. Um parser é obtido via SAXParserFactory da seguinte maneira:
SAXParserFactory fac = SAXParserFactory.newInstance();
SAXParser parser = fac.newSAXParser();
O parser é iniciado chamando um dos métodos parse fornecido. Estes diferem na
maneira em que foi especificado o documento de entrada do parser. É possível usar um
objeto InputStream, um objeto File, um URI, ou um objeto org.xml.sax.InputSource. O
método parse também requer uma referência para um objeto que estende a classe
HandlerInput.
32
import javax.xml.parsers.*;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import java.io.*;
public class SAXTesteSimples {
public SAXTesteSimples()
{
try {
SAXParserFactory factory =
SAXParserFactory.newInstance();
SAXParser parser = factory.newSAXParser();
DefaultHandler dh = new
SAXTesteSimplesHandler();
parser.parse(new
File("c:\\temp\\teste.xml"), dh);
parser.getXMLReader();
} catch(ParserConfigurationException pce) {
pce.printStackTrace();
} catch (SAXException saxe) {
saxe.printStackTrace();
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
public static void main(String arg[])
{
new SAXTesteSimples();
}
public class SAXTesteSimplesHandler extends
DefaultHandler {
public void startElement(String uri, String localName, String name,
Attributes attrs) {
System.out.println(name);
}
33
public void characters(char[] ch, int start,
int length) {
if (!(new String(ch, start,
length).trim().equals("")))
System.out.println(new String(ch,
start, length).trim());
}
}
}
Exemplo 18: Utilização do SAX em Java.
5.2.5 Localizando Parse Errors
Problemas sérios de parsing causarão a chamada do SAXParseException. O
Exemplo 19 mostra como extrair informações ao máximo da exceção, transformando em
uma string:
} catch (SAXParseException spe) {
StringBuffer sb = new StringBuffer (spe.toString());
sb.append(“\n Line number: ”+ spe.getLineNumber());
sb.append(“\n Column number: ” + spe.getColumnNumber());
sb.append(“\n Public ID: ” + spe.getPublicId());
sb.append(“\n System ID” + spe.getSystemId());
return sb.toString();
}
Exemplo 19: Chamada do SAXParseExpection.
34
6. CONSTRUÇÃO DO PROTÓTIPO
O protótipo mostrará os resultados obtidos através da manipulação de dados XML na
plataforma Java.
Através de dois exemplos poderemos ver em qual caso é mais viável o uso do DOM e
em qual caso é viável o uso do SAX. Será possível escolher se a consulta será feita em
SAX ou em DOM. A Figura 7 mostra o esquema do protótipo, desde o conversor até o
resultado.
Figura 7 - Esquema do protótipo
Será usado um programa que converterá banco de dados Firebird ou Interbase
exportando o banco para um arquivo XML, para que seja possível a manipulação de dados
no protótipo. O programa chama-se Fixmlexport, é da empresa TECT Software Ltda. Depois
de feito o cadastro no site é possível fazer o download do programa, pois ele é um software
livre. A Figura 8 mostra a tela principal do programa, depois de especificado o caminho do
banco de dados e programa faz a conexão mostrando todas as tabelas. Para converter o BD
é preciso especificar o caminho onde será salvo e exporta-lo, como mostra a Figura 9.
35
Figura 8: Programa Fixmlexport (Tela Principal).
Figura 9: Programa Fixmlexport (Exportação).
36
6.1. Caso de Uso
Figura 10 - Caso de Uso do Protótipo.
O usuário pode escolher qual o arquivo ele deseja procurar e em seguida escolher
qual método utilizar. E o cliente final visualiza a consulta dos dados que ele solicitou como
mostra a Figura 10.
6.2. Desenvolvimento
Inicialmente temos um documento, que pode ser um XML qualquer ou um arquivo
convertido através do Fixmlexport. Assim que o protótipo é executado é preciiso escolher
qual arquivo será processado (Figura 11).
O protótipo utilizará duas APIS Java destinado à manipulação de dados em XML, SAX
e DOM.
Depois de escolhido o arquivo é preciso escolher entre as duas APIs, o protótipo
retornará o documento escolhido processado integralmente e também o início, fim e tempo
decorrido da consulta (Figura 12).
Como mostra a seção 5, para cada caso é preciso escolher entre utilizar a API DOM
ou a SAX. Se o arquivo for muito extenso recomenda-se que se utilize a aplicação com a
API SAX, pois está não armazena na memória o documento e sua busca é feita
seqüencialmente. Se o Arquivo for menor ou se houver a necessidade de busca através de
árvores é recomendado que se utilize à aplicação com API Dom, já que está cria uma arvore
de nodes na memória, porém essa aplicação não é recomendada se o arquivo for muito
extenso, pois ocupará muita memória.
37
Figura 11: Protótipo – Tela para escolher o arquivo.
Figura 12 - Tela com documento processado e tempo decorrido.
38
6.3. As APIS no protótipo
A API DOM tem uma complexidade maior na programação, embora o seu
entendimento seja razoavelmente fácil, sua implementação é mais complexa. O Exemplo 20
mostra um fragmento da criação do parsers DOM e o printNode que é o responsável pela
impressão dentro do ta (JTextArea).
// cria uma fábrica de parsers DOM
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(true); // Testa DTD/Schema
factory.setNamespaceAware(true); // Testa o name space
DocumentBuilder builder = factory.newDocumentBuilder();
// obtem a árvore do arquivo XML
Document documento = builder.parse( new File( uri ) );
…..
…..
// imprime o documento
printNode( (Node)documento, "" ,ta);
Exemplo 20: Fragmento do protótipo – criando parsers DOM
SAX é considerado mais fácil na sua implementação, já possui classe prontas como o
Handler que percorre e imprime o documento (Exemplo 21).
SAXParserFactory factory = SAXParserFactory.newInstance();
factory.setValidating(true); // se considera a DTD/Schema
factory.setNamespaceAware(true); // se o parser considera o name space
SAXParser saxParser = factory.newSAXParser();
…..
…..
class EchoHandler extends DefaultHandler {
private JTextArea ta;
public EchoHandler(JTextArea xta){
ta = xta;
}
public void startDocument() throws SAXException {
ta.append("\nInício do documento");
}
Exemplo 21: Fragmento do protótipo – Usando o Handler em SAX.
39
6.4. Os testes do protótipo
Os testes do protótipo foram realizados em 3 arquivos XML. O primeiro arquivo foi um
arquivo convertido através do conversor Fixmlexport, TATI.xml, porém o banco de dados
continha poucos registro o que deixou o XML com apenas 3 Kb. Com esse arquivo não foi
possível realizar teste comparativos entre DOM e SAX devido ao seu pequeno tamanho.
O segundo arquivo foi o SectorsAndIndustries90_1.xml que contém 7473 elementos e
578 Kb. O terceiro arquivo foi o SectorsAndIndustries90_2.xml, o mesmo que o segundo
arquivo, porém com 22419 elementos e 2,25 Mb. Foi preciso utilizar arquivos de tamanhos
diferentes para confirmar que quanto maior for o arquivo mais lenta se torna a busca em
DOM.
Tabela 6 – Testes entre Dom e SAX – comparação tempo decorrido.
DOM
SAX
DOM
SAX
DOM
SAX
Nº Teste
Arquivo 1 – 2,25 Mb
Arquivo 1 - 2,25 Mb
Arquivo 2 – 578 Kb
01
16,360
11,282
9,969
8,125
3,62
5,046
02
16,625
8,297
16,79
7,625
2,453
2,704
03
16,907
8,562
16,515
7,36
2,250
2,531
04
17,297
8,157
17,31
7,594
2,562
2,422
05
18,437
8,438
17,953
7,718
2,0
2,516
06
19,187
7,891
17,824
7,328
2,656
2,482
Média
17,469
8,771
16,060
7,625
2,590
2,950
Para arquivos maiores é recomendado o uso do SAX, os resultados na Tabela 6
indicam que quanto maior o arquivo mais lento o DOM se torna.
Para o arquivo com 578 Kb o DOM obteve média de 2,590, enquanto o SAX 2,950
Para o arquivo com 2,25 Mb o DOM obteve médias 17,469 e 16,060, enquanto o SAX
8,771 e 7,625.
A escolha da API irá depender o tipo de consulta a ser realiza e do tamanho do
arquivo. DOM tem melhor performance em arquivos menores.
6.5. Ambiente de Desenvolvimento
O protótipo foi desenvolvido através da plataforma Java utilizando o programa
Netbeeans, versão 5.0.
Para desenvolver o projeto foi utilizado um microcomputador com processador Celeron
2.5 Mhz, memória Ram de 512 Mb e Hd de 80 Gb. O sistema operacional utilizado foi o
Windows XP.
40
7. CONCLUSÕES
7.1. Conclusão
O desenvolvimento desse projeto nos últimos meses foi sem dúvidas um período de
grande aprendizagem, um grande desafio. Hoje posso afirmar estar mais preparada para
enfrentar novos desafios.
Ao concluir este projeto posso dizer que esta experiência foi marcante e
enriquecedora, descobri o sentido da grande responsabilidade da estruturação e
organização de um plano de trabalho.
O projeto envolveu várias áreas estudadas no curso, foi possível relembrá-las e aplicálas, além disso, o projeto envolveu o estudo da linguagem XML, uma tecnologia que para
mim foi totalmente nova, o que me acrescentou muito e aumentou o desfio do projeto.
Com o passar do tempo o projeto foi ganhando forma, onde cada obstáculo
ultrapassado deixava antever um obstáculo ainda maior que o anterior. Foram meses de
trabalho, onde a capacidade de organização, estruturação, análise e resolução de
problemas foram grandes.
A construção do protótipo foi um dos maiores desafios desse projeto, porém ao
termino pode-se constatar que ele preencheu os requisitos que foram estabelecidos.
Enfim o projeto é uma realidade, um grande desafio que delimitou a conclusão da vida
acadêmica.
7.2. Melhoramentos
O protótipo é uma idéia inicial para que se possa visualizar os resultados da utilização
do XML no Java.
Um melhoramento que sugeria é que tivessem mais opções de campos para se
consultar, assim a consulta seria agilizada, pois seria possível escolher o que procurar e em
qual método procurar.
41
8. REFERÊNCIAS BIBLIOGRÁFICAS
CRIAR WEB. “Manuais e recursos para desenvolvimento web”. [INTERNET:
http://www.criarweb.com/XML/, recuperado em: 04/04/2006]
FARIA, Rogério Amorim de . Treinamento Avançado em XML. 1. ed. São Paulo, Digerati
Books, 2005.
IMPACTA Tecnologia. “IPM - Impacta Pesquisa Periódica de Mercado”. [INTERNET:
http://www.impacta.com.br/ipm/pdfs/20050719_Iccorp_analises.pdf, recuperado em:
05/12/2005]
JANDL JUNIOR, Peter, Introdução ao Java. São Paulo, SP: Berkeley, 2002
LIGHT, Richard ; MORAES, Neilande. Iniciando em XML. 1. ed. São Paulo, Makron Books,
1999.
ORG SAX. “Package org.xml.sax “. [INTERNET:
http://www.saxproject.org/apidoc/org/xml/sax/package-summary.html, recuperado em:
13/06/2006]
PITTS-MOULTIS, Natanya.; KIRK, Cheryl. XML Black Book. 1. ed. São Paulo, Makron
Books, 2000
SUN Microsystems, Inc. “Inner Circle Program”.
[INTERNET:http://www.sun.com/emrkt/innercircle/newsletter/brazil/0605howard.html,
recuperado em: 30/11/2005 A]
SUN Microsystems, Inc. “The Java Tutorial”. [INTERNET:
http://java.sun.com/docs/books/tutorial/, recuperado em: 25/11/2005, B]
SUN Microsystems, Inc. “Java Technology”. [INTERNET: http://java.sun.com, recuperado
em: 25/11/2005, C]
SUN Microsystems. “Java API Documentation”. [INTERNET: http://java.sun.com/docs/,
recuperado em 15/02/2006, D]
TECT Software. “Fixmlexport”. [INTERNET: http://www.tectsoft.net/, recuperado em
13/08/2006]
WIKIPEDIA. “Manual XML”. [INTERNET: http://pt.wikipedia.org/wiki/XML, recuperado em:
10/03/2006]
W3C. “World Wide Web Consortium”. [INTERNET: http://www.w3c.org, recuperado em
16/03/2006
42