Universidade Estadual de Maringá
Centro de Tecnologia
Departamento de Informática
A Aplicação de XML no Desenvolvimento de Aplicações
Distribuídas
Beatriz do Carmo Langiano
Daniele Fernanda Fávero
Débora Rodrigues Rebello
PIC/UEM
Maringá - Paraná
Brasil
I
RESUMO
No desenvolvimento de documentos XML existem várias tecnologias
empregadas com o intuito de obter um aplicativo válido e consistente com o objetivo
final do projeto. Do ponto de vista sintático e semântico, utiliza-se Parsers apropriados,
(que podem ou não fazer uso de APIs). Já as DTDs são utilizadas para declaração dos
elementos que serão utilizados no documento XML propriamente dito.
Uma das principais características da XML é sua maneira adequada de
representação de dados. O conteúdo de um documento XML é tratado pelo que chamase de folhas de estilo, as quais descrevem como as partes do documento serão
apresentadas. Para tanto, criou-se uma linguagem chamada XSL, a qual também pode
ser utilizada para transformar documentos XML em outros formatos de documentos
(por exemplo, HTML e RTF). As linguagens criadas para o estabelecimento de links
entre recursos em XML são XLink e XPointer. A linguagem de ligação XLink permite a
inserção de elementos em documentos XML para criar e descrever links entre recursos.
A linguagem XPointer foi criada para permitir a especificação de fragmentos de
documentos.
Linguagens especificadas a partir da XML foram estudadas com o intuito de
observar quais seriam aproveitadas no desenvolvimento do projeto proposto. Dentre
essas linguagens, destaca-se a XMI (XML Metadata Interchange). XMI é o padrão da
OMG (Object Management Group) para interoperabilidade de metadados. Pode-se
definir a XMI como uma integração da tecnologia de Objetos(UML) e o padrão para
trocas de dados através da internet (XML).
Em síntese, estas linguagens foram propostas, sobretudo, para permitir a
reutilização de conteúdo e estruturação de documentos. Elas também têm por finalidade
facilitar a troca de informações e aumentar a independência dos documentos na Web.
II
Sumário
1.0 – INTRODUÇÃO ...............................................................................................
1
2.0 – OBJETIVOS ....................................................................................................
3
3.0 – DESENVOLVIMENTO ..................................................................................
4
3.1 - Exploração da Semântica na Linguagem XML ...........................................
4
3.1.1 – Configurando a Linguagem XML ......................................................
4
3.1.1.1 – O que é XML? .............................................................................
4
3.1.1.2 – Pontos Fortes da Linguagem ..,,...................................................
5
3.1.1.3 – Compreendendo documentos XML ............................................
6
3.1.1.3.1 – Elementos ............................................................................
7
3.1.1.3.2 – Referências a Entidades ......................................................
7
3.1.1.3.3 – Comentários ........................................................................
7
3.1.1.3.4 – Instruções de Processamento (PI) ......................................
8
3.1.1.3.5 – Seções Marcadas (CDATA) ...............................................
8
3.1.1.3.6 - Declarações de tipos de documentos ...................................
9
3.1.1.3.6.1 – Declarações de Tipos de Elementos ...........................
9
3.1.1.3.6.2 – Declarações de listas de atributos ...............................
10
3.1.1.3.6.3 – Declarações de Entidade .............................................
12
3.1.1.3.6.4 – Declarações de Notação ..............................................
14
3.1.2 – Criando-se Novas “Linguagens” a Partir de XML ............................
14
3.1.2.1 – Como Criar uma Nova Gramática? ............................................
14
3.1.2.2 – Utilizando uma DTD ..................................................................
14
3.1.2.2.1 – O que é uma DTD? ............................................................
14
3.1.2.2.2 – Como Criar uma DTD bem projetada? ...............................
15
3.1.2.2.3 – Onde se localiza uma DTD? ..............................................
16
3.1.2.2.4 – Quando usar uma DTD ......................................................
18
3.1.2.3 – Como Funciona o XML Schema? ..............................................
19
3.1.2.3.1 – O que um Schema? ............................................................
19
3.1.2.3.2 – Criando uma Schema .........................................................
19
3.1.2.3.3 – Declaração de Dados Dentro de um Schema .....................
20
III
3.1.3 – Processamento de um Documento XML ...........................................
21
3.1.3.1 – Editores XML .............................................................................
21
3.1.3.2 – Analisadores Sintáticos ...............................................................
22
3.1.3.2.1 – Aelfred ................................................................................
25
3.1.3.2.2 – MSXML ..............................................................................
25
3.1.3.3 – Processadores ou Parsers ............................................................
26
3.1.3.4 – Application Programming Interfaces (API’s) ........................….
27
3.1.3.4.1 – Características do DOM? ....................................................
28
3.1.3.4.2 – Como se caracteriza o SAX? ..............................................
33
3.2 - Estudo das Linguagens que dão Suporte à Representação de Documentos
37
XML ............................................................................................................
3.2.1 - CSS (Cascading Style Sheets) ..................................................……...
38
3.2.1.1 – Cascata .......................................................................................
38
3.2.1.2 – Conceitos Básicos .......................................................................
38
3.2.1.3 – Como criar uma folha de estilo externa ......................................
40
3.2.2 – XSL (eXtensible Style Language) ...............................................……
41
3.2.2.1 – Xpath ...........................................................................................
41
3.2.2.1.1 – Criando expressões em Xpath .............................................
43
3.2.2.2 – XSL (eXtensible Style Language) ........................................…..
45
3.2.2.2.1 – Transformando XML em HTML ........................................
47
3.2.2.2.2 – Informações adicionais .......................................................
52
3.2.3 – Linguagens responsáveis por definir e estabelecer e estruturas de
53
ligações (links) com outras fontes .......................................................
3.2.3.1 – XLINK (Linguagem de Links Extensível) .................................
53
3.2.3.1.1 – Links e recursos .................................................................
54
3.2.3.1.2 – Elementos Xlink .................................................................
54
3.2.3.1.2.1 – SIMPLE ....................................................................
54
3.2.3.1.2.1.1 – Comportamento dos Links .................................
54
3.2.3.1.2.1.2 – Como criar um link simples? .............................
56
3.2.3.1.2.2 – EXTENDED ..............................................................
57
3.2.3.1.2.2.1 – Atributos dos links estendidos ...........................
57
3.2.3.1.2.2.2 – Como criar um link estendido? ..........................
57
3.2.3.1.3 - XTooX – Ferramenta para o uso de Xlinks .........................
58
IV
3.2.3.1.3.1 – Exemplo do uso de XtooX .........................................
59
3.2.3.2 – XPOINTER (Linguagem de Ponteiro XML) ..............................
66
3.2.3.2.1 – Como declarar Xpointer .....................................................
66
3.2.3.2.2 – Como ligar a parte de um arquivo .......................................
66
3.2.3.2.3 – Como criar XPointer mais simples .....................................
67
3.2.3.2.4 – Como criar XPointers móveis .............................................
67
3.2.3.2.5 – Como criar uma faixa de Xpointers ....................................
68
3.3 – Estudo das Linguagens Construídas a partir de XML ................................
69
3.3.1 – Aplicativos XML ...........................................…................................
69
3.3.1.1 – RDF (Resource Description Framework) ….....................….......
70
3.3.1.1.1 – Exemplos .............................................................................
71
3.3.1.2 – SMIL (Syncronized Multimedia Integration Langu) .........….....
72
3.3.1.2.1 – Exemplos ............................................................................
74
3.3.1.3 – UXF (UML eXchange Format) ...................................................
76
3.3.1.3.1 – Limitações do HTML .........................................................
78
3.3.1.3.2 – Exemplo ..............................................................................
80
3.3.1.4 – CDF (Channel Definition Format) ........................................….
80
3.3.1.4.1 – Uma visão mais detalhada dos Canais ................................
81
3.3.1.4.2 – Vantagens dos canais para o usuário ...................................
82
3.3.1.4.3 – Vantagens dos canais para o desenvolvedor .......................
83
3.3.1.4.4 – O relacionamento do XML com o CDF ..............................
85
3.3.1.4.5 – Exemplo ..............................................................................
86
3.3.1.5 – DRP (Distribution and Replication Protocol) .............................
87
3.3.1.6 – XMI (XML Metadata Interchange ) ...........................................
89
3.3.1.6.1 – DTD XMI e Estrutura de Documento ................................
90
3.3.1.6.2 – Atributos XMI necessários ..................................................
90
3.3.1.6.2.1 – Atributos de Ligação ..................................................
91
3.3.1.6.2.2 – Elementos XMI comuns .............................................
92
3.3.1.6.2.3 – Elemento XMI .............................................................
93
3.3.1.6.2.4 – XMI.header ................................................................
93
3.3.1.6.2.5 – XMI.content ................................................................
94
3.3.1.6.2.6 – XMI.extensions ...........................................................
94
3.3.1.6.2.7 – XMI.documentation ....................................................
94
V
3.3.1.6.2.8 – XMI.model ..................................................................
95
3.3.1.6.2.9 – XMI.metamodel ..........................................................
95
3.3.1.6.2.10 – XMI.difference .....................................................….
96
3.3.1.6.2.11 – XMI.delete ................................................................
96
3.3.1.6.2.12 – XMI.add .............................................................…...
96
3.3.1.6.2.13 – XMI.replace ..............................................................
97
3.3.1.6.2.14 – XMI.reference ...........................................................
97
3.3.1.6.3 – Exemplo ..............................................................................
98
4 .0 – RESULTADOS E DISCUSSÕES ..................................................................
99
4.1 – Arquitetura XML .......................................................................................
99
4.2 – Descrição do Exemplo ................................................................................
100
4.2.1 – Documento de Tipo de Definição (DTD) ...........................................
101
4.2.2 – Documento XML ................................................................................ 101
4.2.3 – Documento XSL .................................................................................
103
4.2.4 – Documento XMI .................................................................................
104
4.2.5 – Resultados Obtidos .............................................................................
105
4.3 – Arquitetura X Aplicação XML .................................................................... 108
5.0 – CONCLUSÃO .................................................................................................. 110
BIBLIOGRAFIA ....................................................................................................... 112
ANEXOS ................................................................................................................... 116
Anexo 1 – Documento UXF referente ao exemplo da seção 4.1.3.2 .................... 116
Anexo 2 – Documento XMI referente ao exemplo de Aplicação XML ............... 121
VI
Sumário das Figuras
Tabela 3.1.1: Analisadores Sintáticos
23
Figura 3.1.1: Arquitetura do Processo de um Documento XML
27
Figura 3.1.2: Arquitetura do Processo de Utilização do DOM
31
Figura 3.3.1: Diagrama de Use Case
98
Figura 3.3.2: Diagrama de Classes
98
Figura 4.1.1: Arquitetura XML
100
Figura 4.2.1: Diagrama de Classes feito no ArgoUML
105
Figura 4.2.2: Classe Participante, Mostrada no Documento HTML
105
Figura 4.2.3: Classe Apresentador, Mostrada no Documento HTML
106
Figura 4.2.4: Parte Superior da Página
107
Figura 4.2.5: Parte Inferior da Página
108
VII
1.0 – INTRODUÇÃO
Uma das primeiras linguagens a conseguir um espaço na programação para Web
foi a SGML (Standard Generalized Markup Language, ou Linguagem de Marcação
Padrão Generalizada). Inventada por Jon Bosak, engenheiro da Sun Microsystems e
definida em 1986 pela ISO (International Standards Organization) como padrão ISO
8879, a SGML é um poderoso padrão para linguagens de marcação, mas a sua utilização
é um pouco complexa. Essa complexidade tem feito com que a SGML não seja tão
utilizada quanto o esperado.
Atualmente,
a
principal
linguagem
de
programação
utilizada
para
desenvolvimento de páginas e aplicações no ambiente WWW é a HTML (HiperText
Markup Language) .
HTML foi desenvolvida em 1992 por Tim Berners Lee e Robert Caillau no
CERN, que é o Centro Europeu de Pesquisas de Física de Partículas. É uma linguagem
descendente da SGML. Originalmente a HTML definia estritamente a estrutura lógica
de um documento e não a sua aparência física. Mas, com a pressão dos usuários
(principalmente da indústria), as versões posteriores da HTML foram forçadas a prover
cada vez mais e mais controle da aparência do documento.
XML é um subconjunto do SGML. A linguagem XML simplifica
significativamente o SGML, mantendo os principais pontos, mas tornando seu
aprendizado mais simples. Ela está no processo de padronização pela W3C (Word Wide
Web Consortium), que é o órgão que define os padrões para a World Wide Web
[BUS00].
As inovações oferecidas pela linguagem XML estão diretamente relacionadas
com o contexto de Sistemas Distribuídos. Essa tecnologia pode ser utilizada em
plataformas diferentes, permitindo que seus dados sejam acessados por várias
aplicações.
A pesquisa realizada para o desenvolvimento desse trabalho abrange vários
aspectos dentro do domínio XML. A primeira parte destina-se ao estudo da semântica
da linguagem. Em seguida, são exploradas as linguagens que suportam a representação
de documentos XML.
1
Na parte 3 são estudadas as linguagens construídas a partir de XML, os
chamados Aplicativos dessa linguagem. Dando continuidade nesse estudo, desenvolveuse uma arquitetura para o desenvolvimento de aplicações baseadas na linguagem em
questão.
Como um exemplo prático, diante do embasamento teórico, contruiu-se uma
aplicação que está sendo descrita na parte de Resultados e Conclusões.
Toda essa pesquisa foi realizada viabilizando a sua aplicabilidade dentro do
contexto de Sistemas Distribuídos.
2
2.0 – OBJETIVOS
Este projeto tem como objetivo adquirir conhecimento sobre a XML, suas
diferentes aplicações para a Web e o desenvolvimento de estudos de caso considerando
os diferentes aspectos quanto à sua representação, semântica e linguagens derivadas,
observando a aplicabilidade das mesmas em uma metodologia de desenvolvimento de
software distribuído.
Os objetivos específicos são os seguintes:
-
Estudo dos aspectos relacionados à linguagem de marcação;
-
Estudo dos diferentes aspectos a serem considerados na XML;
-
Estudo das linguagens que suportam representação de documentos;
-
Estudo das linguagens que suportam a exploração da semântica de
documentos;
-
Estudo das linguagens construídas a partir de XML;
-
Definição de uma arquitetura para o desenvolvimento de aplicações baseadas
em XML;
-
Desenvolvimento de estudo de caso e avaliação dos resultados.
3
3.0 - DESENVOLVIMENTO
3.1 - Exploração da Semântica na Linguagem XML
Essa parte dessa pesquisa dedica-se a estudar a linguagem XML, explorando a
sua semântica e partindo-se desse princípio ela possibilita a criação de um documento
chamado DTD, onde o desenvolvedor de software tem a flexibilidade de definir os
componentes que bem entender ou necessitar (seguindo as especificações de DTD), de
acordo com os requisitos da XML.
Essa linguagem utiliza ainda Parsers apropriados para executar a verificação,
que analisam a sintaxe do documento XML com relação às suas especificações e às suas
DTDs correspondentes. A validação de um documento DTD é realizada pelo Parser.
Após a verificação e validação, o Parser gera uma arquitetura interna para organização
do documento XML, que é definida utilizando-se a estrutura de uma árvore.
O uso de APIs (Aplication Programing Interface), como (DOM e SAX),
também entram como um fator importante no contexto XML, permitindo que os dados
contidos no documento sejam acessados por outros aplicativos, como por exemplo:
armazená-los em bancos de dados.
Como qualquer outra linguagem de marcação, a XML existe para fornecer
informações sobre a estrutura e o conteúdo de um documento ou um conjunto de
documentos. Porém XML deixa questões referentes ao estilo e à apresentação do
documento a cargo de documentos separados. Para tanto os desenvolvedores
implementaram o suporte de folhas de estilos. A marcação governa o conteúdo e a
estrutura, ao passo que as folhas de estilos associadas comandam como o conteúdo e a
estrutura são apresentados ao usuário [PIT00].
3.1.1 – Configurando a Linguagem XML
3.1.1.1 – O que é XML?
A XML (eXtensible Markup Language) é uma linguagem que permite ao
projetista criar seus próprios elementos de acordo com a aplicação que está sendo
4
modelada, dando importância ao conteúdo e à estrutura da informação, sem se
preocupar com a modo de apresentação de tal documento.
3.1.1.2 – Pontos Fortes da Linguagem
Uma característica importantíssima da XML é o fato dela ser uma linguagem de
marcação. Essa é a primeira qualidade que distingue os documentos formatados com
uma linguagem de marcação genérica do restante. É que aqueles são normalmente
lógicos em sua ordem, e altamente estruturados. Eles incluem regras específicas que
afirmam onde as várias estruturas do documento devem e precisam ser colocadas. De
fato, documentos SGML e XML possuem uma estrutura em forma de árvore, que pode
ser vista em qualquer um dos analisadores sintáticos [PIT00]. É em torno dessa estrutura
em árvore, que todos os demais componentes, como conteúdo e formatação são
construídos.
Esse formato estruturado torna a descrição do conteúdo do documento mais fácil
e, por sua vez, facilita a formatação de seções dentro do mesmo. É mais simples, separar
o conteúdo da apresentação, e aplicar formatos específicos para fins específicos do
mesmo grupo de dados. A reformatação pode se facilmente concretizada, pois o
projetista não precisa percorrer cada linha de código e mudar formatos específicos para
itens específicos como eram exigidos no HTML.
A estrutura em forma de árvore torna mais fácil redesenhar documentos de
marcação genéricos ou extrair dados para públicos diferentes. O Channels, da
Microsoft, é um excelente exemplo de como um aplicativo XML pode ser usado para
fornecer os mesmos dados para uma ampla gama de aplicativos, como projetores de
tela, mensagens de correio eletrônico com formatação HTML ou canais em si, tudo isso
na área de trabalho do usuário. Essa estrutura de documento bem-formada começa com
uma base e, a partir desse ponto, pode-se trabalhar com opções mais específicas como
marcas. Não importa através de onde os dados estão sendo mostrados (no correio
eletrônico ou num canal colocado na área de trabalho do usuário), com um documento
altamente estruturado é o emprego da tecnologia de folhas de estilo, as mesmas
informações podem ser distribuídas para uma ampla gama de aplicativos de
visualização [PIT00].
Outras características consideráveis da linguagem XML são:
5
•
Inteligência: a XML é inteligente para qualquer nível de
complexidade. A marcação pode ser alterada de uma marcação mais geral como
"<CÃO> Lassie </CÃO>" para uma mais detalhada, como "<CÃO>
<VENHA_PARA_CASA>
<COLLIE>
Lassie
</COLLIE>
</VENHA_PARA_CASA> </CÃO>". As idéias são bem marcadas para que
"<VENDO_DOIS> duplo </VENDO_DOIS>" e "<MAIS_LICOR> duplo
</MAIS_LICOR>" sejam sempre valores diferentes. A informação conhece a si
mesma. Não é necessária mais nenhuma idéia indesejável;
•
Manutenção: a XML é fácil de manter. Ela contém somente idéias e
marcações. Folhas de estilos e links vêm em separado, e não escondidas no
documento. Cada um pode ser alterado separadamente quando preciso com fácil
acesso e fáceis mudanças. Não é preciso mais se achar em uma bagunça de
marcações;
•
Simplicidade: a XML é simples. Um usuário de média experiência
que olha a XML pode achá-la difícil de acreditar no que vê. Comparada com a
HTML não. Comparada com a SGML é um estudo de simplicidade. A
especificação da SGML tem 300 páginas. A da XML, 33. Idéias obscuras e
desnecessárias foram retiradas em favor de idéias concisas. A XML vai direto ao
ponto;
•
Portabilidade: a XML é de fácil portabilidade. A razão da sua
existência é força e portabilidade. A SGML tem força. A HTML tem
portabilidade. A XML tem ambas. A XML pode ser navegada com ou sem o seu
DTD (Document Type Definition, ou Definição de Tipo de Documento - as
normas que definem como as tags são estruturas nos documentos XML),
tornando o download mais rápido. Tudo que um navegador precisa para ver
XML é ter a noção que ela própria e a folha de estilos controlam a aparência. Se
uma validação estrita é necessária, o seu DTD pode acompanhá-lo e fornecer
detalhes exatos da sua marcação.
3.1.1.3 - Compreendendo documentos XML
Os documentos XML são compostos de marcas e conteúdos. Existem seis tipos
de marcações que podem ocorrer em um documento XML: elementos, referências a
6
entidades, comentários, instruções de processamento, seções marcadas e declarações de
tipos de documentos. Eis a introdução dos seus conceitos:
3.1.1.3.1 – Elementos
Elementos são a forma mais comum de marcação. São delimitados pelos sinais
de menor (<) e maior (>) e a maioria dos elementos identificam a natureza de seus
conteúdos. Alguns podem ser vazios.
Ex: <elemento>
Atributos
São pares de valores nomeados que ocorrem dentro das marcas de início, após o
nome do elemento.
Ex: <filme genero=”comédia”>
É um elemento filme cujo atributo gênero possui o valor comédia. Todos os
valores de atributos devem estar entre aspas.
3.1.1.3.2 - Referências a Entidades
Por ser um documento baseado em marcações, alguns caracteres foram
reservados para tal finalidade. Seria um problema colocar esses caracteres em seu
documento sem que fossem considerados sinais de marcação. Assim, em XML, são
usadas as entidades para resolver estes problemas. Também são usadas para referenciar
textos que são repetidos ou alterados com freqüência.
Cada entidade deve ter um nome único. Para usar a entidade, você simplesmente
a referencia pelo nome. Essas referências começam com o E comercial (&) e terminam
com ponto-e-vírgula (;).
Por exemplo, a entidade lt insere o caracter “<” em um documento. Essa
entidade seria referenciada no documento da seguinte maneira: &lt;.
3.1.1.3.3 - Comentários
Comentários não fazem parte de um conteúdo textual do documento XML. Um
processador XML não precisa reconhecê-lo na aplicação.
7
Os comentários podem ser colocados entre as marcas em qualquer lugar do
documento. Eles se iniciam com <!-- e terminam com --> e pode conter qualquer dado,
exceto a combinação “--“.
Ex: <!--Comentário-->
3.1.1.3.4 - Instruções de Processamento (PI)
São formas de fornecer informações a uma aplicação. Elas não são,
textualmente, parte do documento, mas, ao contrário do comentário, elas precisam do
processador para reconhecê-las na aplicação.
Elas têm a forma <?nome dadospi?>. O nome, também chamado de alvo PI,
identifica a PI na aplicação. As aplicações processam somente os alvos PIs que são
reconhecidos e ignoram o resto. Qualquer dado que segue o alvo é opcional, serve para
a aplicação reconhecer o alvo. Os nomes usados em PIs podem ser declarados como
notações a fim de identificá-los formalmente.
Os nomes de PI que iniciam com ‘xml’ são reservados para a padronização da
XML. Por exemplo, a instrução <?xml-stylesheet type="text/css" href="Exemplo.xsl"?>
indica o endereço da folha de estilo correspondente ao documento que contém esta
instrução.
3.1.1.3.5 - Seções Marcadas (CDATA)
Essa seção instrui o analisador para ignorar a maioria dos caracteres de
marcação.
O código-fonte de um documento XML pode conter caracteres que o analisador
XML reconheceria como marcação (por exemplo, < e&). Podemos prevenir isso usando
uma seção CDATA.
Uma seção CDATA inicia-se com <![CDATA[ e termina com ]]>. Todos os
dados contidos entre as marcas são passados diretamente para a aplicação, sem passar
pelo processador, e podem conter qualquer caracter, menos a combinação “]]>”
Ex: <![CDATA[
*p = &q;
b = (i<=3);
]]>
8
3.1.1.3.6 - Declarações de tipos de documentos
As declarações permitem a um documento comunicar meta-informação ao
analisador a respeito do seu conteúdo. Meta-informação inclui as seqüências e
aninhamentos permitidos para as marcas, valores de atributos e seus tipos e padrões, os
nomes de arquivos externos que podem ser referenciados e se eles podem ou não conter
XML, o formato de algum dado (não-XML) externo que pode ser referenciado e as
entidades que podem ser encontradas.
Há quatro tipos de declarações em XML: declarações de tipos de elementos,
declarações de listas de atributos, declarações de entidades e declarações de notações.
3.1.1.3.6.1 - Declarações de Tipos de Elementos
Declarações de tipos de elementos identificam os nomes dos elementos e a
natureza do seu conteúdo. Por exemplo, a declaração <!ELEMENT piada (João+, José*,
aplausos?)> identifica o elemento nomeado como piada. Seu modelo de conteúdo segue
o nome do elemento (este modelo define o que um elemento pode conter). Neste caso, o
elemento piada deve conter os elementos João e José e pode conter o elemento
aplausos. As vírgulas entre os nomes dos elementos indicam que eles devem ocorrer em
sucessão. O sinal de adição (+) indica que a unidade deve aparecer ao menos uma vez
ou várias vezes, no elemento definido. O sinal de interrogação (?) indica que a unidade
é opcional (pode estar ausente ou aparecer no máximo uma vez), se for o caso, no
elemento definido. O asterisco (*) indica que a unidade pode aparecer tantas vezes
quanto necessária ou nenhuma, no elemento sendo definido. Um elemento sem
pontuação deve ocorrer somente uma vez.
As declarações para todos os elementos usados em qualquer modelo de conteúdo
devem estar presentes para que um processador XML verifique a validade do
documento.
Além dos nomes de elementos, o símbolo especial #PCDATA é reservado para
indicar dados de caracter. A cláusula PCDATA significa dado de caracter analisável.
Os elementos que contêm somente outros elementos são ditos que possuem
conteúdo de elementos. Os elementos que contêm outros elementos e #PCDATA são
ditos que possuem conteúdo misturado.
9
Por exemplo, a definição para o elemento José pode ser:
<!ELEMENT José (#PCDATA | citação)*>
A barra vertical indica um relacionamento "ou" e o asterisco indica que o
conteúdo é opcional (pode ocorrer zero ou mais vezes), conforme citado acima; por esta
definição, portanto, o elemento José pode conter zero ou mais caracteres e marcas
citação, misturadas em qualquer ordem. Todos os modelos de conteúdo misturado
devem ter esta forma: #PCDATA deve vir primeiro, todos os elementos devem ser
separados por barras verticais e o grupo inteiro deve ser opcional.
Outros dois modelos de conteúdo são possíveis: EMPTY, indicando que o
elemento não possui conteúdo e, conseqüentemente, não tem tag de fechamento, e
ANY, indicando que qualquer conteúdo é permitido.
O modelo de conteúdo ANY é algumas vezes útil durante a conversão de
documentos, mas deveria ser evitado ao máximo em um ambiente de produção, pois
desabilita toda a verificação do conteúdo deste elemento.
3.1.1.3.6.2 - Declarações de listas de atributos:
Declarações de listas de atributos identificam que elementos podem ter atributos,
que atributos tais elemento podem ter, que valores os atributos podem suportar e qual é
o valor padrão.
Exemplo:
<!ATTLIST piada
nome ID #REQUIRED
rótulo CDATA #IMPLIED
estado (engraçada | nãoengraçada) 'engraçada'>
Neste exemplo, o elemento “piada” possui três atributos: “nome”, que é um ID e
é obrigatório; “rótulo”, que é uma cadeia de caracteres (dados de caracter) e não é
obrigatório; e “estado”, que deve ser ou engraçada ou nãoengraçada e por padrão é
engraçada, se nenhum valor é especificado.
Cada atributo em uma declaração tem três partes: um nome, um tipo e um valor
padrão.
Existem seis tipos de atributos possíveis:
a) CDATA
Atributos CDATA são cadeias de caracteres, onde qualquer texto é permitido.
10
b) ID
O valor de um atributo ID deve ser um nome. Todos os valores usados para IDs
em um documento devem ser diferentes. Os IDs identificam unicamente elementos
individuais em um documento. Os elementos podem ter um único atributo ID.
c) IDREF ou IDREFS
O valor de um atributo IDREF deve ser o valor de um único atributo ID em
algum elemento no documento. O valor de um atributo IDREFS pode conter valores
IDREF múltiplos separados por espaços em branco.
d) ENTITY ou ENTITIES
O valor de um atributo ENTITY deve ser o nome de uma única entidade. O
valor de um atributo ENTITIES pode conter valores de entidades múltiplos separados
por espaços em branco.
e) NMTOKEN ou NMTOKENS
Atributos de símbolos de nome são uma forma restrita do atributo de cadeia de
caracteres. Em geral, um atributo NMTOKEN deve consistir de uma única palavra, mas
não há restrições adicionais para a palavra; não tem que estar associado com outro
atributo ou declaração. O valor de um atributo NMTOKENS pode conter valores
NMTOKEN múltiplos separados por espaços em branco.
f) Uma lista de nomes
Pode-se especificar que o valor de um atributo deve ser pego de uma lista
específica de nomes. Isto é freqüentemente chamado de tipo enumerado, porque cada
um dos valores possíveis está explicitamente enumerado na declaração.
Alternativamente, pode-se especificar que os nomes devem atender a um nome
de notação. Há quatro valores padrão possíveis:
- #REQUIRED
O atributo deve conter um valor explicitamente especificado em cada ocorrência
do elemento no documento.
- #IMPLIED
O valor do atributo não é requerido, e nenhum valor padrão é fornecido. Se um
valor não é especificado, o processador XML deve proceder sem um.
- "valor"
Qualquer valor pode ser dado a um atributo como padrão. O valor do atributo
não é requerido em cada elemento no documento, e se ele estiver presente, será dado a
ele o valor padrão.
11
- #FIXED
"value"
Uma declaração de atributo pode especificar que um atributo tem um valor fixo.
Neste caso, o atributo não é requerido, mas se ele ocorrer deve ter o valor especificado.
Se não estiver presente, será dado a ele o valor padrão.
O processador XML executa o reconhecimento dos valores dos atributos nos
valores dos atributos: as referências de caracter são substituídas por caracteres
referenciados, referências a entidades são resolvidas (recursivamente) e espaços em
branco são normalizados.
3.1.1.3.6.3 Declarações de Entidade
Declarações de entidades permitem associar um nome com algum outro
fragmento de conteúdo. Essa construção pode ser um pedaço de texto normal, um
pedaço de uma declaração de tipo de documento ou uma referência a um arquivo
externo que contém ou texto ou dados binários. Para a declaração de uma entidade, é
utilizada a seguinte sintaxe:
<!ENTITY nome_da_entidade “conteúdo”>
O exemplo abaixo mostra uma típica declaração de entidades:
<!ENTITY
ATI "ArborText, Inc.">
(criação da entidade ATI cujo conteúdo será a string ArborText, Inc)
<!ENTITY boilerplate SYSTEM
"/standard/legalnotice.xml">
(criação da entidade boilerplate a qual irá referenciar o arquivo legalnotice.xml
armazenado em um sistema local)
Existem três tipos de entidades:
- Entidades Internas
Entidades internas associam um nome com uma cadeia de caracteres ou texto
literal. Usando &ATI; em qualquer lugar do documento inserirá "ArborText, Inc"
naquele local.
As entidades internas permitem definir atalhos para textos freqüentemente
digitados ou textos que se espera que sejam alterados, como o estado de revisão de um
documento.
12
Elas também podem incluir referências para outras entidades internas.
A especificação XML pré-define cinco entidades internas:
- &lt; produz o sinal de menor, <
- &gt; produz o sinal de maior, >
- &amp; produz o E comercial, &
- &apos; produz um apóstrofo, '
- &quot; produz aspas, "
- Entidades Externas
Entidades externas associam um nome com o conteúdo de um outro arquivo.
Elas permitem ao documento XML referenciar o conteúdo de um outro arquivo; além
disso, elas contêm ou texto ou dados binários.
Se os arquivos referenciados pelas entidades externas contiverem texto, o
conteúdo desse arquivo é inserido no ponto de referência e analisado como parte do
documento referente. Dados binários não são analisados e podem somente ser
referenciados em um atributo; eles são usados para referenciar figuras e outro conteúdo
não-XML no documento.
O uso de &boilerplate; inserirá o conteúdo do arquivo /standard/ legalnotice.xml
no local da referência da entidade. O processador XML analisará o conteúdo deste
arquivo como se ele ocorresse literalmente no local.
A entidade ATIlogo também é uma entidade externa, cujo conteúdo é binário.
Ela pode ser usada somente como o valor de um atributo ENTITY (ou ENTITIES).
- Entidades Parâmetro
A entidade parâmetro somente pode ocorrer na declaração de tipo de documento.
Uma declaração de uma entidade parâmetro é identificada por "% " (porcento e espaço)
defronte ao seu nome na declaração. O caracter “%” também é usado em referências
para entidades parâmetro, ao invés do caracter “&”.
As referências à entidade parâmetro são imediatamente expandidas na
declaração de tipo de documento e seu texto de substituição é parte da declaração, onde
as referências a entidades normais não são expandidas.
Entidades parâmetro não são reconhecidas no corpo de um documento.
No trecho de código abaixo, percebe-se que os dois elementos têm o mesmo
modelo de conteúdo:
<!ELEMENT João (#PCDATA | citação)*>
<!ELEMENT José (#PCDATA | citação)*>
13
Até o momento, estes dois elementos são a mesma coisa somente porque eles
têm a mesma definição literal. A fim de tornar mais explícito o fato de que estes dois
elementos são semanticamente a mesma coisa, é usada uma entidade parâmetro para
definir seus modelos de conteúdo. Há duas vantagens em se usar uma entidade
parâmetro. Primeiramente, ela permite dar um nome descritivo ao conteúdo; além disso,
ela permite alterar o modelo de conteúdo somente em um local, caso deseja-se atualizar
as declarações do elemento, garantindo que elas sempre fiquem as mesmas:
<!ENTITY % pessoascontentes "#PCDATA | citação">
<!ELEMENT João (%pessoascontentes;)*>
<!ELEMENT José (%pessoascontentes;)*>
3.1.1.3.6.4 Declarações de Notação
Declarações de notação identificam tipos específicos de dados binários externos.
Estas informações são passadas à aplicação de processamento, que pode fazer qualquer
uso daquilo que for desejado. Uma típica declaração de notação é:
<!NOTATION GIF87A SYSTEM "GIF">
3.1.2 – Criando-se Novas “Linguagens” a Partir de XML
3.1.2.1 – Como Criar uma Nova Gramática?
A linguagem XML utiliza marcações especificas ao invés de marcações prédefinidas como é o caso do HTML. Essa personalização do documento XML é feita
quando definimos um conjunto de regras, atributos e elementos em um documento
específico que seja compatível com documentos XML. Esse conjunto de regras chamase esquema, e ele pode ser escrito em dois sistemas principais: DTDs e XML Schema.
3.1.2.2 - Utilizando uma DTD
3.1.2.2.1 – O que é uma DTD?
Uma DTD é o que realmente distingue XML e SGML das demais linguagens de
marcação (fornecem aos desenvolvedores as ferramentas necessárias para criar os tipos
14
de documentos que precisam). DTD é conjunto de estruturas que segue uma
determinada regra, e que pode estar dentro de um documento XML ou externamente,
em um arquivo, salvo com extensão.dtd.
Quando criamos uma DTD, estamos definindo regras que deverão ser seguidas
por um (ou uma classe [Trindade, 97]) documento. Essas regras são as estruturas que
podem ser usadas no documento XML, como:
•
que tipos de elementos;
•
que atributos esses elementos podem ter;
•
como as instâncias desses elementos estão hierarquicamente
relacionadas.
É importante saber que uma DTD define apenas a estrutura lógica de um
documento, não sendo fornecida informação alguma sobre a semântica da apresentação
do documento.
3.1.2.2.2 - Como Criar uma DTD bem projetada?
Para criar uma DTD bem-projetada, é necessário conhecer duas coisas: o tipo de
documento que estará marcando e o público-alvo.
A primeira coisa a fazer é determinar os tipos de documentos que precisam de
marcação. Pelo fato de o XML se tratar basicamente de estrutura, é preciso planejar com
antecedência antes de começar a desenvolver o DTD.
A seguir, é necessário identificar quais elementos, atributos, entidades e
notações para construir a DTD perfeita para o trabalho.
Deve-se examinar também o fluxo do documento, bem como o seu conteúdo. É
importante saber como os documentos se relacionarão entre si.
Etapas na análise e criação de documentos são as mesmas:
ƒ
Definir o ambiente no qual os documentos existentes funcionam.
ƒ
Definir as exigências externas para seus documentos internos.
ƒ
Definir e esboçar os elementos necessários tanto para uso interno como
para uso externo.
ƒ
Definir como os elementos se relacionarão entre si e com elementos
externos.
ƒ
Definir o fluxo de informações de um documento para o seguinte.
ƒ
Determinar quais são os outros sistemas que utilizarão os dados.
15
ƒ
Documentar como o fluxo de informações se dá, juntamente com os
elementos, atributos, entidades e notações definidas na DTD.
ƒ
Criar o modelo de DTD.
ƒ
Testar a DTD com o conteúdo de teste.
ƒ
Fornecer a DTD para todos os envolvidos no projeto.
3.1.2.2.3 Onde se localiza uma DTD?
Uma DTD pode ser armazenada interna ou externamente.
DTDs internas combinam todos os elementos, atributos, notações e entidades
dentro do documento XML. DTDs internas são colocadas no inicio do documento,
dentro da declaração tipo de documento. A declaração tipo de documento é responsável
por apontar o processador à DTD. Ela conecta a DTD ao documento.
Ao criar um documento com uma DTD interna, é necessário saber se o
documento precisa ser auto-suficiente. Um documento auto-suficiente pode ser movido
de um sistema para outro sem perder componentes. Pode-se usar o documento em um
sistema local sem a necessidade de estar conectado à Internet. Também se pode colocar
um documento auto-suficiente em uma unidade de cartucho ou disco e transportá-lo
para onde for. E qualquer processador XML poderá processá-lo sem ter de ficar
procurando por uma DTD respectiva.
Uma outra razão para inserir as informações de DTD em um único arquivo é a
de reduzir a quantidade de tempo de processamento.
Resumindo, usar uma DTD inserida internamente significa criar um arquivo
auto-suficiente, tanto válido como completo, onde qualquer processador XML pode
processar o arquivo sem ter de ficar procurando um arquivo de DTD externo.
16
Ex: documento livro.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE livro [
<!ELEMENT livro (genero, autor, edicao, editora, data, titulo)>
<!ELEMENT genero (#PCDATA)>
<!ELEMENT autor (#PCDATA)>
<!ELEMENT edicao (#PCDATA)>
<!ELEMENT editora (#PCDATA)>
<!ELEMENT data (#PCDATA)>
<!ELEMENT titulo (#PCDATA)>
]>
<livro>
<genero>Romance</genero>
<autor>Camilo Castelo Branco</autor>
<edicao>2</edicao>
<editora>Scipione</editora>
<data>1996</data>
<titulo>Amor de Salvação</titulo>
</livro>
Já as DTDs externas, embora acrescentem uma certa sobrecarga, aumento de
tempo de processamento, as DTDs externas oferecem vários benefícios, especialmente
na área de gerenciamento, atualização e edição de documentos. Eis algumas poucas
razões para utilização de DTDs externas:
•
Ao atualizar DTDs externas, pode-se usar DTDs públicas1
•
Com documentos pequenos, pode se concentrar no conteúdo.
•
DTDs externas possibilitam um melhor gerenciamento dos documentos.
1
DTD públicas: Existem publicamente algumas DTD já definidas, se o usuário quiser utilizálas, é necessário escrever a palavra PUBLIC dentro da declaração do tipo de documento. Se o
DTD for local, ou seja, o próprio usuário quem a criou, deve-se escrever a palavra-chave
SYSTEM na declaração.
17
Ex: documento livro.dtd
<?xml version="1.0" encoding="UTF-8"?>
<!ELEMENT livro (genero, autor, edicao, editora, data, titulo)>
<!ELEMENT genero (#PCDATA)>
<!ELEMENT autor (#PCDATA)>
<!ELEMENT edicao (#PCDATA)>
<!ELEMENT editora (#PCDATA)>
<!ELEMENT data (#PCDATA)>
<!ELEMENT titulo (#PCDATA)>
3.1.2.2.4 – Quando usar uma DTD
Um recurso muito importante do XML, é que ele não requer um DTD como
SGML. Pelo fato de o XML ter sido modelado para trabalhar dentro das restrições da
WWW, poderá haver vezes em que uma DTD simplesmente não funcione, devido às
limitações de largura de banda. Nesse caso, pode-se incluir as definições de elementos e
de atributos dentro do documento em si.
Entretanto, devemos saber exatamente quando precisamos de uma DTD interna
e quando precisamos de uma DTD externa. Há vários fatores que interferem nessa
tomada de decisão:
•
Documentos grandes requerem DTDs externas.
•
Documentos pequenos não requerem DTDs externas.
•
Alguns documentos voltados a Intenet não requerem DTDs2.
•
Processadores XML sem validação não exigem DTDs3.
2
Porque alguns documentos são construídos com estruturas já existentes em XML, ou
utilizando a própria linguagem HTML (que também tem “passagem livre” dentro de um doc.
XML.
3
Um documento XML é dito válido, se e somente se, ele satisfizer todas as especificações da
DTD, logo, se um processador não verifica validação, então, não exige DTD.
18
3.1.2.3.- Como Funciona o XML Schema?
3.1.2.3.1 – O que é um Schema?
Um Schema, como um DTD, define um esquema, ou seja, determina as
estruturas que o documento XML pode ou não conter.
As DTDs têm diversas desvantagens em relação aos Schemas escritos com XML
Schema. Primeiro, as DTDs são escritas em uma sintaxe que tem pouca relação com
XML e que não podem ser analisadas com um parser XML. Em segundo lugar, todas as
declarações em uma DTD são globais, o que significa que não se pode definir dois
elementos diferentes com mesmo nome, mesmo se aparecerem em contextos separados.
Finalmente, e talvez o mais importante, as DTDs não podem controlar que tipo
de informação determinado elemento ou atributo pode conter.
A linguagem XML Schema, desenvolvida pelo W3C, tenta solucionar cada um
desses problemas. XML Schema, escrita em XML, permite definir tanto elementos
globais (que devem ser utilizados da mesma forma em todo o documento XML) e
elementos locais (que podem ter um significado particular em determinado contexto).
Resumindo, XML Schema permite muito mais controle sobre o conteúdo de um
documento XML do que uma DTD.
3.1.2.3.2 – Criando uma Schema
Pode-se fazer uma transformação do exemplo de DTD mostrado no item 1.3.2.3
para um Schema, assim, teríamos o seguinte documento:
<?xml version="1.0" encoding="UTF-8"?>
<!--W3C Schema generated by XML Spy v3.5 (http://www.xmlspy.com)-->
<xsd:schema xmlns:xsd="http://www.w3.org/2000/10/XMLSchema"
elementFormDefault="qualified">
<xsd:element name="autor" type="xsd:string"/>
<xsd:element name="data" type="xsd:string"/>
<xsd:element name="edicao" type="xsd:string"/>
<xsd:element name="editora" type="xsd:string"/>
<xsd:element name="genero" type="xsd:string"/>
<xsd:element name="livro">
19
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="genero"/>
<xsd:element ref="autor"/>
<xsd:element ref="edicao"/>
<xsd:element ref="editora"/>
<xsd:element ref="data"/>
<xsd:element ref="titulo"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="titulo" type="xsd:string"/>
</xsd:schema>
3.1.2.3.3 – Declaração de Dados Dentro de um Schema
Em um sistema XML Schema, se especifica exatamente que tipo de texto que o
elemento vai ter, atribuindo a ele uma determinada definição de tipo.
Para determinar o tipo de um certo elemento, pode-se utilizar um tipo já definido
pelo sistema XML Schema ou personalizar um também a partir dos tipos já existentes
no Schema.
Entre os tipos já reconhecidos pelo XML Schema, temos:
-
xsd: timeDuration: determina hh:mm:ss,s
-
xsd: time: determina hh:mm:ss,s e fuso horário
-
xsd: timeInstant: determina dia e hh:mm:ss,s
-
xsd: date: determina dia aaaa-mm-dd
-
xsd: month: determina mês aaaa-mm
-
xsd: century: determina algarismos utilizados para expressar século
-
xsd: recurringDate: determinar mm-dd
-
xsd: recurringDay: determina somente dia -dd
-
xsd: decimal: numeros decimais
-
xsd: integer: numeros inteiros
-
xsd: positiveInteger: inteiros positivos
-
xsd: nonPositiveInteger: inteiros negativos
20
-
xsd: float: real
-
xsd: double: permite que o conteúdo tenha numeros em ponto flutuante
de precisao dupla de 64 bits.
-
xsd: zipcodeType: determina o cep
Como exemplo podemos citar o descrição do documento na seção “3.1.2.3.2 Criando um Schema” para representar o uso de tipos simples em utilização de tipos já
existentes.
No caso de utilização dos tipos para criação de tipos personalizados, temos:
<xsd: simpleType name= “zipcodeType”>
<xsd: restriction base= “xsd:string”>
<xsd: pattern value= “\d{5}(-\d{4})?”/>
</xsd: restriction>
</xsd: simpleType>
Utilizacao:
< xsd: element name= “zipcode” type= “zipcodeType”/>
3.1.3 – Processamento de um Documento XML
3.1.3.1 – Editores XML
Para criar um arquivo XML, é necessária a utilização de algum editor XML.
Pelo fato de os arquivos e DTDs XML serem simplesmente arquivos de texto, usa-se
um editor de texto simples como o Bloco de Notas.
Porém, não é necessária a utilização de um editor de texto simples. Editores
XML mais elaborados encontram-se à disposição e até mesmo estão programados para
serem lançados nos próximos anos. Produtos como o XML Pro Editor, da Vervet
[PIT00], que oferecem uma interface fácil de usar que o conduz através do processo de
criação de elementos, atributos e entidades XML e de seus respectivos valores. Tais
editores colocam automaticamente os colchetes corretos nas posições adequadas e
incluem todas as aspas, ponto-e-vírgulas e outras notações gramaticais.
21
Além de executar todas as árduas tarefas envolvidas na marcação adequada de
documentos, alguns destes editores XML, dispõem de assistentes que ajudam na criação
de DTDs e documentos XML, depois verificam a existência de erros no código XML.
Embora seja muito mais recomendável o uso de editores específicos para o
desenvolvimento de documentos XML, talvez uma decisão muito boa seria criar alguns
arquivos XML simples, em um processador de texto para se acostumar a escrever
código em XML e para aprender a formar documentos XML simples antes de usar
editores de terceiros; por exemplo, é fácil criar um elemento quando na realidade o
documento requer um atributo. Após entender como construir um documento XML
simples e sua DTD, pode-se ir para o próximo nível. Criar arquivos XML manualmente
contribuirá para que o programador tenha uma experiência inestimável e ajudá-lo-á a
entender como os elementos, atributos, entidades e notações XML são formados.
Contribuindo, também, para diagnosticar o código que foi criado no editor XML.
3.1.3.2 – Analisadores Sintáticos
Um analisador sintático é a ferramenta mais básica dentro do processamento de
um documento XML. Sua principal tarefa é a de garantir que tais documentos sejam
válidos4 ou, pelo menos, bem-formados5. Pelo fato de um documento XML ter de ser
bem-formado e/ou válido para funcionar apropriadamente, o analisador sintático
desempenha um papel fundamental na implementação de uma solução XML. Alem
disso, qualquer aplicativo que esteja preparado para entender XML possui um
analisador sintático embutido para garantir pelo menos sua boa formação (ou seja, que
ele seja bem-formado) e, quem sabe, sua validade. Normalmente, estes analisadores
sintáticos apenas verificam se um documento é bem-formado, entretanto, mesmo que
esse tipo de abordagem poupe tempo de processamento e energia, há uma pressuposição
que o criador do documento aderiu rigorosamente às regras estabelecidas pelo DTD
quando o documento foi construído.
A análise sintática não é uma novidade para o mundo do SGML;
conseqüentemente, quando a XML foi criada pela primeira vez, havia um bom número
de analisadores sintáticos SGML existentes para analisar documentos XML. Entretanto,
4
Documentos válidos são aqueles que satisfazem as regras especificadas em uma DTD.
Um documento é dito bem-formado, se ele respeita as regras básicas impostas pela
recomendação XML
5
22
normalmente eles eram muito grandes e lentos para processarem um documento XML
adequadamente e foram escritos para trabalharem com software SGML proprietário em
uma única plataforma.
Eis alguns analisadores:
Analisador
Fornecedor
Linguagem
Tipo
Versão
Aelfred
Microstar(Opentext)
Java
Não valida
1.1
Expat
James Clark
C
Não valida
N/D
Lark
Textuality
Java
Não valida
1 beta final
Larval
Textuality
Java
Valida
0.8
MSXML
Microsoft
Java
Valida
4.8
TclXML
Steve Ball
Tcl
Não valida
N/D
Xparse
Jeremie
JavaScript
Não valida
0.91
Xmlproc
Lars M. Garshol
Python
Não valida
0.3
XP
James Clark
Java(JDK 1.1)
Não valida
Alfa
Tabela 1: Analisadores Sintáticos
O analisador sintático lê as marcas de elementos e todos os demais componentes
do documento, verificando para ter certeza de que a estrutura gramatical do documento
atenda aos padrões da especificação XML. Se houver problemas com a gramática, o
processador relatará erros. Sem algum tipo de processo de verificação para que seja
usada a sintaxe XML adequada em um documento XML ou DTD, não haveria nenhum
mecanismo para alertar, aos programadores, a respeito de erros sintáticos ou estruturais.
Os documentos XML podem ser analisados sintaticamente de várias formas e
com uma série de produtos. Normalmente, a análise sintática é feita no cliente, o que
significa que o servidor que está enviando os dados e documento XML para o cliente
faz pouco ou nada em relação à análise sintática dos dados. E embora possamos assumir
que essa análise seja feita quando o processamento do documento XML começa, ela
pode acontecer em qualquer ponto do processo. Podemos analisar sintaticamente um
documento, processá-lo e depois analisar os links contidos dentro dele em um nível
secundário.
O produto ou método a ser usado para analisar sintaticamente ou quando o
documento deve ser analisado fica quase que inteiramente a critério do desenvolvedor.
De um modo geral, os analisadores citados na Tabela1 se dividem em aplicativo para
23
exibição final e componentes de software distintos que carregamos em nosso
computador e usamos para avaliar os arquivos XML. Pode-se, ainda, encontrar alguns
na Internet. A Microsoft, por exemplo, oferece um analisador sintático para Java,
chamado MSXML, que é, na verdade, uma biblioteca de código Java (aceito no Internet
Explorer 4 e 5).
O analisador compara o código no documento XML com as regras estabelecidas
antecipadamente na especificação XML. Ele deve estar apto a ler caracteres Unicode de
8-bits e 16-bits e entidades de caracteres. O analisador também lê o documento XML
interno antes de interpretar DTDs internas ou externas. Isso garante que as declarações
locais serão processadas antes das externas. Se houver comentários armazenados no
interior do documento ou da DTD externa, a maioria dos analisadores sintáticos irá
ignorá-los, mas alguns irão relatar o contexto do texto do comentário. Quando o
analisador sintático encontra um atributo que não esteja definido na DTD, será gerado
um erro, dependendo do tipo de analisador usado.
Um analisador sintático também enviará os nomes de aplicativos XML e os
identificadores externos das notações. Ao encontrar uma entidade, um analisador
sintático alerta o aplicativo XML sobre a existência de várias declarações de entidades.
O analisador também informa ao aplicativo onde aconteceram referências a entidade e o
nome da entidade. O analisador sintático substitui a referência pelo caractere ou texto
verdadeiro, e passa essas informações ao aplicativo.
Quando o analisador sintático esta interpretando as informações do documento
XML e/ou DTD, ele repassa informações especificas para o próximo aplicativo. Embora
o desenvolvedor tenha de verificar a existência de eventuais erros em seu documento, os
analisadores sintáticos exibirão erros de modo a auxiliar o programador. O aplicativo
analisador sintático faz tudo isso.
Os analisadores sintáticos assumem a forma de algum tipo de biblioteca de
código normalmente escrita em C++ ou Java. Tanto o Netscape Navigator quanto o
Microsoft Internet Explorer usam analisadores sintáticos Java e C++. Esses analisadores
são, na realidade, constituídos por uma biblioteca de código que contém toda a
programação necessária para analisar documentos XML válidos e bem-formados.
Os analisadores sintáticos também podem ser aplicativos dedicados a partir dos
quais especifica-se o arquivo a ser analisado e depois se obtém o resultado do processo
de análise sintática.
24
3.1.3.2.1 – AElfred
ƒ
Fornecedor: Microstar
ƒ
Linguagem: Java
ƒ
Tipo: não efetua validação
ƒ
Versão: 1.1
ƒ
O que diz o fornecedor: “Desenvolvemos o AElfred para programadores
Java que querem acrescentar suporte a XML em suas applets e aplicativos sem dobrar o
seu tamanho: o AElfred consiste apenas de dois arquivos de classes centrais com um
tamanho total de cerca de 26 k e requer uma quantidade muito pequena de memória
para ser executado”.
Este compacto analisador sintático não efetua validação; portanto, ele verificará
os documentos apenas em termos de boa formação, mas seu objetivo principal é o de
fornecer aos programadores Java um mesmo tipo de implementação XML.
3.1.3.2.2 – MSXML
•
Fornecedor: Microsoft
•
Linguagem: Java
•
Tipo: efetua validação
•
Versão: 1.8
•
O que diz o fornecedor: “O Microsoft XML Parser é um analisador sintático
XML escrito em Java que efetua validação. O analisador verifica se os
documentos são bem-formados e, opcionalmente, permite verificar a
validade dos documentos. Assim que for analisado sintaticamente, o
documento XML será exposto em uma estrutura em forma de árvore por
meio de um conjunto simples de métodos Java. Esses métodos suportam
leitura e/ou gravação das estruturas XML como o CDF – Channel Definition
Format
ou
outros
formatos
de
textos
baseados
no
XML
e,
conseqüentemente, habilidade na construção de aplicativos usando o XML”.
O analisador sintático da Microsoft MSXML é freeware, mas executado
funciona bem apenas em PCs rodando Windows 95/98 ou NT. MSXML é um
25
analisador que efetua validação e foi construído para trabalhar com outras tecnologias
da Microsoft, que não serão mencionadas neste trabalho.
3.1.3.3 – Processadores ou Parsers
Depois de o documento ter sido analisado sintaticamente, um processador XML
assume o comando. Ele lê o documento e oferece a outros aplicativos acesso aos
componentes XML armazenados dentro do documento XML. Um processador poderia
ser um aplicativo de pesquisa usado para recuperar informações contidas em um banco
de dados ou, no caso de Mathematical Markup Language (MathML, um aplicativo
XML), um processador poderia utilizar os resultados do documento XML analisado
sintaticamente, processar as informações por meio de um aplicativo estatístico e
repassar os resultados para um outro visualizador que permitisse ao cliente ver os
resultados. Um processador poderia também simplesmente repassar os resultados do
arquivo analisado sintaticamente para um navegador e deixar que o navegador mostre os
dados.
Quando um processador intercepta as informações analisadas sintaticamente, os
desenvolvedores de software podem acessar rapidamente a estrutura de um documento
XML e trabalhar com os componentes de várias formas (como mostra a Figura 2.4.1).
Todos os elementos, atributos, entidades e notações são então considerados objetos que
podem ser manipulados, ainda, por outros programas. Cada ferramenta de
desenvolvimento XML terá um analisador sintático XML em seu núcleo. Depois de um
documento ter sido analisado sintaticamente, os desenvolvedores podem pegar essas
informações e usar editores, navegador e banco de dados adicionais para pesquisarem
ou extraírem objetos XML do documento analisado sintaticamente. Os diversos objetos
XML analisados sintaticamente podem ser então referenciados, manipulados ou
exibidos usando linguagens de programação ou navegadores adicionais.
26
Especificação
Documento
Analisador
Apl. A
Documento
Usuário
Apl. B
Processador
Apl. C
Internet
Apl. D
Figura 3.1.1: Arquitetura do Processo de um Documento XML
Como a maioria dos analisadores sintáticos e processadores XML, o papel do
processador, na verdade, se sobrepõe ao papel do analisador. O analisador é responsável
pela checagem da sintaxe do documento XML ou DTD e o processador é responsável
pelo fornecimento de acesso ao conteúdo e estrutura do documento.
3.1.3.4 - Application Programming Interfaces (API’s)
As APIs (interfaces de programação de aplicativos) são ferramentas que
funcionam com processadores XML. Algumas APIs podem ser incluídas no
processador para fornecer funcionalidade e serviços de processamento adicionais. Além
dos vários processadores e analisadores sintáticos XML, kits de APIs para o XML vêm
surgindo recentemente. Com um kit de API pode-se usar módulos para processar
documentos XML bem-formados de várias maneiras. Por exemplo, pode-se usar
determinados módulos de API para ordenar dados contidos em um documento XML.
Alguns módulos de API talvez possam permitir que se criem relatórios a partir de uma
fonte de dados XML e outros módulos poderiam ajudá-lo a converter documentos
HTML em XML limpando o código HTML de forma que o arquivo pudesse funcionar
como um documento XML. Os dois tipos de API’s que serão mencionados neste são:
DOM e SAX.
27
3.1.3.4.1 – Características do DOM?
Para explicar ainda mais como o processamento XML funciona, vamos subir um
degrau nessa escalada de aprendizado e discutir algo que para algumas pessoas pode
parecer um tanto confuso – o DOM. O que é um DOM? É uma maneira de
descrevermos um documento XML para um outro aplicativo ou linguagem de
programação em uma tentativa de manipular ainda mais as informações da maneira que
desejamos. Podemos usar o DOM para inserir fontes de dados XML com navegadores.
Entretanto, mais especificamente, podemos usá-lo para coletar informações sobre a
estrutura de um documento XML e depois usar essas informações para criar conexões
entre a estrutura do documento e outros aplicativos ou fontes de dados.
Uma maneira relativamente fácil de usarmos o DOM é por meio de linguagens
de script como, por exemplo, o JavaScript ou VBScript, para carregar um documento
XML, manipulá-lo e enviar os dados ou resultados para um outro aplicativo.
Dependendo do aplicativo e da linguagem de script usada, podemos até mesmo usar o
DOM para exibir o conteúdo do arquivo XML ou para fornecer um mecanismo para
pesquisar o documento XML.
Pode-se criar um documento XML e carregá-lo no navegador Internet Explorer
criando um objeto ActiveX e usando o método Load para carregar o documento. Assim
que ele for carregado, pode-se então navegar ou apontar para qualquer componente
contido no documento bastando iniciar no elemento-raiz que é normalmente chamado
de nó-raiz.
O nome foi escolhido porque segue a designação original de orientação à objeto
(daí o nome “Object Model”). São documentos modelados usando objetos, e o modelo
DOM não se refere apenas à estrutura do documento, mas também no comportamento
do mesmo e seus objetos. Em outras palavras:
•
a interface e objetos usados para representar e manipular um documento;
•
a
semântica
dessas
interfaces
e
desses
objetos
–
incluindo
comportamentos e atributos de ambos;
•
os relacionamentos e colaborações entre essas interfaces e objetos.
No DOM, documentos têm uma estrutura lógica, a qual é muito mais que uma
“árvore”, é uma “floresta”. Cada documento contém: zero ou um Doctype, um elemento
raiz e zero ou mais conteúdos ou restrições de processamento. O elemento raiz do
documento é considerado a raiz da árvore. Entretanto, DOM não especifica que
28
documentos devem ser implementados, nem especifica como os relacionamentos entre
os objetos devem ser implementados. DOM é um modelo lógico, que deve ser
implementado em vários gerenciamentos convenientes. A partir de agora, chamaremos
de “Structure Model” o nome que descreve a árvore como a representação do
documento.
A estrutura em forma de árvore do XML possibilita que você recupere
rapidamente as informações ou componentes XML de que você precisa. Tudo na árvore
é um objeto, desde o primeiro nó-raiz até o valor de uma entidade. O fato de você estar
habilitado a navegar por essa árvore lhe permite a recuperação de informações
importantes no que diz respeito à fonte de dados.
DOM, apesar do nome, não é o competidor do COM (Component Object
Model), também chamado CORBA. COM, por sua vez, é uma linguagem independente
para especificações de objetos e interfaces, DOM é um conjunto de interfaces e objetos
designados para gerenciamento de documentos HTML e XML. DOM deve ser
implementado usando linguagem independente (como a IDL usada no CORBA), mas
também pode ser implementado usando linguagens específicas, como Java ou
ECMAScript bindings.
Para um melhor entendimento de como o DOM funciona em relação ao XML,
utilizar-se-á o exemplo de como um script simples, usado no Internet Explorer 4,
consegue acessar o XML. Depois do programador estar habilitado a acessar os objetos
necessários, pode-se usar JavaScript para exibir os resultados finais em uma página
Web.
Primeiramente, deve-se saber que o DOM usa três objetos para acessar o arquivo
XML:
•
O documento XML.
•
O nó XML.
•
A lista de nós XML.
Supõe-se o documento XML um objeto. Esse objeto, embora represente todo o
documento-fonte XML, pode ser acessado por meio de um script. Esse script pode ser
colocado em uma página Web. O script pode carregar o documento XML, pois para a
linguagem de script, ele é apenas um objeto. Pode-se ter o documento carregado criando
um objeto ActiveX e usando o método load (uma chamada via script disponível para
objetos ActiveX). Pelo fato de o XML exigir que seja seguido um padrão estruturado
para formação de documentos XML, o DOM pode acessar qualquer documento XML e
29
o documento representa um objeto que pode ser manipulado. Teoricamente, isso
significa que você poderia usar e reutilizar script para acessar documentos XML e, pelo
fato de a estrutura dos documentos XML seguirem um padrão com algumas pequenas
alterações, seu script se aplicaria a praticamente qualquer documento XML.
O documento XML, conforme definido no DOM, consiste do elemento-raiz
juntamente com todos os seus descendentes. Por exemplo, o código a seguir,
<JORNAL> é o elemento-raiz e o restante dos elementos, como <SECAO>, são
considerados seus descendentes ou filhos. Isso significa que o objeto documento XML
inteiro é todo o código contido em:
<JORNAL>
<SECAO>
<TEXTO>
</TEXTO>
</SECAO>
</JORNAL>
O objeto nó representa um nó dentro de um documento XML. O que vem
a seguir é considerado um nó no Internet Explorer 5:
•
Elemento
•
PCDATA
•
Comentário
•
!DOCTYPE
•
Quaisquer instruções de processamento
•
Seções CDATA
•
Espaços de nomes
•
ENTITYREF
•
Espaços em branco
•
Atributos
•
A declaração XML
A lista de nós no modelo de documento XML representa um conjunto de nós. Há
várias propriedades e métodos usados na lista de nós XML:
30
•
Propriedades – Length
•
Métodos – CurrentNode, Item, MoveTo, MoveToNode, NextNode,
previousNode.
DOM especifica interfaces que podem ser usadas para gerenciamento tanto de
documentos XML como HTML. É importante entender que essas interfaces são uma
abstração – muito mais que “abstract base classes” em C+±, eles são um significado de
especificação da maneira de acessar e manipular representações internas da aplicação do
documento. Interfaces não implicam em implementação concreta particular. Cada
aplicação DOM é livre para manter documentos em qualquer representação
conveniente, enquanto as interfaces mostradas nessas especificações são suportadas.
Documento
XML
Aplicação para
documento XML
Parser
DOM
Estrutura em forma de árvore
Figura 3.1.2: Arquitetura do Processo de Utilização do DOM
O motivo pelo qual há especificações de interfaces e não objetos reais que estão
sendo criados é porque DOM não pode saber qual construtor chamar par fazer uma
implementação. Em geral, DOM usa o método Create( ) em sua classe de documentos
para criar estruturas de documento, e a implementação DOM cria representações
internas dessas estruturas (na utilização da função Create( )).
31
Há ainda uma característica importante do DOM, é que aplicações com DOM
devem fornecer interfaces adicionais e objetos não encontrados em sua especificaçao6 e
ainda ser considerado complacente com DOM.
Na especificação da W3C, temos a seguinte divisão:
•
DOM Levei 1: é intensionalinente limitada para aqueles métodos necessários
para representar a manipulação de estruturas e conteúdos de documento.
•
DOM Levei 2: especifica recursos para navegação e manipulação de
estrutura e conteúdo de documento XML e HTML.
•
DOM Levei 3: há um acréscimo de recursos como CSS e “Style Sheets”.
O Microsoft XML parser é um componente que acompanha o Internet Explorer
5.0. Uma vez instalado o IE 5.0, o parser é eficaz com alguns tipos de documentos,
como:
•
JavaScript, VBScript, Perl, VB, Java, C+-i- e outros;
•
XML 1.0 da W3C e XML DOM;
•
DTD e validação.
•
Exemplo de uma aplicação DOM usando JavaScript:
<script type=”text/javascript”>
var text= “<note>”
text=text+”<to>Tove</to><from>Jani</from>”
text=text+”<heading>Reminder</heading>”
text=text+”<body>Don’t forget me this weekend!</body>”
text=text+”</note>”
var xmlDoc=new ActiveXObject(“Microsoft.XMLDOM”)
xmlDoc.async=”false”
xmlDoc.loadXML(text)
// …… o processamento do documento vai aqui
</scrip>
6
Existem vârias especiftcações para DOM, tais especificações são construidas por empresas diferentes
abrangendo linguagens diferenciadas. Atualmente, a especificação mais usada é a da W3C.
32
Segue-se então a seguinte aplicação
<html>
<body>
<script language=”javascript”> var xmlDoc= new
ActiveXObject(”Microsoft.XMLDOM”)
xmlDoc.async=”false”
xmlDoc.load(”note.xml”)
document.write
(“The first XML element in the file contains: “) document.write
(xmlDoc.documentElement.childNodes.item(0).text)
</script> </body> </html>
Apenas trocando o índice da expressão:
(xmlDoc.documentElement.childNodes.item(0) .text)
podemos obter as seguintes respostas:
Item 0= “The first XML element in the file contains: Tove”
Item 1= “The first XML element in the file contains: Jani”
Item 2= “The flrst XML element in the file contains: Reminder”
Item3 = Item 3=“The first XML element in the file contains: Don’t forget me
this weekend!”
3.1.3.4.2 – Como se caracteriza o SAX?
O fato de muitos processadores XML estarem disponíveis atualmente libera o
programador para dedicar-se às necessidades específicas de suas aplicações. Entretanto,
a maioria dos processadores não utiliza um formato padrão para apresentação, para as
aplicações, do resultado de seu trabalho. Isso pode implicar dificuldades para se utilizar
um determinado processador e inconveniências quando se desejar trocar de processador.
A Simple API for XML, SAX, é uma interface Java simples que os processadores podem
utilizar. Um processador SAX é, então, uma classe que implementa a interface
33
org.xml.sax.Parser. O parser, ao percorrer a árvore de nós do documento XML, realiza
chamadas para os métodos implementados pela aplicação.
A interface SAX pode ser utilizada por aplicações que realizam tarefas
relativamente simples ou que necessitam processar os documentos de modo seqüencial
(por exemplo, no caso do documento não estar todo disponível quando do inicio do
processamento da aplicação). No caso em atividades mais elaboradas são necessárias e,
ainda, todo o documento está disponível para processamento a priori, o modelo DOM,
descrito anteriormente e estudado há algum tempo, pode ser utilizado.
Para criar uma aplicação SAX, simples, baseada em Java, é preciso fazer
o download e instalar no mínimo as bibliotecas do Java. O desenvolvedor deve ter
certeza de que todas elas foram adicionadas em seu CLASSPATH:
1.
as inerfaces e classes do SAX
2.
no mínimo um Parser XML que suporte SAX
Antes de começar, é preciso anotar o caminho completo do CLASSPATH do
driver SAX para o parser (para Aelfred, é com.microstar.xml.SAXDriver). Depois,
deve-se criar pelo menos um evento handler para receber informação sobre o
documento. O tipo mais importante de handler é DocumentHandler, que recebe eventos
do começo ao fim dos elementos, caracteres, instruções de processamento e outras
estruturas básicas XML.
Mais importante que a implementação da interface como um todo, deve-se criar
uma classe que extende HandlerBase, e então, criar os métodos que são necessários. O
exemplo abaixo (MyHandler.Java) imprime uma mensagem cada vez que um elemento
começa ou termina:
import org.xml. sax.HandlerBase;
import org.xml.sax.AttributeList;
public class MyHandler extends HandlerBase {
public void startElement (String name, AttributeList atts) {
System.out.println(“Start element:” + name);
}
public void endElement (String name) {
System.out.println(“End element:” + name);
}
}
34
Agora, pode-ser criar uma aplicação simples (SAXApp.Java) para invocar o
SAX e processar um documento usando o Handler.
import org.xml.sax.Parser;
import org.xml. sax.Documentllandler;
import org.xml.sax.helpers.ParserFactory;
public class SAXApp {
static final String parserClass = “com.microstar.xml.SAXDriver”;
public static void main (String args[])
throws Exception
{
Parser parser=ParserFactory.makeParser(parserClass);
DocumentHandler handler=new MyHandler();
parser.setDocumentHandler(handler);
for (int i =0; i <args.length; i++) {
parser.parse(args[i]);}
}
}
Este exemplo cria um objeto parser para suprir o nome de uma classe para o
ParserFactory, instancia a classe MyHandler, registra o handler com o parser, então
processa toda a URL suprida sob o comando line (note que a URL deve ser absoluta).
Por exemplo, considere o documento abaixo, chamado roses.xml:
<?xml version=” 1.0”?>
<poem>
<line>Roses are red,</line>
<line>Violets are blue.</line>
<line>Sugar is sweet,</line>
<line>and 1 love you.</line>
</poem>
Para processá-lo com a aplicação SAXApp, você deve fornecer uma URL
absoluta do documento na linha de comando:
java SAXApp file://localhost/tmp/roses.xml
35
A saida será a seguinte:
Start element: poem
Start element: line
End element: line
Start element: line
End element: line
Start element: line
End element: line
Start element: line
End element: line
End element: poem
36
3.2 - Estudo das Linguagens que dão Suporte à Representação de Documentos XML
Nesta seção serão estudadas as linguagens que dão suporte à representação de
documentos XML: XSL (eXtensible Style Language) e CSS (Cascading Style Sheets).
Ambas foram criadas a partir de especificações XML.
Para que se possa entender a importância de XSL e CSS, deve-se ter em mente
as diferenças entre linguagens de formatação e linguagens de marcação.
Nas linguagens de formatação, a inserção dos estilos de apresentação dos
documentos se dá no próprio arquivo; assim para fazer alguma mudança na aparência
deste, deve-se primeiro abri-lo para então efetuar as modificações, mudando, assim,
todo o seu conteúdo. Do mesmo modo, esses estilos não podem ser aplicados a partes
específicas dos documentos; logo as linguagens de formatação, embora suportem a
criação de vários estilos, não são capazes de atender uma formatação mais complexa.
Nas linguagens de marcação, por outro lado, há uma estruturação no documento
para a aplicação de estilos. O conteúdo é tratado pelo que se chama de folhas de estilo,
que através de regras de formatação, descrevem como várias partes do documento serão
apresentadas. Estas regras localizam-se em um arquivo separado, ou seja, o conteúdo é
separado da apresentação. Neste caso, para mudar uma fonte ou o tamanho da fonte, por
exemplo, não é necessário mudar o conteúdo do documento. Em XML, a marcação
governa o conteúdo e a estrutura, ao passo que as folhas de estilo associadas comandam
como o conteúdo e a estrutura serão apresentados ao usuário [PIT00]. Daí a importância
de XSL e CSS.
As principais vantagens do uso de folhas de estilo são:
- uma única folha de estilo pode ser aplicada a vários documentos;
- o fato de a marcação ser separada da apresentação de estilos, facilita a criação
das regras de estilo;
- várias folhas de estilo podem ser aplicadas a vários documentos.
Em síntese, o objetivo de XSL e CSS é tratar exclusivamente da tarefa de
formatação especificada pelas folhas de estilo que o desenvolvedor cria.
37
A ferramenta aqui utilizada para a construção dos documentos XML será
XMLSpy 3.5 e o browser para a visualização desses documentos será o Internet
Explorer 5.0.
3.2.1 - CSS (Cascading Style Sheets)
É a linguagem de estilo utilizada tanto em HTML quanto em XML. Porém,
como os navegadores que lêem XML estão restritos a poucos usuários, ou seja,
enquanto espera-se a integração do XML no mundo da
Web, o mais comum é
utilizar a CSS em documentos HTML gerados a partir de documentos XML com XSL.
3.2.1.1 – Cascata
É a força da CSS. As folhas de estilo estão em cascata quando há uma ordem de
preferência para o browser aplicar as regras de estilo. Nesta ordem, as regras que
tiverem maior prioridade serão aplicadas primeiro.
3.2.1.2 - Conceitos Básicos
- Estilos
Um estilo (também chamado de regra de estilo) é formado por um seletor e uma
ou mais declarações => estilo = seletor + declaração. Do mesmo modo uma declaração
é formada por uma propriedade e seu determinado valor =>declaração = propriedade +
valor. Exemplo:
H1 { color: blue }
Neste exemplo, ajusta-se a cor de um elemento 'H1' (seletor) para azul
(declaração).
- Agrupamento
Para simplificar as folhas de estilo, pode-se usar a propriedade chamada
Agrupamento. Ela é usada quando há um grupo de seletores que compartilham a mesma
declaração ou vice-versa. Exemplo:
H1 { font-family: helvetica }
38
H2 { font-family: helvetica }
=
H1, H2, H3 { font-family:
helvetica}
H3 { font-family: helvetica }
H1 { font-family: helvetica }
H1 { font-weight: bold }
= H1 { font-family: helvetica ;
H1 { font-size: 12pt }
font-weight: bold;
H1 { line-height: 14pt }
font-size: 12pt;
H1 { font-variant: normal }
line-height: 14pt;
H1 { font-style: normal}
font-variant: normal;
font-style: normal; }
OBS: Algumas propriedades possuem suas próprias regras de agrupamento.
Exemplo, a propriedade background combina seus valores em uma única declaração:
Autor { background_color
: white;
{cor do fundo}
background_image
: url(myback.gif);
{imagem do fundo}
background_repeat
: repeat -x;
{repetição de fundo}
background_attachment : fixed;
background_position
: 50%; }
{posição de fundo}
Esta folha de estilo tem o mesmo valor de
Autor {background: white url(myback.gif) repeat –x fixed 50%}
- Seletor 'Classe'
O atributo CLASS é usado como um seletor para criar várias instâncias da
mesma marca, cada uma com sua própria regra de estilo. A sintaxe usada é a seguinte:
seletor.classe : {propriedade : valor}
<MARCA CLASS = “string”>...</MARCA>
onde “string” é igual ao nome da classe dado após o nome do elemento na regra
de estilo.
O exemplo a seguir mostra um caso onde é necessário criar dois tipos de títulos,
um sendo o título do livro e o outro sendo o título do capítulo:
TITLE.livro {color
font
: navy;
: 36 pt Arial;
background-color : teal;
border-style
: double;
39
margin-top
: 5%;
margin-left
: 10%;
margin-right
: 10%; }
TITLE.capitulo {color
font
: teal;
: 18 pt Arial;
background-color : navy;
border-style
: groove;
margin-left
: 15%;
margin-right
: 15%; }
A marcação abaixo especifica as regras de estilo para o titulo do livro e dos
capítulos, respectivamente:
<TITLE CLASS = “livro”> Esse é o titulo do livro. </TITLE>
<TITLE CLASS = “capitulo”> Esse é o titulo do capitulo. </TITLE>
Se esta tag TITLE for usada sem que seja especificada uma classe, nenhuma das
regras de estilo será chamada.
OBS: Quando se usa uma classe como seletor ao trabalhar com CSS e XML, é
necessário declarar CLASS como um atributo para cada marca para que o analisador
sintático possa reconhecê-la.
3.2.1.3 - Como criar uma folha de estilo externa
Primeiro cria-se um documento externo em qualquer editor de texto (neste caso
foi utilizado o Notepad). Em seguida, criam-se os estilos (seletores + declarações). Este
arquivo deve ser salvo com a extensão .css e também deve ser salvo como documento
de texto. Esta folha de estilo deve estar explícita no documento XML. Para tanto usa-se
a seguinte sintaxe:
<?xml-stylesheet type=”text/css” href=”endereço.css”?>
Abaixo segue-se um exemplo:
Documento XML
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE RAIZ SYSTEM
"C:\Meusdocumentos\Exemplos\Exemplo5\Exemplo5.dtd">
<?xml-stylesheet type="text/css"
40
href="C:\Meusdocumentos\Exemplos\Exemplo5\Exemplo5.css"?>
<RAIZ>
<ASSUNTO>
<ALUNA> Beatriz Langiano </ALUNA>
<CURSO> Ciência da Computação </CURSO>
<UNIVERSIDADE>Universidade Estadual de
Maringá</UNIVERSIDADE>
</ASSUNTO>
</RAIZ>
Folha de Estilo (Exemplo.css)
ASSUNTO{font-style:italic; font-size:12pt }
ALUNA {display : inline; background: #db70db }
CURSO {display : block; position:relative; left:100px; font-weight:bold}
UNIVERSIDADE {display : block; color:red; font-family:Courier New; text-
Resultado final:
Beatriz Langiano
Ciência da Computação
Universidade Estadual de Maringá
3.2.2 - XSL (eXtensible Style Language)
Antes de iniciar o estudo da linguagem XSL, é conveniente fazer uma
introdução à linguagem XPath, uma vez que a sintaxe de XPath é amplamente utilizada
na criação das folhas de estilo XSL.
3.2.2.1 – Xpath
41
XPath é a linguagem para endereçar partes de um documento XML, projetada
para ser usada por linguagens, tais como XLink, Xpointer, XSL e XQL. Ela também
fornece facilidades básicas para manipulação de strings, números e valores booleanos.
Este endereçamento é feito através de uma navegação pela estrutura hierárquica do
documento [W3C 01g].
XPath modela o documento XML como uma árvore de nós. Há diferentes tipos
de nós: elementos, atributos e textos. XPath define um caminho para cada um deles.
- Caminhos para localização de nós
Abaixo segue-se uma alguns dos itens de uma sintaxe abreviada de caminhos
para localização de nós:
•
x
Seleciona o elemento x, filho do nó atual.
•
*
Seleciona todos os elementos filhos do nó atual.
•
@*
Seleciona todos os atributos do nó atual.
•
x[1]
Seleciona o primeiro filho x do nó atual.
•
x[last()]
Seleciona o último filho x do nó atual.
•
/doc/chapter[5]/section[2]
Seleciona o segundo elemento section do quinto elemento chapter do
elemento doc.
•
.
Seleciona o nó atual.
•
.//x
Seleciona os elementos x, filhos do nó atual.
•
..
Seleciona o pai do nó atual.
•
x[@type="warning"][5]
Seleciona o quinto filho x do nó atual, que tem um atributo type cujo valor é
warning.
•
chapter[title]
42
Seleciona os elementos chapter filhos do nó atual, que tem um ou mais filhos
title.
•
employee[@secretary and @assistant]
Seleciona todos os elementos filhos do nó atual, que têm os atributos
secretary e assistant.
3.2.2.1.1 - Criando expressões em Xpath
•
Identificando o nó atual
À medida que o processador percorre a folha de estilo e o documento XML, ele
processa um nó de cada vez. Normalmente, é mais fácil especificar o que deve ser
processado em seguida, em relação ao nó atual, ou seja, o nó onde o processador está
trabalhando agora [CAS01].
Por padrão, o nó atual é especificado no modelo pelo atributo match. Se existe
uma instrução xsl:apply-templantes, o nó atual torna-se o que é especificado pela
instrução. Quando retorna-se daquela expressão, o nó atual reverte para o valor do
atributo match do modelo anterior. Por outro lado, se existe uma instrução xsl:for-each,
o nó atual fica sendo o especificado pelo atributo select da instrução. No término da
instrução, o nó atual volta a ter seu valor anterior. Abaixo segue-se um exemplo:
<xsl:template match=”/”>
<html><head><title>Endangeres
Species</title></head><body
bgcolor
=”white”>
<xsl:apply-templantes select =”endangered-species/animal”/>
</body> </html> </xsl:template>
<xsl:template match=”animal”>
<p align=”center”>
<br/><font size=”+3”><xsl:apply-templates select =”name”/></font></p>
<table width = “100%” border = “2”>
<tr><th>
Subspecies
</th><th>Region</th><th>Number
Left</th><th>As
of</th></tr>
<xsl:for-each select=”subspecies”>
<xsl:sort select =”population” data-type = number/>
Neste início, o nó atual é o nó raiz, conforme especificado pelo modelo.
43
Depois, o nó atual torna-se o primeiro elemento “animal” contido no elemento
“endangered-species”. Depois que o primeiro elemento “animal” for processado, o
segundo elemento “animal” torna-se o nó atual, e assim por diante, até que todos os
elementos “animal” sejam processados.
No quarto modelo, o primeiro elemento “name” no elemento animal sendo
processado, torna-se o nó atual. Não é mostrado, mas depois teriam os modelos “name”,
e o segundo elemento “name” seria processado, e assim por diante.
Após o processamento dos elementos “name”, o nó atual volta a ser o elemento
animal, até que se chegue à instrução xsl:for-each. Neste ponto, o nó atual torna-se o
primeiro elemento “subspecies” no nó animal atual. Então o segundo elemento
“subspecies” é processado, e assim por diante, até terminar todos.
•
Selecionando o filho de um nó
Caso o filho desejado seja o filho do nó atual, então é necessário somente digitar
o nome do filho. Senão, digita-se /nome-do-filho
até chegar ao nível desejado.
Exemplo:
<xsl:for-each select = “subspecies”>
<xsl:sort select =”population” data-type = “number”/>
<xsl:sort select = “population/@year” data-type = “number”/>
<tr><td><xsl:apply-templates select = “name”/> </td>
<td><xsl: value-of select = “region”/> </td>
<td><xsl:apply-templates select =”population”/></td>
Quando a instrução xsl:for-each é processada, o elemento subspecies torna-se o
nó atual. O atributo select na primeira instrução xsl:sort seleciona todos os nós
population que sejam filhos do nó subspecies sendo processado. O atributo select na
primeira instrução apply-templates pesquisa todos os nós name que sejam filhos do
elemento subspecies.
•
Selecionando todos os descendentes
Neste caso, tem-se quatro situações:
- para selecionar todos os descendentes do nó raiz, usa-se as duas barras “//”
44
- para selecionar todos os descendentes do nó atual, usa-se um ponto seguido
pelas duas barras “.//”
- para selecionar todos os descendentes de qualquer nó, primeiro deve-se chegar
até este nó, para então usar as duas barras “//”
- para selecionar alguns descendentes de qualquer nó, primeiro cria-se o
caminho para chegar a tal nó, para então usar as duas barras seguidas de um ponto“//.” e
digitar o nome dos elementos descendentes desejados
•
Desconsiderando o nó atual
Para desconsiderar o nó atual ao escrever o caminho a partir da raiz, deve-se
digitar / (barra) e depois o nome do elemento raiz do documento XML; digita-se
novamente / para indicar uma descida no nível hierárquico do documento e o nome do
elemento no nível seguinte que contém o elemento desejado, repetindo estes últimos
passos até chegar ao elemento desejado. Exemplo:
<xsl:for-each select = “/endangered-species/animal/subspecies
Aqui , obteve-se o elemento animal a partir da raiz.
•
Selecionando os atributos de um nó
Para especificar o eixo dos atributos é usado o símbolo @. Para selecionar o(s)
atributo(s) do nó, digita-se /@nome-do-atributo. Exemplo:
<xsl:value-of select = “population/@year”/>
Neste caso, foi selecionado o atributo year do elemento population.
3.2.2.2 - XSL (eXtensible Style Language)
A HTML, com o seu conjunto de tags pré-definidas, facilita a apresentação das
páginas através de qualquer browser. Com XML esta tarefa torna-se mais complicada,
pois pode-se construir as próprias tags que fazem sentido no contexto em que se está
trabalhando, mas que não têm qualquer significado em nível de apresentação [BUS00].
Desde o início da criação do padrão XML percebeu-se que para ter estes
documentos na Web era necessário criar um padrão que explicasse como as novas tags
deveriam ser apresentadas. Assim surgiu XSL, um padrão que permite definir atributos
45
de apresentação das tags definidas no documento XML. O documento que contém a
especificação em XSL costuma ser designado por folha de estilo (style sheet). Este
documento, além de definir a apresentação, contém ainda regras de como um
documento deve ser apresentado conforme a interação do usuário com a página. Em
XSL, as folhas de estilo obedecem às mesmas regras de XML, ou seja, requerem DTDs,
e atuam de maneiras similares (um documento XSL é um documento XML válido)
[BUS00].
Diferentemente de CSS, XSL não possui o recurso de cascata; deste modo,
quando um elemento atende a mais de um estilo, a regra de construção que contém o
padrão mais específico é a que será aplicada. Por exemplo, uma regra de construção que
especifique um elemento título contido dentro de um cabeçalho de capítulo tem
precedência em relação a uma que apenas especifique elementos sem quaisquer
definições de conteúdo ou contexto adicionais. Ambas as regras de construção poderiam
ser legalmente aplicadas a títulos encontrados dentro de elementos capítulo, porém a
primeira é mais específica e, conseqüentemente, é a regra aplicada.
A conjunção de XML com XSL resulta numa página HTML, de forma que
qualquer browser possa interpretá-la, mas na realidade a página apresentada não reflete
toda a estrutura definida na folha de estilo. Existem partes que só são apresentadas
mediante determinadas ações do usuário o que dá um grande dinamismo às páginas.
Toda a estrutura de apresentação se encontra em uma única página, enquanto que, para
conseguir o mesmo efeito utilizando HTML, cada interação do usuário com a página,
significa uma chamada ao servidor para redesenhar a página [BUS00].
XSL – Mais do que uma folha de estilo
XSL consiste em duas partes:
•
Um método para formatação de documentos XML
•
Um método para transformação de documentos XML
Para entender o significado disto, deve-se considerar XSL como uma linguagem
que pode formatar um dado em XML e uma linguagem que pode transformar um
documento XML em um documento HTML, por exemplo (normalmente XSL faz isto,
transformando cada elemento XML em um elemento HTML).
46
3.2.2.2.1 - Transformando XML em HTML
Exemplo 1: Considere o seguinte DTD correspondente ao exemplo a ser
analisado:
<?xml version="1.0" encoding="UTF-8"?>
<!ELEMENT RAIZ (ASSUNTO+)>
<!ELEMENT ASSUNTO (ALUNA*,CURSO?,UNIVERSIDADE+)>
<!ELEMENT ALUNA (#PCDATA)>
<!ELEMENT CURSO (#PCDATA)>
<!ELEMENT UNIVERSIDADE (#PCDATA)>
Nele temos um elemento raiz chamado RAIZ que contém o elemento
ASSUNTO. Este por sua vez contém os elementos ALUNA, CURSO e
UNIVERSIDADE. O atributo #PCDATA indica texto. Abaixo segue-se o documento
XML que segue às regras desse DTD:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE RAIZ SYSTEM "C:\Meus documentos\Exemplos\
Exemplo5\Exemplo5. dtd">
<?xml-stylesheet type="text/xsl"
href="C:\Meus documentos\Exemplos\Exemplo5\Exemplo5.xsl"?>
<RAIZ>
<ASSUNTO>
<ALUNA>Beatriz Langiano </ALUNA>
<CURSO> Ciência da Computação </CURSO>
<UNIVERSIDADE>Universidade Estadual de Maringá</UNIVERSIDADE>
</ASSUNTO>
</RAIZ>
47
Neste documento, a segunda e a terceira linha referenciam, respectivamente, o
DTD e a folha de estilo correspondente. Seguindo, tem-se todos os elementos com seus
respectivos conteúdos.
Agora considere o documento XSL abaixo como um modelo HTML para
construir um documento HTML com dados em XML:
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/TR/WD-xsl">
<xsl:template match="/">
<html>
<body text = "#238E68">
<title> Aprendendo XML</title>
<head ><b><h1><i>Extensible Markup Language </i></h1></b></head>
<xsl:for-each select="RAIZ/ASSUNTO" >
<p><xsl:value-of select="ALUNA"/><h2></h2></p>
<p><xsl:value-of select="CURSO"/><h3></h3></p>
<p><xsl:value-of select="UNIVERSIDADE"/><h4></h4></p>
</xsl:for-each>
</body>
</html>
</xsl:template>
Visto que uma folha de estilo XSL é por si mesma um arquivo XML, o arquivo
começa com uma declaração xml. O elemento xsl:stylesheet indica que este documento
é uma folha de estilo.
A primeira coisa que um processador pesquisa em uma folha de estilo é um
modelo a ser aplicado ao nó raiz do documento XML. Para tanto, digita-se
<xsl:template (para criar um modelo) e math= “/”> (para indicar o nó raiz). A seguir
tem-se as tags HTML, que são: html, body, title e head. A instrução xsl:for-each
processa todos o nós de um determinado conjunto da mesma maneira, um após o outro.
O termo select=”RAIZ/ASSUNTO” seleciona esse conjunto, que no caso são os
elementos contidos no elemento ASSUNTO, o qual está contido no elemento RAIZ. O
48
elemento xsl:value-of seleciona um filho na hierarquia e insere o conteúdo deste filho
no templante.
Por fim, segue-se o resultado da execução desses documentos:
Extensible Markup Language
Beatriz Langiano
Ciência da Computação
Universidade Estadual de Maringá
Exemplo2: Considere o seguinte DTD correspondente ao exemplo a ser
analisado:
<?xml version="1.0" encoding="UTF-8"?>
<!ELEMENT CATALOGO (CD+)>
<!ELEMENT CD (TITLE, ARTIST, COUNTRY, COMPANY, PRICE, YEAR)>
<!ELEMENT TITLE (#PCDATA)>
<!ELEMENT ARTIST (#PCDATA)>
<!ELEMENT COUNTRY (#PCDATA)>
<!ATTLIST COUNTRY
PAIS (BRASIL | USA) #REQUIRED>
<!ELEMENT COMPANY (#PCDATA)>
<!ELEMENT PRICE (#PCDATA)>
<!ELEMENT YEAR (#PCDATA)>
Nele temos um elemento raiz chamado CATALOGO que contém o elemento
CD. Este por sua vez contém os elementos TITLE, ARTIST, COUNTRY, COMPANY,
PRICE e YEAR. O atributo #PCDATA indica texto. O elemento CONTRY contém um
atributo chamado PAIS que pode ser BRA ou USA.
49
Abaixo, o documento XML que segue às regras desse DTD:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE CATALOGO SYSTEM
"C:\Meus documentos\Exemplos\Exemplo6\Exemplo6.dtd">
<?xml-stylesheet type="text/xsl"
href="C:\Meus documentos\Exemplos\Exemplo6\Exemplo6.xsl"?>
<CATALOGO>
<CD>
<TITLE>Carro Velho</TITLE>
<ARTIST>Ivete Sangalo</ARTIST>
<COUNTRY PAIS="BRASIL">BRA</COUNTRY>
<COMPANY>Continental</COMPANY>
<PRICE >21.80</PRICE>
<YEAR>1999</YEAR>
</CD>
<CD>
<TITLE>Music</TITLE>
<ARTIST>Madonna</ARTIST>
<COUNTRY PAIS="USA">USA</COUNTRY>
<COMPANY>Columbia</COMPANY>
<PRICE >25.50</PRICE>
<YEAR>2000</YEAR>
</CD>
<CD>
<TITLE>Keep on Moving</TITLE>
<ARTIST>Five</ARTIST>
<COUNTRY PAIS="USA">USA</COUNTRY>
<COMPANY>Columbia</COMPANY>
<PRICE >24.00</PRICE>
<YEAR>1998</YEAR>
</CD>
</CATALOGO>
50
Este documento é muito parecido com o documento do exemplo anterior, mas
nesse caso temos, ao invés de um, três instâncias do elemento CD.
Agora considere o documento XSL abaixo correspondente:
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/TR/WD-xsl">
<xsl:template match="/">
<html>
<body>
<p><head><h3> <b>CDs cadastrados<title>Loja de CDs
</title></b></h3></head></p>
<table border="3" bgcolor="white">
<tr>
<th>Title</th>
<th>Artist</th>
<th>Country</th>
<th>Company</th>
<th>Price</th>
<th>Year</th>
</tr>
<xsl:for-each select="CATALOG/CD">
<tr>
<td><xsl:value-of select="TITLE"/></td>
<td><xsl:value-of select="ARTIST"/></td>
<td><xsl:value-of select="COUNTRY"/></td>
<td><xsl:value-of select="COMPANY"/></td>
<td><xsl:value-of select="PRICE" /></td>
<td><xsl:value-of select="YEAR"/></td>
</tr>
</xsl:for-each>
51
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
Neste caso, foi construída uma tabela para armazenar os dados. Esta tabela é
construída através dos seguintes elementos:
<table border = largura> (se não for especificada a largura da borda, será
assumido o valor default igual a um)
<tr> delimita uma linha
<th> define um cabeçalho para a tabela
<td> delimita uma célula dentro de cada linha
Por fim, segue-se o resultado da execução desses documentos:
CDs cadastrados
Title
Artist
Country
Company
Price
Year
Carro Velho
Ivete Sangalo
BRA
Continental
21.80
1999
Music
Madonna
USA
Columbia
25.50
2000
Keep on Moving
Five
USA
Columbia
24.00
1999
3.2.2.2.2 - Informações adicionais:
- XSL Sort
Pode ser usado para classificar (ordenar) um documento XML. Para tanto devese apenas acrescentar o atributo order-by para o elemento for-each no arquivo XSL,
como este:
<xsl:for-each select="CATALOGO/CD" order-by="+ ARTIST">
O atributo order-by usa o sinal (+) ou o sinal (-), para definir uma ordem de
modo crescente ou decrescente, e um elemento name para definir o tipo do elemento.
- IF Condicional XSL
52
XSL pode usar um teste IF para processar um nó, se uma determinada condição
for satisfeita. Para tanto, simplesmente acrescenta-se um elemento xsl:if no documento
XSL, tal como:
<xsl:if test=".[ARTIST='Ivete Sangalo']">
... aqui vai o que deve acontecer ...
</xsl:if>
- Escolha condicional XSL
XSL pode usar uma escolha condicional para testar situações e reagir de acordo
com cada uma. Para tanto considera-se o ultimo documento XML mostrado acima. Para
inserir um teste de escolha condicional em frente ao conteúdo do arquivo, simplesmente
acrescentam-se os elementos xsl-choose, xsl-when, xsl-otherwise, no documento XSL,
tal como:
<xsl:choose>
<xsl:when test=".[ARTIST='Ivete Sangalo']">
... ações ...
</xsl:when>
<xsl:otherwise>
... outras ações ....
</xsl:otherwise>
</xsl:choose>
3.2.3 - Linguagens responsáveis por definir e estabelecer estruturas de ligações
(links) com outras fontes.
As especificações XPointer e XLink, atualmente em desenvolvimento pela
W3C, introduzem um modelo de ligação padrão para o XML.
3.2.3.1- XLINK (Linguagem de Links Extensível)
Esta linguagem de ligação XLink,
permite a inserção de elementos em
documentos XML para criar e descrever links entre recursos. XLink fornece uma
estrutura para criar tanto ligações unidirecionais básicas quanto estruturas de ligações
53
mais complexas. Ela permite ao desenvolvedor definir quais elementos ou atributos
especificarão links; desse modo, ele está construindo seus próprios links e ações de link
[W3C 01e].
Quando os desenvolvedores decidiram criar XLink, eles sabiam que teriam que
criar uma linguagem que fosse compatível com documentos HTML existentes, mas que
também suportasse as várias implementações possíveis de XML. Os links XML tinham
que estar aptos a - pelo menos - suportarem links entre documentos HTML e XML, bem
como entre dois documentos XML [PIT00].
3.2.3.1.1 - Links e recursos
Um link XLink é um relacionamento explícito entre recursos ou partes de
recursos. Isto é feito explicitamente por um elemento XLink chamado linking, o qual
também é um elemento XML que declara a existência de um link.
OBS: Quando um link associa um conjunto de recursos, estes são ditos partes do
link. Embora os links XLink devam aparecer em documentos XML, eles são capazes de
associar todos os tipos de recursos, não apenas os codificados em XML [W3C 01e].
3.2.3.1.2 - Elementos XLink
XLink oferece dois tipos básicos de links:
3.2.3.1.2.1 - SIMPLE:
Um link alinhado simples estabelece uma conexão entre recursos, os quais
podem ser uma página Web, um arquivo armazenado em um servidor de transferências
de arquivos, um script que permita a consulta a um banco de dados remoto ou até
mesmo uma conexão a uma câmera de vídeo remota. Esse tipo de link fornece um link
unidirecional externo que inclui um URL. Os links simples têm apenas um localizador
que combina as funções de um elemento de linking e um localizador em um único
elemento. Em XML, um link simples é aquele em que o conteúdo do elemento de link
age como um recurso. Um exemplo de um link simples é o elemento <A> do HTML.
3.2.3.1.2.1.1 - Comportamento dos Links
54
O termo comportamento dos links relaciona-se à especificação do tipo de ação
que é iniciada quando um link é acionado.
Em XLink, os links podem ser especificados para terem atributos do tipo
remotos ou locais.
- remoto: especifica o papel, atributos de comportamento, exibição de título e
atuação do link.
- local: especifica o papel do conteúdo e o título do conteúdo do link [PIT00].
Atributo SHOW:
Este atributo define o que irá acontecer após o link ter sido ativado. Possui três
valores:
- EMBBED: após o link ter sido ativado, o seu conteúdo será embutido na
posição onde o link foi especificado. É semelhante a embutir uma imagem.
-REPLACE: após o link ter sido ativado, o recurso especificado deve substituir o
recurso existente (em outras palavras, o recurso existente é a posição onde o link
começou). A janela será substituída por uma nova da mesma forma. É dessa forma que
funcionam os links padrão do HTML.
- NEW: após o link ter sido ativado, o recurso especificado deve ser exibido em
um novo contexto, ou seja, a janela onde o link foi localizado não será substituída, mas
sim, será exibida uma janela nova [PIT00].
Atributo ACTUATE:
Este atributo é usado para especificar quando um link deve ser ativado. Possui
dois valores:
- AUTO: especifica que o recurso ou página Web deve ser recuperada quando
qualquer um dos demais recursos do mesmo link for encontrado. Todos os recursos
AUTO são recuperados na ordem especificada, ou seja, a ordem em que eles foram
declarados.
- USER: especifica que o recurso definido no atributo HREF (o link) deve ser
exibido quando requisitado pelo usuário (um clique, por exemplo) [PIT00].
Atributo HREF:
Este atributo especifica o localizador do recurso.
Atributo ROLE:
Este atributo especifica o papel do link (o que o link significa para o aplicativo
que está processando-o).
55
Atributo TITLE:
Este atributo especifica o título que pode ser usado para o link.
Atributo INLINE (TRUE | FALSE):
Este atributo especifica que os links criados sobre esses elementos são alinhados
(em um link simples seu valor deve ser TRUE) .
Atributo CONTEND-ROLE:
Este atributo descreve o conteúdo para o qual o localizador aponta ao invés de
um link.
Atributo CONTEND-TITLE :
Este atributo especifica o CONTEND-TITLE para o CONTEND-ROLE.
Atributo BEHAVIOR
Este atributo permite indicar ao aplicativo como atravessar o link.
3.2.3.1.2.1.2 - Como criar um link simples?
1) Primeiro declara-se o elemento na DTD. Por exemplo:
<!ELEMENT MEULINK ANY>
<!ATTLIST MEULINK
XML:XLINK
CDATA
#FIXED “SIMPLE”
HREF
CDATA
#REQUIRED
TITLE
CDATA
#IMPLIED
INLINE
(TRUE | FALSE)
“TRUE”
CONTEND-ROLE
CDATA
#IMPLIED
SHOW
(EMBBED | REPLACE | NEW)
ACTUATE
(AUTO | USER)
BEHAVIOR
CDATA
“REPLACE”
“USER”
#IMPLIED >
2) Depois especifica-se o elemento no documento. Por exemplo:
<MEULINK XML:LINK=”SIMPLE” TITLE= ”Informações sobre XML”
HREF="http://www.site.com/info.xml" SHOW=”NEW”
CONTEND-ROLE=”Referência”>Esse
é
meu
link
para
XML.</MEULINK>
56
Pode-se incluir quaisquer dados, porém deve-se especificar o atributo XML:
LINK, pois seu valor é FIXED. Os demais elementos cujo valor é IMPLIED são
opcionais.
3.2.3.1.2.2 - EXTENDED
Os links estendidos oferecem uma maneira de criar relacionamentos entre
diferentes recursos. Eles relacionam-se ao conceito de anel (ring) Web. Um anel Web é
um grupo de sites Web que compartilham um interesse comum, como, por exemplo,
astrologia. O usuário pode mover para o próximo site ou para o site anterior do anel.
Assim, com links estendidos, pode-se criar um grupo de links para sites similares, uma
lista de links que levam o usuário de um site a outro em uma progressão [PIT00].
Há mais três tipos de links, os quais fornecem suporte aos links estendidos. São
eles:
=> DOCUMENT: indica que o link aponta para um documento de link estendido.
=> GROUP: indica que o link é um grupo de links estendidos.
=> LOCATOR: indica que o link é um localizador que aponta para um recurso.
3.2.3.1.2.2.1 - Atributos dos links estendidos
Os links estendidos assumem três atributos:
INLINE: indica que o elemento de linking é um dos recursos do link; pode ter o
valor TRUE ou FALSE. O padrão é FALSE.
CONTEND-TITLE: fornece informações de título para o elemento de linking
quando ele for um dos recursos do link.
CONTEND-ROLE: fornece informações de papel para o elemento de linking
quando ele for um dos recursos do link.
3.2.3.1.2.2.2 - Como criar um link estendido?
1) Primeiro declara-se o elemento na DTD. Por exemplo:
<!ELEMENT MEULINK ANY>
57
<!ATTLIST MEULINK
XML:XLINK
CDATA
#FIXED
“EXTENDED”
ROLE
CDATA
#IMPLIED
TITLE
CDATA
#IMPLIED
INLINE
(TRUE | FALSE)
CONTEND-ROLE
SHOW
CDATA
“FALSE”
#IMPLIED
(EMBBED | REPLACE | NEW)
“REPLACE”
ACTUATE (AUTO | USER)
“USER”
BEHAVIOR
#IMPLIED >
CDATA
Nota-se que neste caso não foi utilizado o atributo HREF. Para especificar os
recursos de links múltiplos, cria-se um outro elemento no qual o elemento EXTEND irá
se basear para criar um subconjunto de localizadores de links. Por exemplo:
<!ELEMENT RECURSOS ANY>
<!ATTLIST RECURSOS
XML:XLINK
CDATA
#FIXED
ROLE
CDATA
#IMPLIED
HREF
CDATA
#REQUIRED
TITLE
CDATA
#IMPLIED
SHOW
(EMBBED | REPLACE | NEW)
“LOCATOR”
“REPLACE”
ACTUATE (AUTO | USER)
“USER”
BEHAVIOR
#IMPLIED >
CDATA
2) Depois especifica-se o elemento no documento. Por exemplo:
<MEULINK> Linguagens de Marcação
<RECURSOS TITLE= “SGML” HREF="http://www.w3c.org/SGML" />
<RECURSOS TITLE= “HTML” HREF="http://www.w3c.org/SGML"/>
<RECURSOS TITLE= “XML” HREF= "http://www.w3c.org/SGML"/>
</EXTENDED>
3.2.3.1.3 - XTooX - Ferramenta para o uso de Xlinks
58
XtooX [NEN00] é um processador que torna links estendidos (links que podem
apontar para vários recursos) e links desalinhados (links cujo conteúdo não serve como
um recurso) em links simples. Ele toma como um linkbase de entrada um documento
contendo somente XLinks e insere estes links nos documentos referenciados. Em outras
palavras, ele insere xlinks nos arquivos que eles estão apontando.
Feito isto, ainda é necessário transformar os arquivos resultantes em formato
HTML usando XSLT para a exibição dos mesmos.
Entre os vários arquivos contidos no pacote de XTooX, há dois arquivos
principais, que serão responsáveis pela
utilização da ferramenta pelo usuário:
Retriever.java e Test.java. O uso de XTooX é feito da seguinte forma:
•
Identificar no arquivo Retriever.java o diretório cache onde estão os
arquivos a serem utilizados por XTooX. Para tanto, o usuário deve criar seu próprio
diretório cache e inserir nele os arquivos que serão utilizados pela ferramenta.
properties.setProperty("http://www.xlinkit.com/xtoox/linkstructure/cachedirectory","caminho_do_diretório_cache");
•
Compilar o arquivo Retriever.java
•
Identificar no arquivo Test.java o nome do arquivo que contém os xlinks:
String linkbaseurl = “caminho_de_identificação_do_arquivo_de_xlinks”
•
Compilar o arquivo Test.Java
3.2.3.1.3.1 - Exemplo do uso de XtooX
Abaixo segue-se o arquivo de xlinks (documento xml) citado acima. Este
arquivo contém todos os links que serão inseridos nos arquivos referenciados.
Arquivo de xlinks:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE xlinkit:LinkBase SYSTEM "C:\Projeto\Linkbase.dtd">
59
<xlinkit:LinkBase>
xlinkit:ConsistencyLink
ruleid="http://www.xlinkit.com/dangerzone/rule.xml?noprocess=true#/consisten
cyrule[1]">
<xlinkit:State>consistent</xlinkit:State>
<xlinkit:Locator
xlink:href="http://www.xlinkit.com/Example/Bike/Advert1.xml?
noprocess=true#/Advert"
xlink:label="" xlink:title=""/>
<xlinkit:Locator xlink:href="http://www.xlinkit.com/Example/Catalogue.xml?
noprocess=true#/Catalogue/Product[1]"
xlink:label="" xlink:title=""/>
</xlinkit:ConsistencyLink>
<xlinkit:ConsistencyLink
ruleid="http://www.xlinkit.com/dangerzone/rule.xml?noprocess=true#/consistencyrule[
1]">
<xlinkit:State>consistent</xlinkit:State>
<xlinkit:Locator
xlink:href="http://www.xlinkit.com/Example/Bike/Advert2.xml?
noprocess=true#/Advert"
xlink:label="" xlink:title=""/>
<xlinkit:Locator xlink:href= "http://www.xlinkit.com/Example/Catalogue.xml?
noprocess=true#/Catalogue/Product[2]"
xlink:label="" xlink:title=""/>
</xlinkit:ConsistencyLink>
<xlinkit:ConsistencyLink
ruleid="http://www.xlinkit.com/dangerzone/rule.xml?noprocess=true#/consistencyrule[
1]">
60
<xlinkit:State>consistent</xlinkit:State>
<xlinkit:Locator
xlink:href="http://www.xlinkit.com/Example/Bike/Advert3.xml?
noprocess=true#/Advert"
xlink:label="" xlink:title=""/>
<xlinkit:Locator xlink:href="http://www.xlinkit.com/Example/Catalogue.xml?
noprocess=true#/Catalogue/Product[3]"
xlink:label="" xlink:title=""/>
</xlinkit:ConsistencyLink>
</xlinkit:LinkBase>
Na primeira tag <xlinkit> há dois elementos locators (em negrito) que
referenciam os endereços dos arquivos nos quais serão inseridos tais links. Isto indica
que quando o processador XTooX processar este arquivo de xlinks, será inserido no
arquivo Advert1.xml o link para o arquivo Catalogue.xml e também será inserido no
arquivo Catalogue.xml o link para o arquivo Advert1.xml (neste caso foi utilizada uma
expressão XPath indicando que a inserção do link será feita no primeiro elemento
Product do documento Catalogue.xml).
O mesmo também vai ocorrer para os arquivos referenciados nas demais tags do
documento.
Advert1- Antes do processamento
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE Advert SYSTEM "http://www.xlinkit.com/DTD/advert.dtd">
<Advert>
<ProductName>HARO SHREDDER</ProductName>
<Price currency="sterling">349.95</Price>
<Description>Freestyle Bike.
Super versatile frame for dirt, street, vert or flat. New full
cromoly frame. Fusion MegaTube axle extenders.
</Description>
</Advert>
61
Advert1- Após processamento
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE Advert SYSTEM "http://www.xlinkit.com/DTD/advert.dtd">
<Advert>
<ProductName>HARO SHREDDER</ProductName>
<Price currency="sterling">349.95</Price>
<Description>Freestyle Bike.
Super versatile frame for dirt, street, vert or flat. New full
cromoly frame. Fusion MegaTube axle extenders.
</Description>
<xlink
xlink:href="http://www.xlinkit.com/Example/Catalogue.xml?
noprocess=true#/Catalogue/Product[1]"
xlink:role="destination" xlink:title="" xlink:type="simple"
xmlns:xlink="http://www.w3.org/1999/xlink/namespace/"/>
</Advert>
Advert2- Antes do processamento
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE Advert SYSTEM "http://www.xlinkit.com/DTD/advert.dtd">
<Advert>
<ProductName>HARO TR2.1</ProductName>
<Price currency="sterling">179.95</Price>
<Description>BMX / Trail Bike.
Affordable BMX performance! New Track and Trail frame design
Tektro alloy direct pull brakes.</Description>
</Advert>
Advert2- Após processamento
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE Advert SYSTEM "http://www.xlinkit.com/DTD/advert.dtd">
62
<Advert>
<ProductName>HARO TR2.1</ProductName>
<Price currency="sterling">179.95</Price>
<Description>BMX / Trail Bike.
Affordable BMX performance! New Track and Trail frame design
Tektro alloy direct pull brakes.</Description>
<xlink xlink:href="http://www.xlinkit.com/Example/Bike/catalogue.xml?
noprocess=true#/Catalogue/Product[2]"
xlink:role="destination"
xlink:title=""
xlink:type="simple"
xmlns:xlink="http://www.w3.org/1999/xlink/namespace/"/>
</Advert>
Advert3- Antes do processamento
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE Advert SYSTEM "http://www.xlinkit.com/DTD/advert.dtd">
<Advert>
<ProductName>DYNO NFX</ProductName>
<Price currency="sterling">119.95</Price>
<Description>BMX Bike. Dyno
expert frame. Tektro V-type direct pull rear brakes. Chrome,
gloss black, candy blue or hyper red. Coaster brake or
freewheel.</Description>
</Advert>
Advert3- Após processamento
xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE Advert SYSTEM "http://www.xlinkit.com/DTD/advert.dtd">
<Advert>
<ProductName>DYNO NFX</ProductName>
<Price currency="sterling">119.95</Price>
63
<Description>BMX Bike. Dyno
expert frame. Tektro V-type direct pull rear brakes. Chrome,
gloss black, candy blue or hyper red. Coaster brake or
freewheel.</Description>
<xlink xlink:href="http://www.xlinkit.com/Example/Bike/catalogue.xml?
noprocess=true#/Catalogue/Product[3]"
xlink:role="destination"
xlink:title=""
xlink:type="simple"
xmlns:xlink="http://www.w3.org/1999/xlink/namespace/"/>
</Advert>
Catalogue.xml- Antes do processamento
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE
Catalogue
SYSTEM
"http://www.xlinkit.com/DTD/catalogue.dtd">
<Catalogue>
<Product>
<Name>HARO SHREDDER</Name>
<Code>B001</Code>
<Price currency="sterling">349.95</Price>
<Description>Freestyle Bike.</Description>
</Product>
<Product>
<Name>HARO TR2.1</Name>
<Code>B002</Code>
<Price currency="sterling">179.95</Price>
<Description>BMX / Trail Bike.</Description>
</Product>
<Product>
<Name>DYNO NFX</Name>
<Code>B003</Code>
<Price currency="sterling">169.95</Price>
<Description>BMX Bike.</Description>
64
</Product>
</Catalogue>
Catalogue.xml- Após processamento
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE
Catalogue
SYSTEM
"http://www.xlinkit.com/DTD/catalogue.dtd">
<Catalogue>
<Product>
<Name>HARO SHREDDER</Name>
<Code>B001</Code>
<Price currency="sterling">349.95</Price>
<Description>Freestyle Bike.</Description>
<xlink
xlink:href="http://www.xlinkit.com/Example/Bike/advert1.xml?noprocess=true#/
Advert"
xlink:role="destination" xlink:title="" xlink:type="simple"
xmlns:xlink="http://www.w3.org/1999/xlink/namespace/"/>
</Product>
<Product>
<Name>HARO TR2.1</Name>
<Code>B002</Code>
<Price currency="sterling">179.95</Price>
<Description>BMX / Trail Bike.</Description>
<xlink
xlink:href="http://www.xlinkit.com/Example/Bike/advert2.xml?noprocess=true#/
Advert"
xlink:role="destination" xlink:title="" xlink:type="simple"
xmlns:xlink="http://www.w3.org/1999/xlink/namespace/"/>
</Product>
<Product>
<Name>DYNO NFX</Name>
<Code>B003</Code>
<Price currency="sterling">169.95</Price>
<Description>BMX Bike.</Description>
65
<xlink
xlink:href="http://www.xlinkit.com/Example/Bike/advert3.xml?noprocess=true#/
Advert"
xlink:role="destination" xlink:title="" xlink:type="simple"
xmlns:xlink="http://www.w3.org/1999/xlink/namespace/"/>
</Product>
</Catalogue>
3.2.3.2 - XPOINTER (Linguagem de Ponteiro XML)
A linguagem XPointer foi criada para permitir a especificação de fragmentos de
documentos. Os XPointers são muito mais do links simples, uma vez que são
referências a posições dentro de documentos, de forma similar à marca âncora e sua
referência #NOME em HTML. Os locais que XPointer consegue identificar vão além
de seções identificadas pelos atributos ID (atributo que fornece um identificador
exclusivo para o elemento dentro do documento) ou NAME, indo para aqueles descritos
por conteúdo, relacionamento pai-filho, etc [W3C 01f].
3.2.3.2.1 - Como declarar Xpointer
Para estender o atributo HREF do XML de modo que inclua XPointers , basta
inserir o símbolo (#) ou (|) e o ponteiro após a URL. Ambos os caracteres indicam que o
que vem a seguir é um XPointer procurando um identificador de fragmentos. O
XPointer procura o fragmento (sub-recurso ) dentro do recurso que o contém definido
pelo localizador URL, e identifica o fragmento como o verdadeiro destino do link. Se
uma URL não estiver precedendo os caracteres # ou |, a sintaxe do XPointer assumirá
que o recurso que a contém é o documento que contém o XPointer.
3.2.3.2.2 - Como ligar a parte de um arquivo
Como já fora visto, XPointer permite ligar a determinado elemento ou faixa de
elementos, ao invés do arquivo todo. Para tanto, digita-se #xpointer(expression), após
ou no lugar da URL, onde expression é uma frase XPath que identifica a parte
66
específica do arquivo ao qual deseja-se conectar. Um exemplo de tal aplicação segue-se
abaixo:
...
<source xlink:type=”simple” xlink:href=
“http://www.meusite.com/xml/examples/
xlink/cidade.xml#xpointer(escola[position()=1])” xlink:role=”info source”
xlink:title=”Informações”
xlink:show=”replace”
xlink:actuate=”onRequest”/>
...
Este XPointer aponta para o primeiro elemento “escola” no documento
cidade.xml. Neste exemplo, primeiro tem-se o elemento “source”, o qual é um link
simples (xlink:type=”simple”) e em seguida especifica-se o valor da URL (onde URL é
o local do arquivo a ser referenciado).
3.2.3.2.3 - Como criar XPointer mais simples
XPointers são projetados para identificar facilmente atributos do tipo ID. Se
deseja-se fazer um link a um elemento que contém um atributo ID, o XPointer consiste
simplesmente do valor daquele atributo [CAS01].
Abaixo segue-se um exemplo da criação de XPointers mais simples:
...
<source xlink:type=”simple” xlink:href=
“http://www.meusite.com/xml/examples/
xlink/cidade.xml#T143” xlink:role=”info source”
xlink:title=”Informações”
xlink:show=”replace”
xlink:actuate=”onRequest”/>
...
Este XPointer aponta para um elemento que contém um atributo do tipo de ID
cujo valor é T143.
3.2.3.2.4 - Como criar XPointers móveis
67
Este tipo simples de XPointer é um que literalmente percorre o documento XML
até chegar ao elemento desejado. Esse tipo de XPointer é chamado de seqüência filho.
Um exemplo de tal aplicação segue-se abaixo:
...
<source xlink:type=”simple” xlink:href=
“http://www.meusite.com/xml/examples/
xlink/cidade.xml#1/1/” xlink:role=”info source”
xlink:title=”Informações”
xlink:show=”replace”
xlink:actuate=”onRequest”/>
...
Este XPointer aponta para o primeiro filho do primeiro filho do raiz (1/1/).
3.2.3.2.5 - Como criar uma faixa de Xpointers
Se o objetivo é ligar a uma faixa entre dois pontos determinados de um
documento, pode-se utilizar a função range-to de XPointer. Para tanto, digita-se
#xpointer (para iniciar o Xpointer); depois digita-se (start_expression), onde
start_expression é a expressão XPath que indica o início da faixa desejada, e digita-se
/range-to para indicar que deseja-se uma faixa; então digita-se (end_expression), onde
end_expression é a expressão XPath que indica o fim da faixa desejada. Por fim, digitase ) para concluir o XPointer. Um exemplo de tal aplicação segue-se abaixo:
...
<source xlink:type=”simple” xlink:href=
“http://www.meusite.com/xml/examples/
xlink/cidade.xml#xpointer((escola[position()=1])/range-to
(escola[position()=2]))”
xlink:role=”info source”
xlink:title=”Informações”
xlink:show=”replace”
xlink:actuate=”onRequest”/>
...
68
Esse XPointer identifica a faixa entre o primeiro e o segundo elementos “escola”
no arquivo cidade.xml.
3.3 – Estudo das Linguagens Construídas a partir de XML
3.3.1 – Aplicativos XML
Com essa flexibilidade oferecida pela XML é possível criar novos vocabulários
que são, na realidade, aplicativos que usam a linguagem XML. Isso significa que
organizações e empresas da mesma área criam seus próprios elementos, atributos e
entidades que explicam, completamente, a estrutura dos tipos de documentos para
mercados específicos, bem como para assuntos específicos. Por exemplo, a OpenMLS
criou um DTD - Document Type Definitions (definição de tipos de documentos) para
imobiliárias que especifica a estrutura de documento de dados que armazena
informações sobre as propriedades colocadas à venda. [PIT00]
Sabemos que XML nos dá a habilidade de criar nosso próprio conjunto de
elementos, os atributos que esses elementos vão ter e as entidades. A XML define como
um vocabulário pode ser estruturado. Os vocabulários são conjuntos de componentes
XML que podem ser usados para definir estruturas de documentos específicas. No
exemplo de um vocabulário, o CDF (Channel Definition Format - Formato de
Definição de Canais), o XML forneceu a estrutura para definir canais e seus respectivos
elementos de canal, chamados itens. Em outras palavras, podemos usar a linguagem
XML para criar nossa própria linguagem de tipos e essa linguagem pode ser usada para
fazer uma série de coisas, desde a exibição de equações matemáticas até a remessa de
informações ao computador de um usuário via tecnologia “push”7.
Com o XML, podemos construir nosso próprio conjunto de componentes que
definem a estrutura de um documento. Como pode ser observado, definimos essa
estrutura na DTD. Essa DTD lista todos os elementos, atributos, entidades e declarações
de notação, e ela pode ser armazenada no conteúdo do documento XML. Nós que
7
Tecnologia que permite que os computadores façam a busca por notícias sem que o internauta
precise acessar algum site. Por meio de uma personalização, o equipamento sabe de quanto em
quanto tempo deve-se conectar para receber as informações de um canal pré-determinado.
69
determinamos onde a DTD é colocada, seja no próprio documento XML (DTD interna)
ou em um documento à parte (DTD externa). Ao pensarmos realmente no assunto, o
XML nos permite criar aplicativos inteiramente novos, não por meio de métodos de
programação convencional, mas sim por meio da definição da estrutura contextual do
documento.
Não levou muito tempo para os aplicativos XML começarem a aparecer. Já
existe um número razoável de aplicativos XML que podemos usar para uma variedade
de funções e mais um bom número se encontra em fase de desenvolvimento ou sob
análise do W3C (World Wide Web Consortium). Alguns, como o CDF, já fazem parte
do navegador Internet Explorer, ao passo que outros ainda se encontram em fase de
desenvolvimento.
Aplicativos XML seguem a sintaxe XML. Portanto, tudo o que se tem a fazer
para aprender como usá-los é familiarizar-se com os elementos específicos e seus
atributos. A maioria dos aplicativos XML disponíveis hoje em dia usa menos do que 20
marcas de elementos diferentes e a maioria dessas marcas de elementos possui apenas 1
ou 2 atributos. Portanto, o aprendizado é consideravelmente facilitado
É impressionante ver o tremendo suporte que o XML vem ganhando e nenhuma
evidência disso é tão grande quanto o número de aplicativos baseados em XML que
foram criados em um período relativamente curto de tempo. Podemos usar XML para
fazer praticamente qualquer coisa que possamos imaginar, inclusive enviar remotamente
atualizações de software, transmitir objetos multimídia de uma maneira padronizada e
elaborar e exibir equações matemáticas.
Para exemplifica, descreveremos alguns desses aplicativos criados a partir da
XML.
3.3.1.1 - RDF (Resource Description Framework)
O RDF é a base para o processamento de metadados. Seu principal objetivo é o
de facilitar o intercâmbio de informações (que podem ser interpretadas por máquinas)
entre aplicativos via Web. Um dos alicerces importantes do RDF é sua habilidade de
automatizar o processamento de recursos Web. [PIT00]
As técnicas de pesquisa de dados atuais giram em torno de busca e recuperação
textual por agentes não-inteligentes. Tudo o que mecanismos de busca fazem é verificar
a coincidência de strings de texto com strings de texto e não de descrições com outras
70
descrições. A marca <META> do HTML está disponível, porém não é largamente
usada pelos desenvolvedores em HTML e muito menos pelos mecanismos de busca.
O número e tipos de recursos na Web estão crescendo a uma razão exponencial
e, em breve, ficará impossível para qualquer um encontrar alguma coisa em um período
de tempo razoável.
A Web está em estado desesperador em busca de uma maneira de descrever
recursos e a XML é extensível o bastante, tanto é que foi usado para criar um aplicativo
que pudesse fazer isso. Pelo fato de o RDF não ter sido concebido para ser usado para
funcionar com um ou dois tipos de recursos, mas sim com todos os tipos de dados
eletrônicos, ele possui uma variedade de aplicações, entre as quais podemos destacar as
seguintes:
•
Identificação consistente de direitos autorais, marcas registradas e outras
informações de propriedade intelectual em recursos da Web.
•
Pesquisa mais acurada de arquivos de dados, pois os dados em si estão
melhor identificados.
•
A capacidade de representar conjuntos inteiros de documentos como um
único e grande documento quando apropriado.
•
Estabelecimento de relacionamentos seguros entre documentos e
computadores para facilitar o intercâmbio de idéias e de recursos, bem
como de comércio eletrônico.
O RDF é um aplicativo XML que ainda se encontra em desenvolvimento no
W3C (World Wide Web Consortium). O RDF usa a notação XML como uma sintaxe de
codificação para descrição de metadados. Você não encontrará uma DTD RDF por si.
Em vez disso, os elementos construtivos do XML são usados para descrever o modelo
de dados do RDF. Isso permite que as descrições sejam analisadas sintaticamente por
analisadores sintáticos XML e passadas para aplicativos que entendam o XML, mas isso
não significa que o RDF possa ser implementado apenas em XML. Os desenvolvedores
do RDF pretendem torná-lo flexível o suficiente para que seu modelo de dados possa ser
descrito usando-se outros vocabulários além do XML. Mas aqui estamos interessados
no RDF como um aplicativo XML. [PIT00]
3.3.1.1.1 – Exemplos
71
O exemplo a seguir foi adaptado do Dublin Core da página Web RDF Examples
em http://www.dstc.edu.au/RDU/RDF/dc-in-rdf-ex.html. È uma descrição simples da
página Web Dublin Core Elements.
<?xml:namespace href="http://www.w3c.org/RDF/" as="RDF"?>
<?xml:namespace href="http://purl.org/RDF/DC/" as="DC"?>
<RDF:RDF>
<RDF:Description>
<DC:Title>
Conjunto de Elementos Metadados do Dublin Core: Descrição de
Referência
</DC:Title>
<DC:Creator>Stuart Weibel</DC:Creator>
<DC:Creator>Eric Miller</DC:Creator>
<DC:Subject>Metadados,
elementos
do
Dublin
core,
descrição
de
resursos</DC:Subject>
<DC:Description>
Este documento é a descrição de referência do Conjunto de Elementos
Metadados
do Dublin Core concebido para facilitar a pesquisa e localização de
recursos.
</DC:Description>
<DC:Publisher>OCLC
Online
Computer
Library
Center,
Inc.</DC:Publisher>
<DC:Format>texto/html</DC:Format>
<DC:Type>Relatório Técnico</DC:Type>
<DC:Language>en</DC:Language>
<DC:Date>02-11-1997</DC:Date>
</RDF:Description>
</RDF:RDF>
3.3.1.2 - SMIL (Syncronized Multimedia Integration Language)
72
Com SMIL [SMIL99], os desenvolvedores podem criar sites Web ricos em
conteúdo multimídia. O SMIL permite aos sites terem conteúdo parecido com o de TV,
com requisitos de largura de banda baixa para transmitir conteúdo através da Internet.
Assim que o SMIL tornar-se um padrão usado em larga escala, não haverá nenhuma
necessidade de os usuários configurarem seus navegadores para usarem aplicativos
auxiliares ou plug-ins8 específicos. Em vez disso, o SMIL irá fornecer uma maneira
padronizada e interplataformas de remeter conteúdo multimídia sem a necessidade de
software proprietário especializado. Isso também significa que linguagens de
programação adicionais não serão necessárias para criar documentos multimídia. Como
acontece com qualquer outro aplicativo XML, tudo o que é preciso é um simples
processador de texto.
O SMIL também permite ao desenvolvedor criar e embutir links dentro de
arquivos multimídia. Isso significa que o desenvolvedor pode criar apresentações Web
baseadas em tempo, e objetos de mídia podem ser reutilizados repetidamente.
Como acontece com todos os aplicativos XML, o SMIL segue princípios de
projeto padrão, mas também possui um conjunto de princípios de projeto próprio:
[SMIL01]
•
Todos os objetos especificados em qualquer URL devem estar
disponíveis on-line
•
Todos os objetos em arquivos SMIL devem Ter um horário de início e
outro de término, baseados em parâmetros de tempo.
•
Opções para o usuário como parar, reproduzir, avançar e retroceder,
devem estar disponíveis e todos os componentes devem reagir a essas
opções de uma maneira sincronizada.
Os links se constituem em um componente-chave para o SMIL e devemos
desenvolver arquivos SMIL com os links embutidos nesses mesmos arquivos.
Entretanto, ele utiliza apenas links. Em vez disso, o SMIL usa os mecanismos
avançados de links usados no XML.
73
3.3.2.2.1 - Exemplos
<smil>
<head>
<layout>
<root-layout width="300" height="200" background-color="white"/>
<region
id="vim_icon"
left="80%"
top="40%"
width="32"
height="32"/>
</layout>
</head>
<body>
<img src="vim32x32.gif" alt="The vim icon" region="vim_icon"/>
</body>
</smil>
Exemplo1: regiao relativa. A região em que o ícone vai aparecer é referenciada pela
porcentagem da tela (80% à esqueda e 40% abaixo do topo)
<smil>
<head>
<layout>
<root-layout width="300" height="200" background-color="white"/>
<region id="vim_icon" left="75" top="50" width="32" height="32"/>
<region id="soja_icon" left="150" top="50" width="100" height="30"/>
</layout>
</head>
<body>
<par>
8
Extensões do browser fornecidas pelo fabricante do browser ou empresas parceiras que
74
<img src="vim32x32.gif" region="vim_icon" begin="4s"/>
<img src="madewithsoja.gif" region="soja_icon" begin="6s"/>
</par>
</body>
</smil>
Exemplo2: Sincronismo básico. Os ícones “vim32x32.gif” e “madewithsoja.gif” são mostrados
paralelamente, através do uso da tag “par”.
<smil>
<head>
<layout>
<root-layout width="300" height="200" background-color="white"/>
<region id="vim_icon" left="75" top="50" width="32" height="32"/>
<region id="soja_icon" left="150" top="50" width="100" height="30"/>
</layout>
</head>
<body>
<par>
<img src="vim32x32.gif" alt="The vim icon" region="vim_icon"
dur="6s"/>
<img
src="madewithsoja.gif"
alt="Made
with
SOJA"
region="soja_icon" dur="6s"/>
</par>
</body>
</smil>
Exemplo3: 2 ícones serão mostrados , paralelamente, durante 6 segundos
<smil>
<head>
<layout>
<root-layout width="300" height="200" background-color="white"/>
<region id="vim_icon" left="75" top="50" width="32" height="32"/>
</layout>
fornecem recursos adicionais de multimídia facilitando a visualização de textos, som, vídeo, ect.
75
</head>
<body>
<img
src="vim32x32.gif"
alt="The
vim
icon"
region="vim_icon"
dur="6s"/>
</body>
</smil>
Exemplo4:Um ícone será exibido durante 6 segundos
<smil>
<head>
<layout>
<root-layout width="300" height="200" background-color="white"/>
<region id="vim_icon" left="75" top="50" width="32" height="32"/>
</layout>
</head>
<body>
<img src="vim32x32.gif" alt="The vim icon" region="vim_icon" dur="6s"
begin="2s"/>
</body>
</smil>
Exemplo5: Após o inicio da aplicação, passa-se 2s sem nada e depois será exibido um ícone
durante 6s
3.3.1.3 - UXF (UML eXchange Format)
Como a Unified Modeling Language (UML) provê a maioria dos conceitos e
notações que são essenciais para documentar modelos orientado a objetos, ela tem sido
aceita amplamente na área de Engenharia de Software. Porém, UML não tem um
formato explícito para intercâmbio de seus modelos. A habilidade para trocar os
modelos é bastante importante, porque é possível que um time de desenvolvedores
residam em lugares separados e porque a maioria das ferramentas de desenvolvimento
atual não provê a “interconectividade” da informação dos modelos. Para este problema,
propõe-se UXF (UML eXchange Format) que é um formato de troca para modelos
UML, baseado em XML (eXtensible Markup Language). É um formato poderoso o
76
suficiente para expressar, publicar, acessar e trocar modelos UML e uma extensão
natural existente no ambiente Internet. Serve como um veículo de comunicação para o
desenvolvedor e como um formato de dados bem-estruturado para ferramentas de
desenvolvimento. UXF mostra um passo importante na colaboração e troca de
informações do modelo e indica uma direção futura da “interconectividade” entre
ferramentas UML. [JUN01]
UML define os seguintes diagramas para a modelo objeto:
•
•
•
diagramas Estruturais:
•
diagrama de classes
•
diagrama de objetos
diagramas de Comportamento:
•
diagrama use case
•
diagrama de seqüência
•
diagrama de colaboração
•
diagrama de transição de estados
•
diagrama de atividades
diagramas de implementação:
•
diagrama de componentes
•
diagrama de desenvolvimento
Usando estes diagramas com um bom nível de abstração, sistemas complexos
podem ser modelados por um pequeno conjunto de diagramas quase independentes.
UML provê dois aspectos para construção nestes diagramas:
•
Semântica
Um metamodelo UML define a sintaxe abstrata e semântica do
conceito de modelagem a objeto.
•
Notações
UML define notações gráficas para a representação visual da
semântica UML.
Enquanto UML define as construções coerentes citadas acima, ela não provê o
formato explícito para a troca de informações do modelo. A habilidade para trocar
77
modelos é bastante importante, porque as redes de comunicação como Internet cresce
exponencialmente e é provável que um time de desenvolvedores resida em lugares
separados. Além disso, tal habilidade facilita a “interconectividade” de aplicação de
forma que as informações do modelo podem ser trocadas entre várias ferramentas, como
CASE (Computer Aided Software Engeneering), editores de diagrama e ferramentas de
engenharia reversa e amplia a habilidade para codificar, trocar e reusar as informações
do modelo.
Através deste problema, foi descrita uma linguagem para fazer com que
modelos UML fossem trocados na Internet e/ou entre ferramentas de desenvolvimento.
Para prover um meio baseado no padrão e aplicações neutras, propõe-se um formato de
troca de fluxo chamado UXF (UML eXchange Format) que é baseado em XML
(eXtensible Markup Language) e provê um mapeamento UML para XML.
3.3.1.3.1 - Limitações do HTML
Como tal, desde que a Web está se tornando o ambiente onipresente, HTML tem
sido o principal formato de documento, e também usado para documentação de
software. Exemplos de tais ferramentas incluem javadoc incluído em Java Development
Kit (JDK) que é um tradutor dos comentários em código de fonte Java na especificação
de documentos escrito em HTML. Enquanto tal ferramenta é valiosa e útil no trabalho
de desenvolvimento cotidiano, infelizmente algumas informações importantes para os
modelos de software são jogadas fora no processo de produção de documentos HTML,
devido a seu conjunto fixo de tags. Conteúdos em tais documentos HTML são
significantes somente para humano e sua semântica não pode ser ambígua para ser
reconhecida por ferramentas de software. Em outras palavras, documentos HTML
gerados por ferramentas de documentação não podem ser reusados em outras aplicações
diferentes de browsers HTML. Neste caso, se há uma linguagem de marcação com uma
semântica mais rica e ferramentas de desenvolvimento que a suportam, pode-se trocar
informação de modelo UML sem perder sua semântica.
Também, é provável que os membros em um grupo de desenvolvimento de
software, inclusive analistas de requisitos, arquitetos de sistemas, desenhistas e
programadores, estejam trabalhando em lugares separados e estão confiando na
comunicação eletrônica. Atualmente, os meios predominantes para distribuir diagramas
de UML na Web são os métodos baseados em imagens como GIF (Graphics
78
Interchange Format) ou imagens de JPEG (Joint Photographic Experts Group) que
representam diagramas de UML e não são bem dispostos dentro de um texto de HTML.
Porém, é difícil e caro (consome tempo) para o autor, ler e manter estas imagens e
inadequado, já que a informação do modelo é escondida dentro de imagens e não pode
estar disponível para outras ferramentas de desenvolvimento (por exemplo busca e
desenho). Outro problema com a codificação da informação do modelo como imagens é
que requer mais largura de banda da rede. Marcação descrevendo informações do
modelo é tipicamente menor e mais compreensível que uma imagem do modelo.
Juntamente com os problemas acima citados, o fator mais importante em troca
de modelos UML entre programas de software é que a semântica dentro dos modelos
deveria ser descrita explicitamente e deveria ser mantida. Para este propósito, XML é
um candidato razoável e prático para um veículo trocar modelos UML.
De frente com os problemas descritos acima e baseado em uma emergente
linguagem de descrição de dados chamado XML, propõe-se um formato de troca de
modelos UML denominado UXF (UML eXchange Format). UXF facilita: [JUN01]
•
Intercomunicação entre desenvolvedores de software:
UXF é um poderoso veículo de transferência de modelos UML entre
desenvolvedores de software. Ele simplifica a circulação de modelos UML para
cada um, com o formato legível para o humano e intuitivo.
•
Interconectividade entre ferramentas de desenvolvimento:
UXF é um formato bem-estruturado e portável (aplicação neutra) entre
várias ferramentas de desenvolvimento. Uma vez codificado com UXF, a
informação de modelos UML pode ser reutilizável por um grande número de
usuários que usam ferramentas diferentes.
•
Extensão Natural de ambientes de Rede existentes:
UXF é uma extensão natural e transparente do ambiente de Rede existente.
Assim, permite editar, publicar, acessar e trocar os dados de UXF tão facilmente
quanto é atualmente possível com HTML. Além disso, a maioria de aplicações
existentes ao redor da Web pode ser usada para tratar UXF com modificações
relativamente menores.
A maioria das ferramentas de desenvolvimento como CASE, ferramentas de
documentação, ferramentas visuais e depósitos de documento, podem ser modificadas
de forma que eles reconheçam UXF. Na situação atual onde muitas aplicações XML
existem, é relativamente fácil de estender ferramentas existentes. Também, materiais
79
técnicos relacionados a UML formatados em UXF podem ser tratados por toda
aplicação Web que manipula HTML como também browsers Web e servidores Web
num futuro próximo. Como resultado, UXF permite o uso, sem restrições, de modelos
UML entre ferramentas de desenvolvimento, e proporciona uma estreita integração com
ambientes Web.
Desenvolvedores, inclusive analistas, designers e engenheiros, podem
comunicar suas visões, compreensões ou intenções em seus modelos UML, por
intercâmbio do arquivo formatado em UXF. Também, a habilidade para manter
informações técnicas durante o ciclo de vida do software é vital a grupos de
desenvolvimento com o propósito de arquivar, porque, tipicamente, todo grupo tem um
grande volume de materiais. Engenheiros usam estes materiais em seus trabalho para
consultar e revisar a informação atual, registrar resultados de experiências ou histórico
de logs. Para tal uso, UXF bem-estruturado provê um modo padrão de compartilhar
informações, na qual pode-se ler facilmente, processar e gerar modelos UML usando
ferramentas geralmente disponíveis.
Além disso, UXF assegura uma variedade de possibilidades de suas
representações de saída (apresentações): como os dados UXF deveriam ser passados ou
vistos. Considerando que UXF pode solicitar arbitrariamente a folha de estilo XSL,
pode ser convertido em materiais de grande alcanço de mídia como RTF (Rich Text
Format), HTML, LaTeX, PDF (Portable Document Format). Além disso, documentos
UXF podem embutir links de hypermidia com o mecanismo de link de XLL (XML
Linking Language). Isto nos permite unir construções UML uma a outra. Como tal,
desenvolvedores podem envolver em materiais técnicos todo o nível de versões
eletrônicas e documentos impressos para versões interativas. [JUN01]
3.1.1.3.2 - Exemplo
Um exemplo de um documento UXF de um diagrama de classes está no
Anexo1: [JUN01]
3.3.1.4 - CDF (Channel Definition Format)
80
CDF (Channel Definition Format - Formato de Definição de Canais) é
uma implementação da Microsoft da tecnologia push. O CDF é, na realidade, um
aplicativo XML, significando que o CDF depende da Extensible Markup Language para
criar um sistema de remessa de informações.
A Microsoft introduziu a tecnologia Active Channel e sua base estrutural,
CDF, quando introduziu o Internet Explorer 4. As tecnologias push que usam XML
(como o CDF) oferecem ao desenvolvedor uma maneira para organizar e remeter
informações
baseadas
na
Web
específicas
e
personalizadas
em
intervalos
predeterminados para os usuários que as solicitarem. Trata-se de um dos aplicativos
XML mais fáceis de ser aprendidos e implementados dentro de um site,
independentemente do site estar na Internet ou ser parte de um intranet. Com o CDF, os
desenvolvedores podem criar conteúdo para distribuição para uma ampla gama de
usuários e por meio de uma variedade de formatos de remessa. Por exemplo, preços
atualizados de ações poderiam ser enviados aos assinantes de um canal CDF com
tecnologia push via e-mail formatado em HTML, páginas Web ou protetor de tela. Esta
tecnologia push permite aos usuários obter as informações simplesmente efetuando uma
assinatura com a fonte de conteúdo. As informações são remetidas automaticamente
para os computadores dos usuários tomando como base uma programação
predeterminada ou por meio de conexão com a Internet. Uma vez enviadas, as
informações podem ser vistas fora do ar, pois todo o conteúdo textual e de imagens são
remetidos juntos em um único pacote de assinatura. [PIT00]
O CDF fornece um conjunto padrão de marcas para definir canais que
enviam dados automaticamente de um servidor Web para um navegador Web. O CDF
também lhe permite criar uma programação para efetuar o download de conteúdo
atualizado a partir do servidor Web para o navegador. O conteúdo é identificado com
uma breve descrição e inclui botões de navegação para possibilitar que o usuário se
movimente facilmente.
3.3.1.4.1 - Uma visão mais detalhada dos Canais
O conceito de canais é relativamente fácil de compreender. Em sua forma mais
básica, um canal é um conjunto de informações em forma de página Web que o
desenvolvedor definiu para remessa para aqueles usuários que assinaram para receber
esse tipo de informação. A maneira mais fácil de explicar os canais e seu potencial é
81
sair do mundo do computador e pensar sobre o mundo da televisão, mais
especificamente, o da TV a cabo. Ao fazer uma assinatura em uma operadora de TV a
cabo, o usuário normalmente tem acesso a uma opção chamada pay-per-view. Os canais
pay-per-view são aqueles que o usuário pode assinar para conteúdo específico que é
levado ao ar em um determinado horário. A operadora de TV a cabo lhe informa o que
há disponível, na maioria das vezes por meio de um canal de pré-visualização. O
usuário assina o conteúdo - a decisão de um campeonato ou um filme, por exemplo -,
discando para um número, digitando o número de sua conta de TV a cabo e
selecionando o número de identificação do programa mostrado no canal de prévisualização. Em um horário predeterminado, a empresa de TV a cabo libera o conteúdo
solicitado diretamente para seu aparelho. [PIT00]
Com canais da Web, a teoria é praticamente a mesma, exceto que o usuário
normalmente não tem que pagar. O conteúdo normalmente é grátis e pode ser acessado
por meio de um clique de um botão. Na televisão, um canal é basicamente um conjunto
de conteúdo como filmes, remetidos ao assinante em um horário predeterminado.
Entretanto, no computador, os canais enviam um conjunto de páginas Web, imagens,
sons e possivelmente arquivos de filmes. O arquivo que descreve o que se está
disponível no canal é chamado de arquivo CDF, e como qualquer aplicativo XML, o
arquivo CDF fornece uma descrição dos recursos disponíveis dentro do canal. Incluído
no índice do canal se encontra uma programação que descreve quando as informações
no canal serão atualizadas. Dependendo de como o canal é codificado, o assinante pode
especificar se essas informações são remetidas via tecnologia push para seu endereço de
e-mail, para a área de trabalho do computador ou para um protetor de tela. Depois de o
conteúdo ter sido recebido, o usuário pode então ver, manipular ou imprimir as
informações sem se conectar à Internet, pois todo o conteúdo é enviado para o
computador do usuário.
3.3.1.4.2 - Vantagens dos canais para o usuário
Sob o ponto de vista do usuário, os canais oferecem um acesso fácil a
informações. O botão Canais da barra de ferramentas do Internet Explorer lhe dá acesso
por meio de uma única operação de apontar-e-clicar com o mouse os canais, que
também serão acessíveis por meio do botão Canais na barra de ferramentas Iniciar
rapidamente. Assim que for ativado, o Channel Guide (guia de canais) exibe a lista de
82
canais que o usuário assina. Os canais oferecem a mesma acessibilidade que as páginas
Web, dispondo dos mesmos controles para a navegação. Os links ainda são
incorporados dentro do conteúdo e dependendo do nível da assinatura, as informações
podem ter mais do que uma página Web em termos de profundidade. O usuário não tem
de aprender novas técnicas de navegação, comandos especiais ou outros controles para
assinar, recolher ou ler informações. Desde que as informações remetidas para a área de
trabalho do usuário sejam apresentadas no formato HTML padrão, o assinante usa as
informações fornecidas no canal da mesma maneira que ele faria com informações
contidas em uma página Web.
Para o usuário, fazer a assinatura de canais é quase tão simples como dar
um clique sobre um ícone de uma página Web. O ícone, chamado de logotipo de canal,
pode residir em uma página Web posicionada em algum ponto do site ou pode ser
acrescentado ao Active Desktop do usuário ou ao painel Explorer do Internet Explorer.
Os assinantes podem usar tanto o Active Desktop do Internet Explorer como o Netcaster
da Netscape. Desde que o desenvolvedor tenha seguido o formato CDF, será indiferente
o mecanismo de navegação utilizado para ver os dados.
Todas as informações às quais o usuário faz uma assinatura são
atualizadas automaticamente.
O usuário não faz nada em termos de procurar ou
encontrar as novas informações em seu site. E melhor ainda, a atualização é feita em um
horário predeterminado, o que significa que o usuário tem de fazer o download do
conteúdo ou esperar que as páginas Web sejam carregadas. Basta ver o canal para que
sejam trazidas as informações mais recentes. Pelo fato de as informações virem via
download, o usuário poderá vê-las fora do ar.
3.3.1.4.3 - Vantagens dos canais para o desenvolvedor
Todas
essas
informações
fornecem
várias
vantagens
para
o
desenvolvedor de sites Web. Com o CDF, o desenvolvedor pode estender o conteúdo
em um site Web, remetendo-o para os usuários que talvez não saibam a respeito do
conteúdo ou não tenham o tempo necessário para ficar navegando. Como mencionado
anteriormente, o CDF é um excelente mecanismo para remeter conteúdo por meio de
páginas Web, e-mail, etc. Ele oferece aos desenvolvedores os seguintes benefícios:
[PIT00]
83
• Total controle sobre o envio das informações - O desenvolvedor pode
especificar exatamente o que e a quantidade de informações enviadas ao usuário.
Isso garante que o usuário pelo menos veja as informações que se quer que ele
veja, diferentemente de apenas postá-las em uma página Web que pode ou não ser
acessada pelos usuários que se quer atingir.
• A capacidade de personalizar conteúdo para o assinante - Os assinantes
podem selecionar o conteúdo que será enviado às suas áreas de trabalho
• A capacidade de fornecer acesso a usuários autorizados apenas por
meio de proteção via senha - Pelo fato de poder solicitar um nome de usuário e
uma senha dentro do arquivo CDF que se criou, é possível solicitar que apenas os
usuários que tenham nomes de usuários e senhas assinem as informações de
conteúdo. Esta opção, entretanto, não fornece certificação digital completa.
• A capacidade de controlar e registrar o número de acessos a páginas O desenvolvedor pode fazer um acompanhamento dos usuários para saber que
páginas estão sendo vistas e quais são recebidas via download, mas jamais foram
tocadas. Isso lhe ajuda a determinar que informações devem ser atualizadas e quais
informações os usuários não estão interessados em ler.
• Opções para remeter informações tendo como base a preferência do
assinante - O desenvolvedor pode dar ao usuário a opção de ver as informações
através de uma página Web, e-mail ou protetor de tela ou por meio de um canal
Active Desktop.
Ao empregar arquivos CDF dentro de um site, se está, basicamente,
configurando páginas Web que se destinam a um público interessado, o que significa
que as informações têm muito mais chance de ser lidas. Quando os usuários assinam um
canal, eles sabem que as informações serão atualizadas regularmente.
Em termos de desenvolvimento, você pode usar o conhecimento que já possui
para desenvolver o conteúdo do canal: [PIT00]
•
Não é preciso nenhuma ferramenta ou conhecimento adicional para criarse conteúdo. Pelo fato de os canais serem simplesmente páginas em
HTML, pode-se usar habilidades de desenvolvimento e layout, imagens e
programação atuais no conteúdo do canal.
84
•
O arquivo CDF pode ser personalizado por meio da tecnologia Active
Server Pages e outros Scripts CGI - além de scripts do lado do cliente
como cookies - para estender e personalizar o conteúdo do canal.
•
Pode-se automatizar a produção de arquivos CDF com produtos como
Microsoft
FrontPage
98
ou
Microsoft
CDF
Generator
(ww.microsoft.com/gallery/tools/ contents.htm), que é um aplicativo
separado que lhe permite criar arquivos CDF sem usar o FrontPage.
•
Os arquivos CDF lhe permitem organizar suas informações segundo uma
hierarquia - a mesma estrutura como acontece com qualquer outro
documento XML. Isso significa que os arquivos CDF podem ser vistos
por meio de vários analisadores sintáticos existentes hoje em dia. Isso
torna mais fácil organizar suas informações e apresentá-las a seus
assinantes em uma ordem lógica.
•
Ao empacotar o conteúdo em canais, você pode ter diferentes públicosalvo para diferentes tipos de informações.
• Pelo fato de os arquivos CDF serem aplicativos XML, você pode
começar a implementar XML em seu site de forma rápida e fácil.
3.3.1.4.4 - O relacionamento do XML com o CDF
Todo o conteúdo enviado ao assinante por meio de um canal é criado em HTML.
O XML não formata o conteúdo. Portanto, como o CDF se relaciona com o XML? O
XML fornece a estrutura por meio da qual o navegador encontra, descreve e remete o
conteúdo segundo a programação fornecida. O CDF é um aplicativo XML, o que
significa que a Microsoft desenvolveu uma lista de elementos CDF específicos que
seguem a sintaxe e convenções do XML, mas foram definidos com seus próprios
atributos. Esses elementos são usados para criar um canal. Ao criar um documento
XML que define o canal, seu conteúdo e seu mecanismo de remessa, usa-se a
declaração de documentos XML e segue os conceitos do XML de aninhar elementos
dentro de outros elementos. A única diferença é que se usam os elementos predefinidos
que a Microsoft criou para descrever um canal. [PIT00]
Para colocar de forma mais sucinta, pelo fato de o CDF ser uma aplicação em
XML, a especificação CDF depende muito do XML. Elementos, entidades, atributos e
85
regras de elementos, todos fazem parte do CDF, como os elementos aninhados,
declarações XML e o uso de links via URLs. Dominando a linguagem XML, dominarse-á o formato CDF. Os analisadores sintáticos XML analisam sintaticamente as
informações especificadas no CDF.
Especificamente, o CDF se baseia em uma DTD contendo informações que
apontam o navegador do usuário para a fonte de informações, informações descritivas
sobre o conteúdo e a programação para download das informações. O aplicativo CDF
consiste de um único elemento-raiz, um elemento a partir do qual todos os demais itens
dentro do canal se originam. Esse elemento-raiz único é chamado de elemento
<CHANNEL>. As ramificações a partir dele são chamadas elementos <ITEM>.
Podemos te vários elementos <ITEM>, mas somente um elemento
<CHANNEL> para escrever o canal. Os elementos <ITEM> especificam as páginas
individuais ou subpáginas que são filhas da raiz do canal. Com o CDF, apenas o
elemento <CHANNEL> e seu conteúdo são definidos na especificação CDF. [PIT00]
3.3.1.4.5 - Exemplo
Após especificar a hierarquia como o elemento <CHANNEL> e o conteúdo com
os elementos <ITEM>, deve-se incluir os elementos <LOGO> apropriados para cada
ícone e imagem. A ordem na qual isso é especificado não é importante. No entanto, se
eles não os especificar, o Internet Explorer usará os ícones padrão.
O arquivo CDR simples a seguir é declarado como um arquivo XML. Os ícones
e imagens são descritos com o elemento <LOGO> e os itens para o conteúdo do canal
são identificados com o elemento <ITEM>.[PIT00]
<?XML Version=”1.0”?>
<CHANNEL HREF= “http://www.site.com/mainpage.html” >
<ABSTRACT> Este é um modelo de canal </ABSTRACT>
<TITLE> Modelo de Canal </TITLE>
<LOGO HREF= “http: www.site.com/.ico” STYLE= “icon” />
<LOGO HREF= “http: www.site.com/.gif” STYLE= “image” />
<LOGO HREF= “http: www.site.com/-w.gif” STYLE= “image-wide” />
<ITEM HREF= “http://microsoft.com/workshop/author/dhtml/” >
<ABSTRACT> Artigos do Site Builder sobre DHTML </Abstract>
86
<TITLE> Artigos sobre Dynamic HTML <TITLE/>
</ITEM>
<ITEM HREF= “http://microsoft.com/workshop/prog/ie4/” >
<ABSTRACT> Artigos do Site Builder sobre autoria no Internet
Explorer
4.0 </ABSTRACT>
<TITLE> Tecnologias do Internet Explorer 4.0 </TITLE>
</ITEM>
</CHANNEL>
3.3.1.5 - DRP (Distribution and Replication Protocol)
O objetivo do protocolo DRP (Distribution and Replication Protocol) é
melhorar, de forma significativa, a eficiência e confiança dos dados distribuídos através
do HTTP. Aqui está uma lista mais detalhada dos objetivos: [W3CDRP01]
•
Fornecer um mecanismo para uma cópia eficiente de dados e conteúdos.
•
Aprimorar a eficiência e confiança dos provedores e proxies.
•
Segurança aperfeiçoada para a distribuição de dados e documentos
importantes.
•
Criar um padrão de interoperabilidade para replicação de conteúdo entre
clientes e servidores de diferentes fornecedores.
•
Sustentar um protocolo simples para evitar incompatibilidades.
•
Fornecer funcionalidade que é complementar aos padrões existentes.
•
Fornecer funcionalidade que é backward compatible (capacidade de uma
nova versão de um programa ou aparelho poder trabalhar de forma compatível com a
versão anterior) com servidores e proxies HTTP existentes.
•
Fornecer funcionalidade que pode ser desenvolvida em qualquer lugar
onde HTTP é disponível hoje em dia.
O HTTP DRP foi projetado para replicar, eficientemente, um conjunto
hierárquico de arquivos para um grande número de clientes. A concepção é feita sobre o
conteúdo ou tipo dos arquivos; eles são simplesmente arquivos em alguma organização
hierárquica.
87
Depois do download inicial, um cliente pode possuir os dados atualizados
usando o protocolo DRP. Usando DRP, o cliente pode fazer somente o download dos
dados que foram mudados desde a última vez em que foi ativado. Fazer somente o
download das diferenças é muito mais eficiente porque os dados se desenvolvem
lentamente através do tempo a porque as mudanças são, usualmente, restritas a somente
um subconjunto de dados. Um dos objetivos do protocolo DRP é evitar o download dos
mesmos dados mais de uma vez. [W3CDRP01]
Os dados que são distribuídos podem consistir em mais que apenas páginas
HTML. Pode consistir em qualquer tipo de código ou conteúdo. O protocolo DRP
fornece uma grande garantia sobre a versão dos dados. Isto é requerido para aplicações
que distribuem dados importantes porque conseguir a versão correta de cada
componente é necessário para assegurar que uma aplicação completa trabalhe
corretamente. Pegar a versão correta dos arquivos usando o HTTP existente para o
pedido é problemático porque não há um mecanismo confiável para a identificação de
uma versão particular de um arquivo.
O protocolo DRP usa um identificador de conteúdo para automaticamente
dividir recursos que são requeridos mais de uma vez. Isto elimina transferências
redundantes dos recursos geralmente utilizados. O identificador de conteúdo usado no
protocolo DRP é baseado na tecnologia amplamente aceita checksum ( verificação do
número de bits que estão sendo transferidos na rede para descobrir erros na
transferência).
O protocolo DRP usa uma estrutura de dados chamada index, que atualmente é
especificada usando a eXtensible Markup Language (XML). Pelo motivo de que index
descreve metadados, será usado o Resource Description Framework (RDF) numa versão
futura do protocolo DRP. XML é usado nesse meio tempo porque o padrão RDF ainda
não foi finalizado.
O Protocolo DRP conta com a funcionalidade do HTTP/1.1 para alcançar uma
performance melhor quando fizer cópia de arquivos e ele é backward compatible com o
proxies existentes HTTP/1.0 e HTTP/1.1, de forma que ele pode ser desenvolvido
imediatamente. Para fornecer um download mais eficiente do HTTP, a proposta
introduz novas informações no cabeçalho HTTP que, talvez, poderão tornar-se parte
do centro de especificações do protocolo HTTP.
O protocolo DRP é baseado na tecnologia que foi originalmente desenvolvida e
implementada por Marimba Inc. Embora fosse originalmente desenvolvida para
88
distribuição de software, esse protocolo é amplamente aplicado em diferentes áreas e
isso possibilita uma distribuição automática (e em larga escala) de software, dados e
conteúdos para diferentes clientes.
Para descrever o estado exato de um conjunto de arquivos de dados, o protocolo
DRP usa uma estrutura de dados chamada index. Um index não somente descreve a
estrutura hierárquica dos arquivos, mas também descreve a versão, o tamanho e o tipo
de cada arquivo. Um index é uma descrição instantânea de um conjunto de arquivos em
um determinado momento.
Um index é tipicamente armazenado como uma estrutura de dados em arvore,
mas para cliente e servidor passar essas informações através de http, um index pode ser
descrito usando XML. [W3CDRP01]
3.3.1.6 - XMI (XML Metadata Interchange )
O objetivo principal de XMI é permitir a facilidade na troca de metadados entre
ferramenta de modelagem (baseadas na OMG (Object Management Group) UML) e
depósitos de metadados (baseado em OMG MOF) em ambientes heterogêneos
distribuídos. XMI integra três coisas: [OMG01]
•
XML – eXtensible Markup Language, o padrão W3C
•
UML – Unified Modeling Language, o padrão da modelagem OMG
•
MOF – Meta Object Facility, o padrão OMG para modelagem e deposito de
metadados.
A integração desses três padrões no XMI une a melhor tecnologia de OMG e
W3C em relação a metadados e modelagem, permitindo que desenvolvedores de
sistemas distribuídos possam associar modelos de objetos e outros metadados através da
Internet.
Podemos definir XMI, também, como um “casamento” entre a tecnologia padrão
referente a Objetos(UML) e o padrão para trocas de dados através da internet (XML).
XMI permite aos desenvolvedores trabalhar em um ambiente colaborativo de
desenvolvimento para construir, armazenar e trocar modelos através da Internet, sem
levar em consideração plataforma, linguagem de programação ou ferramenta.
89
3.3.1.6.1 - DTD XMI e Estrutura de Documento
Como num documento XML, XMI também tem uma DTD. Todo DTD XMI
consiste nas seguintes declarações: [OMG01]
•
Uma instrução da versão XML. Ex: <? XML version=”1.0”?>
•
Uma declaração de codificação (opcional), que especifica o conjunto de
caracteres que seguem o padrão ISSO-10646. Ex: <?XML version=”1.0”
ENCODING = “UC2” ?>
•
Qualquer outra instrução de processos XML válida.
•
O requerimento da declaração XMI
•
Declarações para um metamodelo específico
•
Declarações para extensões
•
Todo documento XMI consiste nas seguintes declarações:
•
Uma instrução da versão XML
•
Uma declaração de codificação (opcional), que especifica o conjunto de
caracteres.
•
Qualquer outra instrução de processos XML válida.
•
Uma declaração de uma DTD exterma (opcional) com uma declaração de
uma DTD interna (opcional).
•
EX: <DOCTYPE XMI SYSTEM http://www.xmi.org/xmi.dtd >
3.3.1.6.2 - Atributos XMI necessários
Três atributos XML são definidos pela especificação para identificar elementos
XML. Logo, esses elementos XML podem ser associados pelos demais. O objetivo
desses atributos é permitir que os elementos XML referencie outro elememto XML
usando XML IDREFs, Xlinks e Xpointers.
Esses
atributos
são
declarados
em
uma
entidade
XML
chamada
XMI.element.att. Colocar esses atributos em uma entidade XML previne erros na
declaração desses atributos em DTDs. A declaração é a seguinte: [OMG01]
<!ENTITY % XMI.element.att
‘xmi.id
xmi.label
ID #IMPLIED
CDATA #IMPLIED
90
xmi.uuid
CDATA #IMPLIED’ >
xmi.id
A semântica XML requer que o valor desse atributo seja único dentro do
documento XML. De qualquer forma, o valor não é requerido para ser globalmente
único. Esse atributo pode ser usado como um valor do atributo xmi.idref. Ele pode
também ser incluído como parte dos valores do atributo href usando Xlinks. [OMG01]
xmi.label
Este atributo pode ser usado para permitir um label, identificando um elemento
particular XML. Usuários também podem colocar qualquer valor nesse atributo.
[OMG01]
xmi.uuid
O objetivo desse atributo é providenciar uma identificação única global para um
elemento XML. [OMG01]
3.3.1.6.2.1 - Atributos de Ligação
O propósito desses atributos é permitir que elementos XML ajam como simples
Xlinks ou para manter uma referência para um elemento no mesmo documento usando
XML IDREF.
Os atributos descritos nessa seção devem ser incluídos na DTD como uma
entidade XML. As entidades devem ser declaradas como se segue: [OMG01]
<!ENTITY % XMI.link.att
‘xml:link
CDATA
#IMPLIED
inline
(true|false)
#IMPLIED
actuate
(show|user)
#IMPLIED
href
CDATA
#IMPLIED
role
CDATA
#IMPLIED
title
CDATA
#IMPLIED
show
(embed|replace| new)
#IMPLIED
behavior
CDATA
#IMPLIED
xmi.idref
IDREF
#IMPLIED
xmi,uuidref CDATA
#IMPLIED’ >
91
Atributos Xlink Simples
Um
atributo
declarado
sobre
uma
entidade
(xml:link
através
de
comportamento) permite que um elemento XML aja como um XLink simples, de
acordo com as especificações de XLink e XPointer. XMI permite o uso de XLinks
simples. Para usar XLinks simples, é declarado xml:link=”simple”. O atributo href
pode ser usado para referenciar elementos XML como os atributos xmi.id, xmi.label or
xmi.uuid, que é um conjunto de valores particulares.
3.3.1.6.2.2 - Elementos XMI comuns
Toda DTD bem formata deve incluir as seguintes declarações de elementos
XML: [OMG01]
•
XMI
•
XMI.header
•
XMI.content
•
XMI.extensions
•
XMI.documentation
•
XMI.owner
•
XMI.contact
•
XMI.longDescription
•
XMI.shortDescription
•
XMI.explorer
•
XMI.exporterVersion
•
XMI..exporterID
•
XMI.notice
•
XMI.model
•
XMI.metamodel
•
XMI.difference
•
XMI.delete
•
XMI.add
•
XMI.replace
•
XMI.reference
92
•
XMI.field
•
XMI.struct
•
XMI.seqItem
•
XMI.sequence
•
XMI.arrayLen
•
XMI.array
•
XMI.enum
•
XMI.discrim
•
XMI.union
•
XMI.any
3.3.1.6.2.3 - Elemento XMI
O elemento de maior nível para cada documento XMI é o elemento XMI. Sua
declaração é: [OMG01]
<!ELEMENT XMI (XMI.header,
XMI.content?,
XMI difference*,
SMI.extensions*)>
<ATTLIST XMI
XMI,version CDATA #FIXED “1.0”
Timestamp
CDATA #IMPLIED
Verified (true | false) #IMPLIED >
O atributo xmi.version é requerido e fixado como “1.0”. Isso indica que o
metadado obedece a essa versão da especificação XMI.
3.3.1.6.2.4 - XMI.header
Esse elemento contém elementos XML que identifica o modelo, metamodelo e
metametamodelo de um metadado, assim como um elemento XML opcional que
contem várias informações sobre o metadado que ser transferido. Sua declaração é:
[OMG01]
93
<!ELEMENT XMI.header (XMI.documentation?,
XMI.model*,
XMI.metamodel*,
XMI.metametamodel*) >
3.3.1.6.2.5 - XMI.content
É o elemento que contém o metadado atual que está sendo transferido. Ele pode
representar as informações do modelo ou informações do metamodelo. Sua declaração
é: [OMG01]
<!ELEMENT XMI.content ANY >
3.3.1.6.2.6 - XMI.extensions
É o elemento que contém elementos XML que contém metadado que é uma
extensão de um metamodelo. Esta informação deve incluir informações da apresentação
associada ao metadado, por exemplo. Sua declaração é: [OMG01]
<!ELEMENT XMI.extensions ANY >
<!ATTLIST XMI.extensions
xmi.extender CDATA #REQUIRED
>
3.3.1.6.2.7 - XMI.documentation
Este elemento XML contém informações sobre o metadado a ser ransferido
como, por exemplo, o dono do metadado, a pessoa contactada pelo metadado,
descrições, longas ou curtas, do metadado, a ferramenta que criou o metadado, a versão
da ferramenta, copyright, etc. Sua declaração é: [OMG01]
<!ELEMENT XMI.documentation (#PCDATA |
XMI.owner | XMI.contact |
XMI.longDescription |
XMI.shortDescription | XMI.exporter |
XMI.exporterVersion | XMI.notice)* >
94
<!ELEMENT XMI.owner ANY >
<!ELEMENT XMI.contact ANY >
<!ELEMENT XMI.longDescription ANY >
<!ELEMENT XMI.shortDescription ANY >
<!ELEMENT XMI.exporter ANY >
<!ELEMENT XMI.exporterVersion ANY >
<!ELEMENT XMI.exporterID ANY >
<!ELEMENT XMI.notice ANY >
3.3.1.6.2.8 - XMI.model
Elemento XML que identifica o modelo conforme os dados têm sido
instanciados. Pode haver modelos múltiplos, se o modelo que está sendo transferido
obedece a mais de um modelo. Sua declaração é: [OMG01]
<!ELEMENT XMI.model ANY>
<!ATTLIST XMI.model
%XMI.link.att;
xmi.name CDATA #REQUIRED
xmi.version CDATA #REQUIRED
>
Os atributos xmi.name and xmi.version são o nome e a versão do metamodelo,
respectivamente.
3.3.1.6.2.9 - XMI.metamodel
Este elemento XML identifica o metamodelo, o qual, o modelo de dados que é
transferido obedece. Pode haver metamodelos múltiplos, se o modelo de dados que é
transferido obedece a mais de um metamodelo. É esperado que este elemento se torne
um XLink simples quando é usada uma recomendação dos W3C. Sua declaração é:
[OMG01]
<!ELEMENT XMI.metamodel ANY>
<!ATTLIST XMI.metamodel
%XMI.link.att;
xmi.name CDATA #REQUIRED
95
xmi.version CDATA #REQUIRED
>
Os atributos xmi.name and xmi.version são o nome e a versão do metamodelo,
respectivamente.
3.3.1.6.2.10 - XMI.difference
Este elemento XML guarda elementos XML que representam diferenças para
dados base. Usuários podem usa-lo dentro da parte que contém um arquivo XMI ou em
um XMI.difference numa seção separada. Os atributos, neste elemento, permitem fazer
referências a outros elementos XLinks usando, XPointers, ou IDREFs. Sua declaração
é: [OMG01]
<!ELEMENT XMI.difference (XMI.difference | XMI.add | XMI.delete |
XMI.replace)* >
<!ATTLIST XMI.difference
%XMI.element.att;
%XMI.link.att;
>
3.3.1.6.2.11 - XMI.delete
Este elemento XML representa uma deleção para o metadata base. Ele deve estar
dentro de um elemento XML XMI.difference. Os atributos neste elemento permitem
referências para serem feitas a outros elemento se usando XLinks, XPointers, ou XML
IDREFs. Sua declaração é: [OMG01]
<!ELEMENT XMI.delete EMPTY >
<!ATTLIST XMI.delete
%XMI.element.att;
%XMI.link.att;
>
3.3.1.6.2.12 - XMI.add
96
Este elemento XML representa uma adição para o metadata base. Ele deve estar
dentro de um elemento XML XMI.difference. Os atributos neste elemento permitem
referências para serem feitas a outros elemento se usando XLinks, XPointers, ou XML
IDREFs. Sua declaração é: [OMG01]
<!ELEMENT XMI.add ANY >
<!ATTLIST XMI.add
%XMI.element.att;
%XMI.link.att;
xmi.position CDATA "-1"
>
O atributo xmi.position
indica o local onde será feita a adição de outro
elemento XML.
3.3.1.6.2.13 - XMI.replace
Este elemento XML representa uma substituição de metadata base com outro
metadata. Isso deve estar dentro de um elemento XML XMI.difference. Os atributos,
neste elemento, permitem fazer referências a outros elementos usando XLinks,
XPointers, ou XML IDREFs. Sua declaração é: [OMG01]
<!ELEMENT XMI.replace ANY >
<!ATTLIST XMI.replace
%XMI.element.att;
%XMI.link.att;
xmi.position CDATA "-1"
>
3.3.1.6.2.14 - XMI.reference
Este elemento XML permite referências a outros elementos XML dentro de um
atributo do tipo string ou um elemento XMI.any, que representa um tipo de dados no
qual não é definido o metamodelo. Deveria ser usado dentro de um elemento XMI.any
ou em atributos para especificar um valor remoto. Sua declaração é: [OMG01]
<!ELEMENT XMI.reference ANY >
<!ATTLIST XMI.reference %XMI.link.att; >
97
3.3.1.6.3 - Exemplo
Esse exemplo foi gerado através do uso da ferramenta ArgoUML, que gera o
documento XMI automaticamente. O documento XMI gerado é um tanto quanto
extenso, por isso o seu código não será mostrado aqui. Apesar disso, no Anexo 2 é
mostrado o código do documento XMI da Aplicação XML feita como exemplo nesse
projeto. Mais detalhes dessa Aplicação pode ser vista no Anexo 2.
Figura 3.3.1: Diagrama de Use Case
Figura 3.3.2: Diagrama de Classes
98
4 .0 – RESULTADOS E DISCUSSÕES
4.1 - Arquitetura XML
Esta arquiteturaestá sendo proposta no projeto objetivando a sua
utilização em aplicações distribuídas.
Na primeira camada, encontram-se as estruturas de cada documento
XML, que são desenvolvidas através da criação de documentos Schemas ou DTD’s.
Esses, definem regras para a especificação de uma classe de documentos tais como, os
tipos de elementos que podem existir, seus atributos e como as instâncias desses
elementos podem estar hierarquicamente relacionadas. DTD’s e Schemas também
podem conter linguagens tais como: XLINK e XPOINTER (que também permite a
utilização sintaxe XPATH).
Seguindo-se na hierarquia, a próxima camada é definida como o
documento XML propriamente dito, ou seja, um documento construído utilizando as
definições contidas em uma determinada DTD ou Schema e as especificações da
linguagem XML.
Na camada 3, observam-se documentos de aplicativos XML, neste caso,
são citados os aplicativos XMI, SMIL e XMath. Em geral, um aplicativo XML é uma
DTD, ou conjunto de DTD’s, com um objetivo específico. Ele é escrito e mantido de
maneira padronizada e com documentação apropriada.
Na próxima camada, existem documentos utilizados para apresentação de
aplicativos XML no ambiente WWW. Para tanto são criadas folhas de estilo (XSL,
XSLT e CSS) que associam regras de formatação a elementos diferentes em um
documento e instrui o navegador sobre como formatar tais elementos e seus conteúdos
para visualização.
Representações:
-
Linha contínua grossa: determina que a camada inferior deve ser seguida,
obrigatoriamente, pela camada superior .
-
Linha contínua fina: determina que a camada inferior pode ou não ser
seguida pela camada superior .
99
-
Linha pontilhada: determina que os dois níveis em questão não
representam camadas distintas.
HTML
4
Aplicativo de Mídia
XSLT
XSL
SMIL
3
XMI
XPATH
CSS
XMATH
XML
2
XLINK
XPATH
XLINK
XPATH
1
XPOINTER
DTD
XPOINTER
SCHEMA
Figura 4.1.1: Arquitetura XML
4.2 – Descrição do Exemplo
O exemplo consiste na criação de uma página feita em linguagem XML,
utilizando várias tecnologias da mesma. Simulou-se o desenvolvimento de uma página
que auxiliaria os desenvolvedores de um sistema de controle de um Evento do
Departamento de Informática.
Através dessa página, os desenvolvedores teriam acesso a todos os diagramas
UML gerados até o momento, juntamente com as informações de seu autor.
100
As ferramentas utilizadas para a contrução da página foram:
•
XMLSpy 3.5 – Contrução da DTD, do documento XML propriamente dito e
da folha de estilo (XSL);
•
ArgoUML – Utilizado para a construção do diagrama UML. Faz a geração
automática do documento XMI;
•
Xalan – Gera o documento HTML a partir de um documento XMI e uma
folha de estilo adequada.
4.2.1 – Documento de Tipo de Definição (DTD)
Os elementos criados na DTD são específicos da página em questão. Abaixo está
o código da DTD utilizada:
<?xml version="1.0" encoding="UTF-8"?>
<!ELEMENT pagina (texto, dados+)>
<!ELEMENT texto (#PCDATA)>
<!ELEMENT dados (desc, autor, instituicao, data, link)>
<!ELEMENT desc (#PCDATA)>
<!ELEMENT autor (#PCDATA)>
<!ELEMENT instituicao (#PCDATA)>
<!ELEMENT data (#PCDATA)>
<!ELEMENT link (#PCDATA)>
Foi criado um elemento raiz chamado pagina que contém os elementos texto e
dados. O elemento texto é do tipo #PCDATA, que significa uma cadeia de caracteres. O
elemento dados contém os elementos desc, autor, instituição, data e link, que também
são do tipo #PCDATA.
4.2.2 – Documento XML
Esse documento utiliza a DTD descrita na linha:
<!DOCTYPE pagina SYSTEM "pag.dtd">
101
Os dados que serão mostrados na página, são especificados nessa parte da
programação da aplicação XML. No documento XML também é referenciada a folha de
estilo correspondente:
<?xml-stylesheet type="text/xsl" href="pag.xsl"?>
Segue abaixo, parte do documento:
<?xml version="1.0" encoding="UTF-8"?>
<!-- edited with XML Spy v3.5 (http://www.xmlspy.com) by dffavero (Home) ->
<!DOCTYPE pagina SYSTEM "pag.dtd">
<?xml-stylesheet type="text/xsl" href="pag.xsl"?>
<pagina>
<texto> O Departamento de Informática estará sediando um
evento científico e estará recebendo, de interessados, trabalhos que deverão
ser avaliados. Para tal, estes trabalhos serão enviados para os avaliadores
competentes de acordo com a área de especificidade de cada um. Cada
avaliador poderá receber vários trabalhos para avaliar dependendo da
demanda e também cada um dos trabalhos pode ser analisado por vários
avaliadores. Dependendo da avaliação, os trabalhos poderão ser
desclassificados ou selecionados para apresentação e publicação nos anais
correspondentes. Portanto, os anais serão constituídos pelos trabalhos
selecionados. Todo participante deverá se inscrever no evento. Um
participante poderá fazer uma inscrição preliminar que poderá depois ser
confirmada. No momento da confirmação, deverá ter sido efetuado o
pagamento da taxa correspondente. Eventualmente, uma inscrição poderá
ser cancelada. As inscrições confirmadas serão efetivadas, o que implicará
na geração do número de inscrição. Cada participante receberá um crachá
no primeiro dia do evento e também um certificado ao final do evento. Os
perticipantes poderão ser classificados em: apresentadores, convidados e
ouvintes. Os participantes convidados terão as reservas de hotel e
passagem custeadas pelo evento.
</texto>
102
<dados>
<desc>Diagrama de Classes </desc>
<autor>Débora Rodrigues Rebello</autor>
<instituicao>UEM</instituicao>
<data>09/09/2001</data>
<link>http://www.din.uem.br/~drrebell/evento/diagclasse1.xmi</link>
</dados>
...
<dados>
<desc>Diagrama de Use Case</desc>
<autor>Beatriz do Carmo Langiano</autor>
<instituicao>UEM</instituicao>
<data>09/09/2001</data>
<link>http://www.din.uem.br/~drrebell/evento/diagusecase1.xmi</link>
</dados>
</pagina>
4.2.3 – Documento XSL
Esta folha de estilo tem por finalidade fazer a transformação do documento
XML para HTML. Desta forma, foram utilizadas as tags html e os comandos XSL
responsáveis por processar todos os nós presentes no documento XML. Segue abaixo o
documento XSL:
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/TR/WD-xsl"
xmlns:xlink="http://www.w3.org/1999/xlink">
<!--"http://www.w3.org/1999/XSL/Transform"
xmlns:fo="http://www.w3.org/1999/XSL/Format"-->
<xsl:template match="/">
<html>
103
<body background= "blue3.jpg">
<head ><h2 align="center"><b><font size="+4" color="white">Evento
do DIN</font></b></h2></head><br/>
<p><dd style="TEXT-ALIGN: justify"> <xsl:value-of
select="pagina/texto"/>
</dd></p><br/> <br/>
<p align="center"><font size="+2" color="white"><u> Diagramas
UML</u></font></p><br/>
<xsl:for-each select="pagina/dados">
<p align="center"><b><xsl:value-of select="desc"/></b><br/>
Autor: <xsl:value-of select="autor"/><br/>
Instituição: <xsl:value-of
select="instituicao"/><br/>
Data: <xsl:value-of select="data"/><br/>
<a> <xsl:attribute name="href"> <xsl:value-of
select="link" />
</xsl:attribute> Visualizar diagrama
</a></p>
</xsl:for-each>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
4.2.4 – Documento XMI
O documento XMI foi gerado pela ferramenta ArgoUML. Nessa ferramenta é
construído o diagrama UML e um documento XMI referente a esse diagrama é gerado
automaticamente.
Foi feito um diagrama XMI para cada diagrama citado na página mas, como o
documento XMI gerado é muito extenso, somente o código de um diagrama UML
(diagrama de classes) acompanha este relatório.
Pelo fato de XMI ser um aplicativo XML, a estrurura do seu documento segue as
mesmas especificações de um documento XML.
104
A Figura 4.2.1 representa o diagrama de classe feito na ferramenta ArgoUML:
Figura 4.2.1: Diagrama de Classes feito no ArgoUML
4.2.5 – Resultados Obtidos
Para um documento XMI ser exibido na Web, deve ser gerado um documento
HTML a partir dele. Com uma folha de estilo apropriada, foi utilizada a ferramenta
Xalan para gerar esse documento HTML.
As figuras 4.2.2 e 4.2.3 mostram como essas classes aparecem no documento
HTML.
Figura 4.2.2: Classe Participante, Mostrada no Documento HTML
105
Figura 4.2.3: Classe Apresentador, Mostrada no Documento HTML
O código desse documento XMI pode ser visto no Anexo 2.
106
Utilizando os arquivos .xsl, .xml, .dtd, .xmi descritos nessa sessão, obteve-se a
seguinte página (dividida em 2 partes para uma melhor visualização):
Figura 4.2.4 – Parte Superior da Página
107
Figura 4.2.5 – Parte Inferior da Página
4.3 – Arquitetura X Aplicação XML
Devido a simplicidade do exemplo, muitos dos componentes da arquitetura não
foram utilizados.
A principio, criou-se o documento DTD conforme mostrado no item 4.2.1
(Exemplo) e na camada 1 da Figura 4.1. Em seguida, o documento XML foi construído
de acordo com as especificações da DTD (como observado na Figura 4.1, quando existir
uma DTD, ela deve ser seguida de um documento XML).
Documentos XMI foram contruídos a fim de representarem os diagramas UML
que seriam apresentados na página. Por ser uma linguagem definida, XMI tem um DTD
próprio, não sendo necessária sua construção.
108
Com posse desses documentos (XML e XMI), foram elaborados documentos
XSL, responsáveis pela transformação para HTML (como pode ser observado na
camada 4 camada da Arquitetura), sendo possível a visualização desses documentos no
browser Internet Explorer 5.5.
109
5.0 - CONCLUSÃO
O estudo dessa nova linguagem permitiu a aquisição de um conhecimento
considerável de programação em ambiente WWW a partir do desenvolvimento de casos
de estudos, práticos e teóricos, quanto à semântica do documento XML, observando-se
a aplicabilidade no que diz respeito ao desenvolvimento de software distribuído.
Diante do vasto conjunto de analisadores sintáticos e Parsers encontrados
durante a pesquisa, pode-se dizer que cada um deles foi construído de maneira bastante
específica às características do sistema ao qual é utilizado. Já com relação às APIs, que
até então são em pouco número para documentos do tipo XML, mesmo que em alguns
aspectos se adequam melhor em determinados sistemas, constatou-se características
genéricas para aplicação na linguagem XML em ambientes distribuídos .
A crescente popularidade de XML tem proporcionado o surgimento de vários
sites e lançamento de livros. A primeira ferramenta utilizada para desenvolvimento
prático de páginas e documentos do tipo XML, foi a XML SPY. Uma ferramenta de
fácil compreensão que permite ao programador optar por vários tipos de arquivos (como
.xml, .dtd, .schema, .xmath, etc), contribuindo assim para uma introdução bastante
abrangente dentro da linguagem.
Através do estudo das linguagens de representação de documentos XML, foi
possível concluir que cada uma destas linguagens possui suas aplicações apropriadas;
deste modo as vantagens e desvantagens de utilizá-las estão relacionadas com a
aplicação correspondente.
Em aplicações mais simples, há várias razões para usar CSS. A principal é que
as CSS são fáceis de serem aprendidas e implementadas, pois foram projetadas para
HTM (por isso elas já se encontram em amplo uso na Web).
Porém em casos de aplicações mais complexas, o uso de CSS não é
recomendável devido a alguns fatores, entre eles: as CSS não conseguem gerar textos e
não se constituem em uma linguagem de programação (elas não suportam estruturas de
decisão de suporte). Por estas razões, desenvolveu-se a XSL. Além de suprir estas
deficiências, a XSL também pode acrescentar ou remover elementos em um arquivo,
pode rearranjar e classificar os elementos, testar e tomar decisões sobre como um
110
elemento será exibido, e muito mais. O principal ponto forte de XSL é que ela foi
desenvolvida para trabalhar especificamente com XML.
A especificação XLink destaca-se pelo fato de fornecer controle sobre a
semântica do link e introduzir links extendidos, os quais podem envolver mais de dois
recursos. Já a linguagem XPointer destaca-se por fornecer um método sofisticado de
localização de recursos,
permitindo a localização de recursos arbitrários em um
documento, sem que seja necessário que tal recurso seja identificado com um atributo
ID. Tanto a linguagem XLink quanto a XPointer são capazes de fazer ligações a
documentos quando se trata do desenvolvimento de um software distribuído
O estudo de novas linguagens que surgiram a partir da XML, os chamados
Aplicativos XML, possibilitou um contato maior com várias dessas linguagens dando,
pelo menos, uma noção básica do que cada uma propunha. Dentre essas linguagens,
algumas se adequaram ao propósito desse projeto e foram estudadas com mais cuidado.
A linguagem UXF, usada para representar diagramas UML foi muito
interessante no começo dos estudos, mas com o tempo, foi tornando-se inviável a
continuidade desse estudo pelo fato de que se tratava de uma linguagem muito recente,
ainda em fase de desenvolvimento e não foi encontrada uma ferramenta que desse
suporte a essa linguagem, por menor que fosse.
Diante dessa barreira, a busca por uma linguagem semelhante a essa se iniciou.
Foi então que começou o estudo da linguagem XMI que tinha uma proposta muito
parecida com a UXF e já havia várias ferramentas que davam suporte a essa linguagem
como, por exemplo, Together, Rational Rose e ArgoUML. Foi usada essa última para o
desenvolvimento de arquivos XMI.
Pode-se observar que a linguagem XMI ofereceu o resultado esperado. Sendo
assim, ela mostrou-se muito útil para ser usada no desenvolvimento de software
distribuído, visto que possibilita aos desenvolvedores a troca de diagramas UML.
A simplicidade da aplicação exemplo se deve ao fato de que o intuito desta não
era fazer um exemplo complexo da linguagem, mas sim possibilitar uma visão geral de
como funciona e como são aplicadas a linguagem XML e suas derivadas. Isso
proporcionou um conhecimento prático considerável do que foi estudado.
111
BIBLIOGRAFIA
[PIT00] Pitts-Moultis, N. e Kirk, C. XML Black Book. Editora Makron Books. São
Paulo. 2000
[CAS01] CASTRO, E. XML para a World Wide Web. Rio de Janeiro: Campos, 2001
[JUN01] Junichi Suzuki - UML Exchange Format & Pattern Markup Language –
Último Acesso: 02/09/2001
http://www.yy.ics.keio.ac.jp/~suzuki/project/uxf/uxf.html
[SMIL01] Synchronized Multimedia (SMIL) – Último Acesso – 02/09/2001
http://www.w3.org/AudioVideo/
[SMIL99] The SMIL Tutorial – Ultimo Acesso – 28/112001
http://www.helio.org/products/smil/tutorial
[W3CRDF01] Resource Description Framework (RDF) Model and Syntax
Specification Último Acesso: 02/09/2001
http://www.w3.org/TR/1999/REC-rdf-syntax-19990222/
[W3CWIDL01] Web Interface Definition Language (WIDL) – Último Acesso:
02/09/2001
http://www.w3.org/TR/NOTE-widl
[W3CDRP01] The HTTP Distribution and Replication Protocol (DRP) – Último
Acesso: 02/09/2001
http://www.w3.org/TR/NOTE-drp-19970825
[XML01] A Technical Introduction to XML – Último Acesso: 02/09/2001
http://www.xml.com/pub/a/98/10/guide0.html
[W3CXML01] Extensible Markup Language (XML) – Último Acesso: 02/09/2001
112
http://www.w3.org/XML
[OMG01] XML Metadata Interchange (XMI) - Último Acesso: 25/0/2001
ftp://ftp.omg.org/pub/docs/ad/98-10-95.pdf
[W3C 01a] W3C Recomendation: XML Tutorial – Último Acesso: 01/09/2001
http://www.w3schools.com/xml
[W3C 01b] W3C Recommendation:Extensible Stylesheet Language(XSL) –Último
Acesso:01/11/2001
http://www.w3.org/TR/xsl/
[W3C 01c] W3C Recommendation: Cascading Style Sheets, level 1CSS1 – Último
Acesso: 20/11/2000
http://www.w3.org//TR/REC/-CSS1
[W3C 01d] W3C Recomendation: Extensible Stylesheet Language (XSL) – Último
Acesso:01/09/2001
http://www.w3.org/Style/XSL
[W3C 01e] W3C Recomendation. XML Linking Language (XLink) – Último Acesso:
01/09/2001
http://www.w3.org/TR/XLink
[NEN00] Nentwich, Christian. XTooX – XLink processor – Último Acesso: 21
/052/2002
http://www.xlinkit.com/xtoox/index.html
[W3C 01f] W3C Recomendation. XML Pointer Language (XPointer) – Último Acesso:
01/09/2001
http://www.w3.org/TR/xptr
[W3C 01g] W3C Recomendation. XML Path Language – Último Acesso: 01/09/2001
http://www.w3.org/TR/xpath
113
[BUS00]Buss, Sidney e Kawassaki,Vanesssa. Desenvolvimento WEB- Estudos de
Tecnologia- PUC – PR - Último Acesso: 01/09/2001
http://espec.ppgia.pucpr.br/~sbuss/tecno/default.htm
Definições XML - Ultimo Acesso: 15/03/2001
http://www.xmlx.com
Definições Básicas XML – Último Acesso: 05/08/2001
http://www.xml.com
DOM & SAX – Último Acesso: 23/08/2001
http://www.developerlife.com
Utilização SAX: Último Acesso: 23/08/2001
http://www.megginson.com
MSXML – Último Acesso: 20/05/2001
http://msdn.microsoft.com/downloads/default.asp?URL=/code/sample.asp?url=/
msdn-files/027/000/541/msdncompositedoc.xml
Aelfred – Último Acesso – 15/08/01
http://www.opentext.com/services/content_management_services/xml_sgml_sol
utions.html#aelfred_and_sax
Expat – Último Acesso: 20/05/2001
http://www.jclark.com/xml/expat.html
Definições de Todas as Linguagens XML – Último Acesso: 23/08/2001
http://www.w3cschools.com
SAXHistory – Último Acesso: 23/08/2001
http://www.megginson.com/SAX/SAX1/history.html
114
The Simple API for XML – Último Acesso: 20/08/2001
http://www.coputer.org/internet/v2n3/xml-sax.htm
Quick Start Aplication Writers – Último Acesso: 21/08/2001
http://www.megginson.com/SAX/SAX1/quickstart.html
SAX - Último Acesso: 05/08/2001
http://matwww.ee.tut.fi/~onykane/courses/prj/xmlsem2000/ht/vitanen.html,
115
ANEXOS
Anexo 1: Documento UXF referente ao exemplo da seção 3.1.3.2
<?xml version="1.0"?>
<!DOCTYPE UXF SYSTEM "uml.dtd">
<UXF Version="2.0"
xmlns:UXF="http://www.yy.cs.keio.ac.jp/~suzuki/project/uxf/">
<UXF:TaggedValue>
<UXF:Tag>Model
Name</UXF:Tag><UXF:Value>Polygon
Sample</UXF:Value>
<UXF:Tag>Author</UXF:Tag><UXF:Value>Junichi Suzuki</UXF:Value>
<UXF:Tag>Date</UXF:Tag><UXF:Value>19, Feb. 1999</UXF:Value>
<UXF:Tag>Version</UXF:Tag><UXF:Value>1.0</UXF:Value>
</UXF:TaggedValue>
<Package>
<Name>UXF Sample Description</Name>
<ClassDiagram>
<Name>Polygon</Name>
<Class>
<Name>Polygon</Name>
<IsAbstract>true</IsAbstract>
<Attribute>
<Name>points</Name>
<Type>Point</Type>
<Visibility>private</Visibility>
</Attribute>
<Attribute>
<Name>bundle</Name>
<Type>GraphicsBundle</Type>
116
<Visibility>private</Visibility>
</Attribute>
</Class>
<Class>
<Name>Triangle</Name>
</Class>
<Class>
<Name>Point</Name>
<Attribute>
<Name>x</Name>
<Type>Real</Type>
<Visibility>private</Visibility>
<InitialValue>0.0</InitialValue>
</Attribute>
<Attribute>
<Name>y</Name>
<Type>Real</Type>
<Visibility>private</Visibility>
<InitialValue>0.0</InitialValue>
</Attribute>
<Operation>
<Name>rotate</Name>
<Visibility>public</Visibility>
<ReturnType>void</ReturnType>
<Parameter>
<Name>angle</Name>
<Type>Real</Type>
</Parameter>
</Operation>
<Operation>
<Name>scale</Name>
<Visibility>public</Visibility>
<ReturnType>void</ReturnType>
117
<Parameter>
<Name>factor</Name>
<Type>Real</Type>
</Parameter>
</Operation>
</Class>
<Exception>
<Note>This
is
a
SystemException.
Exception
Element
is
defined
in
common_behavior.dtd.</Note>
<Name>SystemException</Name>
<Context>Point.scale</Context>
<Attribute>
<Name>errorMsg</Name>
<Type>String</Type>
</Attribute>
</Exception>
<Class>
<Name>GraphicsBundle</Name>
<Attribute>
<Name>color</Name>
<Type>Color</Type>
<Visibility>public</Visibility>
</Attribute>
</Class>
<Generalization>
<Parent>Polygon</Parent>
<Child>Triangle</Child>
</Generalization>
<Association>
<AssociationName>
118
<Name>Contains</Name>
<Direction>
<Source><Type>Polygon</Type></Source>
<Target><Type>Point</Type></Target>
</Direction>
</AssociationName>
<AssociationEnd>
<Type>Polygon</Type>
<AggregationKind>AggregationWhole</AggregationKind>
<Multiplicity>1</Multiplicity>
</AssociationEnd>
<AssociationEnd>
<Type>Point</Type>
<Name>points</Name>
<AggregationKind>AggregationPart</AggregationKind>
<Multiplicity>3..*</Multiplicity>
<Ordering>ordered</Ordering>
</AssociationEnd>
</Association>
<Association>
<AssociationEnd>
<Type>Polygon</Type>
<AggregationKind>AggregationWhole</AggregationKind>
<Multiplicity>1</Multiplicity>
</AssociationEnd>
<AssociationEnd>
<Type>GraphicsBundle</Type>
<Name>bundle</Name>
<AggregationKind>AggregationPart</AggregationKind>
<Multiplicity>1</Multiplicity>
</AssociationEnd>
</Association>
</ClassDiagram>
119
</Package>
</UXF>
Esse seria o diagrama referente ao código acima, construído aplicando-se a folha
de estilo XSL.
120
Anexo 2: Documento XMI referente ao exemplo da Aplicação XML.
<?xml version="1.0" encoding="UTF-8"?>
<XMI xmi.version="1.0">
<XMI.header>
<XMI.documentation>
<XMI.exporter>Novosoft UML Library</XMI.exporter>
<XMI.exporterVersion>0.4.19</XMI.exporterVersion>
</XMI.documentation>
<XMI.metamodel xmi.name="UML" xmi.version="1.3"/>
</XMI.header>
<XMI.content>
<Model_Management.Model xmi.id="xmi.1" xmi.uuid="-87--2-57-37-5c9766:e95116ff04:-8000">
<Foundation.Core.ModelElement.name>untitledModel</Foundation.Core.Mode
lElement.name>
<Foundation.Core.ModelElement.isSpecification
xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isRoot
xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isLeaf
xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isAbstract
xmi.value="false"/>
<Foundation.Core.Namespace.ownedElement>
<Foundation.Core.Class
xmi.id="xmi.2"
xmi.uuid="-87--2--57-37-5c9766:e95116ff04:-7fff">
<Foundation.Core.ModelElement.name>Participante</Foundation.Core.ModelE
lement.name>
<Foundation.Core.ModelElement.isSpecification
xmi.value="false"/>
121
<Foundation.Core.GeneralizableElement.isRoot
xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isLeaf
xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isAbstract
xmi.value="false"/>
<Foundation.Core.Class.isActive xmi.value="false"/>
<Foundation.Core.ModelElement.namespace>
<Foundation.Core.Namespace xmi.idref="xmi.1"/>
</Foundation.Core.ModelElement.namespace>
<Foundation.Core.GeneralizableElement.specialization>
<Foundation.Core.Generalization
xmi.idref="xmi.3"/>
<Foundation.Core.Generalization
xmi.idref="xmi.4"/>
<Foundation.Core.Generalization
xmi.idref="xmi.5"/>
</Foundation.Core.GeneralizableElement.specialization>
<Foundation.Core.Classifier.feature>
<Foundation.Core.Operation xmi.id="xmi.6">
<Foundation.Core.ModelElement.name>inserir</Foundation.Core.ModelEleme
nt.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.BehavioralFeature.isQuery
xmi.value="false"/>
<Foundation.Core.Operation.isRoot xmi.value="false"/>
<Foundation.Core.Operation.isLeaf xmi.value="false"/>
<Foundation.Core.Operation.isAbstract
xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.2"/>
</Foundation.Core.Feature.owner>
122
</Foundation.Core.Operation>
<Foundation.Core.Operation xmi.id="xmi.7">
<Foundation.Core.ModelElement.name>remover</Foundation.Core.Mo
delElement.name>
<Foundation.Core.ModelElement.isSpecification
xmi.value="false"/>
<Foundation.Core.BehavioralFeature.isQuery
xmi.value="false"/>
<Foundation.Core.Operation.isRoot
xmi.value="false"/>
<Foundation.Core.Operation.isLeaf
xmi.value="false"/>
<Foundation.Core.Operation.isAbstract
xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier
xmi.idref="xmi.2"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Operation>
<Foundation.Core.Operation
xmi.id="xmi.8">
<Foundation.Core.ModelElement.name>consultar</Foundation.Core.ModelEle
ment.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.BehavioralFeature.isQuery
xmi.value="false"/>
<Foundation.Core.Operation.isRoot xmi.value="false"/>
<Foundation.Core.Operation.isLeaf xmi.value="false"/>
<Foundation.Core.Operation.isAbstract xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.2"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Operation>
<Foundation.Core.Operation xmi.id="xmi.9">
123
<Foundation.Core.ModelElement.name>alterar</Foundation.Core.Model
Element.name>
<Foundation.Core.ModelElement.isSpecification
xmi.value="false"/>
<Foundation.Core.BehavioralFeature.isQuery
xmi.value="false"/>
<Foundation.Core.Operation.isRoot xmi.value="false"/>
<Foundation.Core.Operation.isLeaf xmi.value="false"/>
<Foundation.Core.Operation.isAbstract xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.2"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Operation>
<Foundation.Core.Attribute xmi.id="xmi.10">
<Foundation.Core.ModelElement.name>nome</Foundation.Core.Model
Element.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier
xmi.idref="xmi.2"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Attribute>
<Foundation.Core.Attribute xmi.id="xmi.11">
<Foundation.Core.ModelElement.name>endereço</Foundation.Core.ModelElement.n
ame>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.2"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Attribute>
<Foundation.Core.Attribute xmi.id="xmi.12">
<Foundation.Core.ModelElement.name>cidade</Foundation.Core.Mode
lElement.name>
124
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.2"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Attribute>
<Foundation.Core.Attribute xmi.id="xmi.13">
<Foundation.Core.ModelElement.name>RG</Foundation.Core.ModelElement.n
ame>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.2"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Attribute>
<Foundation.Core.Attribute xmi.id="xmi.14">
<Foundation.Core.ModelElement.name>CIC</Foundation.Core.ModelElement.
name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.2"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Attribute>
</Foundation.Core.Classifier.feature>
</Foundation.Core.Class>
<Foundation.Core.Class
xmi.id="xmi.15"
xmi.uuid="-87--2--57-37-
5c9766:e95116ff04:-7ffc">
<Foundation.Core.ModelElement.name>Ouvinte</Foundation.Core.ModelElem
ent.name>
<Foundation.Core.ModelElement.isSpecification
xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isRoot
xmi.value="false"/>
125
<Foundation.Core.GeneralizableElement.isLeaf
xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isAbstract
xmi.value="false"/>
<Foundation.Core.Class.isActive xmi.value="false"/>
<Foundation.Core.ModelElement.namespace>
<Foundation.Core.Namespace xmi.idref="xmi.1"/>
</Foundation.Core.ModelElement.namespace>
<Foundation.Core.GeneralizableElement.generalization>
<Foundation.Core.Generalization xmi.idref="xmi.3"/>
</Foundation.Core.GeneralizableElement.generalization>
</Foundation.Core.Class>
<Foundation.Core.Generalization xmi.id="xmi.3" xmi.uuid="-87-2--57-37-5c9766:e95116ff04:-7ffb">
<Foundation.Core.ModelElement.isSpecification
xmi.value="false"/>
<Foundation.Core.ModelElement.namespace>
<Foundation.Core.Namespace xmi.idref="xmi.1"/>
</Foundation.Core.ModelElement.namespace>
<Foundation.Core.Generalization.child>
<Foundation.Core.GeneralizableElement xmi.idref="xmi.15"/>
</Foundation.Core.Generalization.child>
<Foundation.Core.Generalization.parent>
<Foundation.Core.GeneralizableElement xmi.idref="xmi.2"/>
</Foundation.Core.Generalization.parent>
</Foundation.Core.Generalization>
<Foundation.Core.Class
xmi.id="xmi.16"
xmi.uuid="-87--2--57-37-
5c9766:e95116ff04:-7ffa">
<Foundation.Core.ModelElement.name>Convidado</Foundation.Core.ModelElement.n
ame>
<Foundation.Core.ModelElement.isSpecification
xmi.value="false"/>
126
<Foundation.Core.GeneralizableElement.isRoot
xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isLeaf
xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isAbstract
xmi.value="false"/>
<Foundation.Core.Class.isActive xmi.value="false"/>
<Foundation.Core.ModelElement.namespace>
<Foundation.Core.Namespace xmi.idref="xmi.1"/>
</Foundation.Core.ModelElement.namespace>
<Foundation.Core.GeneralizableElement.generalization>
<Foundation.Core.Generalization xmi.idref="xmi.4"/>
</Foundation.Core.GeneralizableElement.generalization>
<Foundation.Core.Classifier.feature>
<Foundation.Core.Attribute xmi.id="xmi.17">
<Foundation.Core.ModelElement.name>hotel</Foundation.Core.ModelElement
.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.16"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Attribute>
<Foundation.Core.Attribute xmi.id="xmi.18">
<Foundation.Core.ModelElement.name>cia_aerea</Foundation.Core.ModelEle
ment.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier
xmi.idref="xmi.16"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Attribute>
</Foundation.Core.Classifier.feature>
127
</Foundation.Core.Class>
<Foundation.Core.Generalization xmi.id="xmi.4" xmi.uuid="-87-2--57-37-5c9766:e95116ff04:-7ff9">
<Foundation.Core.ModelElement.isSpecification
xmi.value="false"/>
<Foundation.Core.ModelElement.namespace>
<Foundation.Core.Namespace xmi.idref="xmi.1"/>
</Foundation.Core.ModelElement.namespace>
<Foundation.Core.Generalization.child>
<Foundation.Core.GeneralizableElement
xmi.idref="xmi.16"/>
</Foundation.Core.Generalization.child>
<Foundation.Core.Generalization.parent>
<Foundation.Core.GeneralizableElement
xmi.idref="xmi.2"/>
</Foundation.Core.Generalization.parent>
</Foundation.Core.Generalization>
<Foundation.Core.Class xmi.id="xmi.19" xmi.uuid="-87--2--5737-5c9766:e95116ff04:-7ff8">
<Foundation.Core.ModelElement.name>Apresentador</Foundation.Core.Model
Element.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isRoot xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isLeaf
xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isAbstract
xmi.value="false"/>
<Foundation.Core.Class.isActive xmi.value="false"/>
<Foundation.Core.ModelElement.namespace>
<Foundation.Core.Namespace xmi.idref="xmi.1"/>
</Foundation.Core.ModelElement.namespace>
<Foundation.Core.GeneralizableElement.generalization>
<Foundation.Core.Generalization xmi.idref="xmi.5"/>
</Foundation.Core.GeneralizableElement.generalization>
128
<Foundation.Core.Classifier.feature>
<Foundation.Core.Attribute xmi.id="xmi.20">
<Foundation.Core.ModelElement.name>titulo_trabalho</Foundation.Core.ModelEleme
nt.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.19"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Attribute>
</Foundation.Core.Classifier.feature>
</Foundation.Core.Class>
<Foundation.Core.Generalization xmi.id="xmi.5" xmi.uuid="-87-2--57-37-5c9766:e95116ff04:-7ff7">
<Foundation.Core.ModelElement.isSpecification
xmi.value="false"/>
<Foundation.Core.ModelElement.namespace>
<Foundation.Core.Namespace xmi.idref="xmi.1"/>
</Foundation.Core.ModelElement.namespace>
<Foundation.Core.Generalization.child>
<Foundation.Core.GeneralizableElement xmi.idref="xmi.19"/>
</Foundation.Core.Generalization.child>
<Foundation.Core.Generalization.parent>
<Foundation.Core.GeneralizableElement xmi.idref="xmi.2"/>
</Foundation.Core.Generalization.parent>
</Foundation.Core.Generalization>
<Foundation.Core.Class xmi.id="xmi.21" xmi.uuid="-87--2--5737-5c9766:e95116ff04:-7ff3">
<Foundation.Core.ModelElement.name>Trabalho</Foundation.Core.Mo
delElement.name>
<Foundation.Core.ModelElement.isSpecification
xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isRoot
xmi.value="false"/>
129
<Foundation.Core.GeneralizableElement.isLeaf
xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isAbstract
xmi.value="false"/>
<Foundation.Core.Class.isActive xmi.value="false"/>
<Foundation.Core.ModelElement.namespace>
<Foundation.Core.Namespace xmi.idref="xmi.1"/>
</Foundation.Core.ModelElement.namespace>
<Foundation.Core.Classifier.feature>
<Foundation.Core.Attribute xmi.id="xmi.22">
<Foundation.Core.ModelElement.name>titulo</Foundation.Core.ModelElement
.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.21"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Attribute>
<Foundation.Core.Attribute xmi.id="xmi.23">
<Foundation.Core.ModelElement.name>autor</Foundation.Core.Model
Element.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.21"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Attribute>
<Foundation.Core.Attribute xmi.id="xmi.24">
<Foundation.Core.ModelElement.name>assunto</Foundation.Core.ModelElem
ent.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.21"/>
</Foundation.Core.Feature.owner>
130
</Foundation.Core.Attribute>
<Foundation.Core.Attribute xmi.id="xmi.25">
<Foundation.Core.ModelElement.name>condiçao</Foundation.Core.ModelEl
ement.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.21"/>
<Foundation.Core.Feature.owner>
</Foundation.Core.Attribute>
<Foundation.Core.Operation xmi.id="xmi.26">
<Foundation.Core.ModelElement.name>inserir</Foundation.Core.Model
Element.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.BehavioralFeature.isQuery
xmi.value="false"/>
<Foundation.Core.Operation.isRoot xmi.value="false"/>
<Foundation.Core.Operation.isLeaf xmi.value="false"/>
<Foundation.Core.Operation.isAbstract
xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.21"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Operation>
<Foundation.Core.Operation xmi.id="xmi.27">
<Foundation.Core.ModelElement.name>remover</Foundation.Core.Mo
delElement.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.BehavioralFeature.isQuery
xmi.value="false"/>
<Foundation.Core.Operation.isRoot xmi.value="false"/>
<Foundation.Core.Operation.isLeaf xmi.value="false"/>
<Foundation.Core.Operation.isAbstract
xmi.value="false"/>
131
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.21"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Operation>
<Foundation.Core.Operation xmi.id="xmi.28">
<Foundation.Core.ModelElement.name>consultar</Foundation.Core.Mo
delElement.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.BehavioralFeature.isQuery
xmi.value="false"/>
<Foundation.Core.Operation.isRoot xmi.value="false"/>
<Foundation.Core.Operation.isLeaf xmi.value="false"/>
<Foundation.Core.Operation.isAbstract xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.21"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Operation>
</Foundation.Core.Classifier.feature>
</Foundation.Core.Class>
<Foundation.Core.Association xmi.id="xmi.29" xmi.uuid="-87--2--5737-5c9766:e95116ff04:-7ff2">
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isRoot xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isLeaf xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isAbstract xmi.value="false"/>
<Foundation.Core.ModelElement.namespace>
<Foundation.Core.Namespace xmi.idref="xmi.1"/>
</Foundation.Core.ModelElement.namespace>
<Foundation.Core.Association.connection>
<Foundation.Core.AssociationEnd xmi.id="xmi.30">
<Foundation.Core.ModelElement.isSpecification
xmi.value="false"/>
<Foundation.Core.AssociationEnd.isNavigable
xmi.value="true"/>
132
<Foundation.Core.AssociationEnd.aggregation
xmi.value="none"/>
<Foundation.Core.AssociationEnd.association>
<Foundation.Core.Association
xmi.idref="xmi.29"/>
</Foundation.Core.AssociationEnd.association>
<Foundation.Core.AssociationEnd.type>
<Foundation.Core.Classifier xmi.idref="xmi.19"/>
</Foundation.Core.AssociationEnd.type>
</Foundation.Core.AssociationEnd>
<Foundation.Core.AssociationEnd xmi.id="xmi.31">
<Foundation.Core.ModelElement.isSpecification
xmi.value="false"/>
<Foundation.Core.AssociationEnd.isNavigable
xmi.value="true"/>
<Foundation.Core.AssociationEnd.aggregation
xmi.value="none"/>
<Foundation.Core.AssociationEnd.association>
<Foundation.Core.Association
xmi.idref="xmi.29"/>
</Foundation.Core.AssociationEnd.association>
<Foundation.Core.AssociationEnd.type>
<Foundation.Core.Classifier xmi.idref="xmi.21"/>
</Foundation.Core.AssociationEnd.type>
</Foundation.Core.AssociationEnd>
</Foundation.Core.Association.connection>
</Foundation.Core.Association>
<Foundation.Core.Class
xmi.id="xmi.32"
xmi.uuid="-87--2--57-37-
5c9766:e95116ff04:-7ff1">
<Foundation.Core.ModelElement.name>Avaliadores</Foundation.Core.ModelE
lement.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isRoot xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isLeaf xmi.value="false"/>
133
<Foundation.Core.GeneralizableElement.isAbstract xmi.value="false"/>
<Foundation.Core.Class.isActive xmi.value="false"/>
<Foundation.Core.ModelElement.namespace>
<Foundation.Core.Namespace xmi.idref="xmi.1"/>
</Foundation.Core.ModelElement.namespace>
<Foundation.Core.Classifier.feature>
<Foundation.Core.Attribute xmi.id="xmi.33">
<Foundation.Core.ModelElement.name>nome</Foundation.Core.ModelElemen
t.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.32"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Attribute>
<Foundation.Core.Attribute xmi.id="xmi.34">
<Foundation.Core.ModelElement.name>area_atuação</Foundation.Core.M
odelElement.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier
xmi.idref="xmi.32"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Attribute>
<Foundation.Core.Operation xmi.id="xmi.35">
<Foundation.Core.ModelElement.name>inserir</Foundation.Core.Model
Element.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.BehavioralFeature.isQuery
xmi.value="false"/>
<Foundation.Core.Operation.isRoot xmi.value="false"/>
<Foundation.Core.Operation.isLeaf xmi.value="false"/>
<Foundation.Core.Operation.isAbstract xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.32"/>
134
</Foundation.Core.Feature.owner>
</Foundation.Core.Operation>
<Foundation.Core.Operation xmi.id="xmi.36">
<Foundation.Core.ModelElement.name>remover</Foundation.Core.Mo
delElement.name>
<Foundation.Core.ModelElement.isSpecification xmi.value="false"/>
<Foundation.Core.BehavioralFeature.isQuery
xmi.value="false"/>
<Foundation.Core.Operation.isRoot xmi.value="false"/>
<Foundation.Core.Operation.isLeaf xmi.value="false"/>
<Foundation.Core.Operation.isAbstract
xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.32"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Operation>
<Foundation.Core.Operation xmi.id="xmi.37">
<Foundation.Core.ModelElement.name>consultar</Foundation.Core.Mo
delElement.name>
<Foundation.Core.ModelElement.isSpecification
xmi.value="false"/>
<Foundation.Core.BehavioralFeature.isQuery
xmi.value="false"/>
<Foundation.Core.Operation.isRoot xmi.value="false"/>
<Foundation.Core.Operation.isLeaf xmi.value="false"/>
<Foundation.Core.Operation.isAbstract xmi.value="false"/>
<Foundation.Core.Feature.owner>
<Foundation.Core.Classifier xmi.idref="xmi.32"/>
</Foundation.Core.Feature.owner>
</Foundation.Core.Operation>
</Foundation.Core.Classifier.feature>
</Foundation.Core.Class>
<Foundation.Core.Association xmi.id="xmi.38" xmi.uuid="-87-2--57-37-5c9766:e95116ff04:-7ff0">
135
<Foundation.Core.ModelElement.isSpecification
xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isRoot
xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isLeaf
xmi.value="false"/>
<Foundation.Core.GeneralizableElement.isAbstract
xmi.value="false"/>
<Foundation.Core.ModelElement.namespace>
<Foundation.Core.Namespace xmi.idref="xmi.1"/>
</Foundation.Core.ModelElement.namespace>
<Foundation.Core.Association.connection>
<Foundation.Core.AssociationEnd xmi.id="xmi.39">
<Foundation.Core.ModelElement.isSpecification
xmi.value="false"/>
<Foundation.Core.AssociationEnd.isNavigable
xmi.value="true"/>
<Foundation.Core.AssociationEnd.aggregation
xmi.value="none"/>
<Foundation.Core.AssociationEnd.association>
<Foundation.Core.Association
xmi.idref="xmi.38"/>
</Foundation.Core.AssociationEnd.association>
<Foundation.Core.AssociationEnd.type>
<Foundation.Core.Classifier xmi.idref="xmi.21"/>
</Foundation.Core.AssociationEnd.type>
</Foundation.Core.AssociationEnd>
<Foundation.Core.AssociationEnd xmi.id="xmi.40">
<Foundation.Core.ModelElement.isSpecification
xmi.value="false"/>
<Foundation.Core.AssociationEnd.isNavigable
xmi.value="true"/>
<Foundation.Core.AssociationEnd.aggregation
xmi.value="none"/>
136
<Foundation.Core.AssociationEnd.association>
<Foundation.Core.Association
xmi.idref="xmi.38"/>
</Foundation.Core.AssociationEnd.association>
<Foundation.Core.AssociationEnd.type>
<Foundation.Core.Classifier xmi.idref="xmi.32"/>
</Foundation.Core.AssociationEnd.type>
</Foundation.Core.AssociationEnd>
</Foundation.Core.Association.connection>
</Foundation.Core.Association>
</Foundation.Core.Namespace.ownedElement>
</Model_Management.Model>
</XMI.content>
</XMI>
137