O slideshow foi denunciado.
Utilizamos seu perfil e dados de atividades no LinkedIn para personalizar e exibir anúncios mais relevantes. Altere suas preferências de anúncios quando desejar.

XML: Uma Introdução Prática (2001)

1.252 visualizações

Publicada em

Curso de XML por Helder da Rocha (2001)

Publicada em: Tecnologia
  • Seja o primeiro a comentar

  • Seja a primeira pessoa a gostar disto

XML: Uma Introdução Prática (2001)

  1. 1. 1 Helder da Rocha XML uma introdução prática © 2000, 2001, 2003, 2005, 2007 Helder da Rocha
  2. 2. 2 Objetivos !! Oferecer uma introdução geral sobre a tecnologia XML, com conceitos teóricos e experimentação prática, abrangendo fundamentos e principais aplicações
  3. 3. 3 Agenda !! Dia 1 !! 1. Introdução a XML e tecnologias relacionadas !! 2. Fundamentos de estrutura e sintaxe !! 3. Especificação de aplicações com DTD !! Dia 2 !! 4. Programação com DOM e SAX (fundamentos*) !! 5. Visualização de documentos XML usando CSS !! 6. Referências e navegação com XLink e XPointer !! 7. Especificação de aplicações com XML Schema (fundamentos*) !! Dia 3 !! 8. Localização e extração de dados com XPath !! 9. Transformação de XML com XSLT (fundamentos*) !! 10. Layout de página e gráficos com XSL-FO e SVG (fundamentos*) * tópicos complexos que são abordados de forma introdutória neste curso (eles são explorados em maior profundidade em outros cursos)
  4. 4. 4 Formato !! Apresentação em slides !! Demonstrações !! Exercícios !! Realizados em sala de aula !! Propostos para realização fora do horário de aula
  5. 5. 5 Material !! Slides (disponíveis no site) !! Apostila (tópicos selecionados e guia de referência) !! Código de exemplos usados nas demonstrações !! Código de aplicações !! Atualizações (slides e documentos anexos) !! Especificações oficiais !! Ferramentas abertas !! Material de referência
  6. 6. 6 Sobre material avulso e alterações !! O material didático distribuído refere-se ao roteiro usado como referência para a maior parte dos cursos !! Em cursos personalizados, alguns tópicos poderão não ser abordados, e material avulso de outros cursos poderá ser usado !! Mesmo em cursos normais, material avulso poderá ser introduzido como atualização !! A maior parte dos cursos de tecnologia envolvem assuntos que mudam com freqüência !! Melhoramentos na apresentação e didática às vezes são introduzidos antes e uma reforma geral do material !! Durante o curso o instrutor também poderá trocar a ordem de apresentação de assuntos, aprofundar um assunto ou mesmo tratar superficialmente outro assunto, caso isto traga benefícios ao curso de uma forma geral
  7. 7. 7 Sobre ferramentas usadas no curso !! As ferramentas e aplicações usadas em sala tem acima de tudo um objetivo didático !! Podem não ser as melhores ferramentas em termos de produtividade e uso profissional !! Algumas ferramentas usadas em aula foram adaptadas para explorar os exemplos e exercícios apresentados !! As ferramentas podem não estar mais disponíveis na Web ou estarem em versões mais novas e possivelmente incompatíveis !! Geralmente uma pasta com todo o código usado nessas ferramentas será distribuída com o material didático (depende do curso) – use a versão fornecida (a menos que o instrutor indique outra alternativa) !! É possível que algumas ferramentas só funcionem em determinadas plataformas (Windows, Mac, Java)
  8. 8. 8 Ferramentas úteis para este curso !! Para programação !! Parsers-validadores: Xerces, Crimson, MSXML 4.0 !! Validadores: MSV (Sun) !! Transformadores XSL: TrAX, Xalan, Xt, Saxon !! APIs: JDOM, JAX !! Veja mais em xml.apache.org e www.alphaworks.ibm.com !! Para edição (de XML genérico) !! XML Spy, Liquid e oXygen (software comercial) !! Eclipse e Netbeans (gratuitos) !! Veja mais em www.w3.org/XML/
  9. 9. 9 Fontes [1] World Wide Web Consortium (W3C). eXtensible Markup Language. http://www.w3.org/XML/. Ponto de partida e principal fonte sobre XML e suas tecnologias "satélite". Contém últimas especificações de XML, XPath, XSchema, XSLT, XSL-FO, XQuery, XLink, XPointer, SVG, XHTML, CSS. [2] Eric Armstrong et al. Working with XML. Aborda DOM, SAX e XML com Java. http://java.sun.com/xml/jaxp/dist/1.1/docs/tutorial/index.html. [3] Adobe. SVG Tutorial. http://www.adobe.com/svg/. Contém tutorial sobre SVG e links para o plug-in SVG da Adobe (Win/Mac). [4] IBM Developerworks. http://www-106.ibm.com/developerworks/. Diversos tutoriais e artigos sobre XML, XSLT, DOM e SAX usando geralmente Java. [5] Doug Tidwell. XSLT. O’Reilly & Associates, 2001. Explora XSLT com aplicações práticas em Java. [6] Elliotte Rusty Harold. XML Bible, Second Edition, 2001. Aborda todas as principais tecnologias W3C. 5 capítulos em http://cafeconleche.org/books/bible2/ [7] Erik T. Ray. Learning XML. O’Reilly & Associates, 2001. Introdução ao XML e DTD, XSLT, XLink e XPointer (os dois últimos baseados em especificações draft).
  10. 10. 10 Importante !! Tente fazer os exercícios; se não entender, pergunte! !! Explore os exemplos e exercícios em aplicações reais (não se limite a ver um exemplo didático funcionar) !! Tente fazer os exercícios; se não entender, pergunte! helder.darocha@gmail.com www.argonavis.com.br
  11. 11. 1 Introdução a XML X100 Helder da Rocha (helder@argonavis.com.br) Atualizado em setembro de 2001
  12. 12. 2 O que é XML? !! eXtensible Markup Language: padrão W3C !! Uma maneira de representar informação !! não é uma linguagem específica !! não define vocabulário de comando !! não define gramática, apenas regras mínimas de estrutura !! Exemplo: documento XML usuario_33.xml <contato codigo="33"> <nome>Severino Severovitch</nome> <email>bill@norte.com.br</email> <telefone tipo="celular"> <area>11</area> <numero>9999 4321</numero> </telefone> </contato> elemento atributo "nó" de texto
  13. 13. 3 XML versus HTML HTML mostra como apresentar XML mostra o que significa <nome>Severino Severovitch</nome> <email>bill@norte.com.br</email> <telefone> <ddd>11</ddd> <numero>9999 4321</numero> </telefone> <h1>Severino Severovitch</h1> <h2>bill@norte.com.br</h2> <p> <b>11</b> <i>9999 4321</i> </p>
  14. 14. 4 Anatomia de um documento XML !! Documentos XML são documentos de texto Unicode !! É uma hierarquia de elementos a partir de uma raiz !! Menor documento tem um elemento (vazio ou não): !! Menor documento contendo elemento vazio !! Menor documento contendo elemento e conteúdo texto <nome> !"#"$%&' !"#"$'#%( </nome> <nome> !"#"$%&' !"#"$'#%( </nome> Etiqueta inicial Conteúdo do Elemento Etiqueta final Elemento raiz <nome/><nome></nome> =
  15. 15. 5 XML Namespaces !! Estabelecem um contexto para elementos e atributos !! É formalmente declarado através de um identificador (um string, geralmente uma URI) através de atributo reservado do XML: xmlns !! Podem ser associados a um prefixo para qualificar elementos e atributos !! Quando o prefixo não é usado, estabelece um namespace default adotado pelo elemento onde é declarado e seus elementos filho !"#$%&'(')*+ ++!,-$.)+%/#0'0-12"-3%/0)"2*456!7,-$.)*+ ++!(&#$'+!"#$%&'()*+,,-../0#*"-'*+ ++++!,-$.)*(8%9)")!7,-$.)*+ ++!7(&#$'*+ !7"#$%&'(')*+ !"#$%&'(')+:$&/"+112%;#<77'..=(&#$'2*+ ++!,-$.)+%/#0'0-12"-3%/0)"2*456!7,-$.)*+ ++!1+(&#$'*+ ++++!1+,-$.)*(8%9)")!71+,-$.)*+ ++++!,-$.)+%/#0'0-128);'"2*>?@!7,-$.)*+ ++!71+(&#$'*+ !7"#$%&'(')*+ Escopo do namespace vale para elemento <clima> e herdado por todos os seus descendentes Escopo do namespace vale para descendentes de <simulacao> qualificados com o prefixo 'w' Nos dois casos, elementos <tempo> significam coisas diferentes, mas não há conflito porque pertencem a namespaces diferentes (um deles não tem namespace)
  16. 16. 6 Documentos XML bem formados !! Para que possa ser manipulado como uma árvore, um documento XML precisa ser bem formado !! Documentos que não são bem formados não são documentos XML – use um editor XML para descobrir !! Documentos bem-formados obedecem as regras de construção de documentos XML genéricos !! Regras incluem !! Ter um, e apenas um, elemento raiz !! Valores dos atributos estarem entre aspas ou apóstrofes !! Atributos não se repetirem !! Todos os elementos terem etiqueta de fechamento !! Elementos estarem corretamente aninhados
  17. 17. 7 Exemplos de algumas regras !! (1) Elementos não devem se sobrepor !! Não pode !"#!$#!%"#!%$#& !! (2) Atributos têm que ter valores entre aspas !! Não pode !'(&)*+,'-./#&& !! Deve ser !'(&)*+,'-0./0#& !! (3) Nomes de elementos são case-sensitive !! Não pode !"#111!%2#& !! (4) Todos os elementos têm marcadores de abertura e de fechamento !! Não pode !$(#3!$(#& !! Deve ser !$(%#3!$(%#& ou !$(#!%$(#3!$(#!%$(#&
  18. 18. 8 XML válido !! Um XML bem construído pode não ser válido em determinada aplicação !! Aplicação típica pode esperar que !! elementos façam parte de um vocabulário limitado, !! certos atributos tenham valores e tipos definidos, !! elementos sejam organizados de acordo com uma determinada estrutura hierárquica, etc. !! É preciso especificar a linguagem! !! Esquema: modelo que descreve todos os elementos, atributos, entidades, suas relações e tipos de dados !! Um documento é considerado válido em relação a um esquema se obedecer todas as suas regras
  19. 19. 9 Esquema !! O esquema representa uma classe !! Os documentos são instâncias Esquema (universo de documentos válidos) Documentos que aderem à especificação (válidos) Documento fora da especificação !! Como definir esquemas: !! DTD - Document Type Definition !! W3C XML Schema
  20. 20. 10 DTD vs. XML Schema !! Um esquema é essencial para que haja comunicação usando XML !! Pode ser estabelecido "informalmente" (via software) !! Uso formal permite validação usando ferramentas genéricas de manipulação de XML !! Soluções padrão do W3C DTD XML Schema !"#$#%#&'()*+,-,*(( ((((((((((.+*/01(0/-231(,0304*+056( !"7''$89'()*+,-,*( (((((((((()*:2;*(&%'<=#&(>?#@A8?#B6( !CD:ED)F0/-(( (((((C/3+DECD:GHIIIJK%$9)F0/-H6( (!CD:E030/0+,(+-/0GH)*+,-,*H6( ((!CD:E)*/L30C'ML06( (((!CD:E-,,N2OP,0(+-/0GH)*:2;*H((((((((((((((((((((((((( ((((((((((((((((((PD0GHN0QP2N0:H6( •!É XML, porém mais complexo •!Suporta namespaces •!Permite definição de tipos •!Simples mas não é XML •!Não suporta namespaces •!Limitado quando a tipos de dados
  21. 21. 11 Por que usar XML para compartilhar dados? !! Porque é um padrão aberto !! Facilidade para converter para formatos proprietários !! Porque é texto !! Fácil de ler, fácil de processar, menos incompatibilidades !! Porque promove a separação entre estrutura, conteúdo e apresentação !! Facilita geração de dados para visualização dinâmica !! Evita repetição de informação / simplifica manutenção !! Porque permite semântica na Web !! Elementos HTML não carregam significado, apenas dicas de formatação: mecanismos de busca ficam prejudicados
  22. 22. 12 Como produzir XML !! Criando um documento de texto Unicode a partir de qualquer editor de textos !! Gerando um documento a partir de uma árvore montada dinamicamente !"#$%&%#'"#()*#+,--,.' ''!$#/0.10203)$#'10203#2)%"4!5$#/0.' ''!0/&)6.7)668$#3%09"#/973!50/&)6.' ''!%060:#$0'%);#+,"06<6&3,.' ''''!&30&.==!5&30&.' ''''!$</03#.>>>>'?-@=!5$</03#.' ''!5%060:#$0.' !5"#$%&%#.' !"#$%&%#'"#()*#+,--,.' ''!$#/0.10203)$#'10203#2)%"4!5$#/0.' ''!0/&)6.7)668$#3%09"#/973!50/&)6.' ''!%060:#$0'%);#+,"06<6&3,.' ''''!&30&.==!5&30&.' ''''!$</03#.>>>>'?-@=!5$</03#.' ''!5%060:#$0.' !5"#$%&%#.' celular 11 9999 4321 33 Severino Severovitch bill@norte.com.br
  23. 23. 13 Visualização em um browser !! Folha de estilo: conjunto de regras para formatar ou transformar as informações de um documento XML !! CSS - Cascading Style Sheets !! Transformação visando apresentação visual !! Aplicação do estilo em tempo de execução no cliente !! XSLT - eXtensible Stylesheet Language !! Transformação em texto, HTML ou outro formato !! Aplicação em tempo real ou prévia (no servidor) !! Se não estiver associado a uma folha de estilo, o documento XML não tem uma "aparência" definida !! Vários browsers por default mostram a árvore-fonte XML !! Outros mostram apenas os nós de texto sem formatação
  24. 24. 14 Formas de processamento XML !! Via APIs de programação !! SAX – Simple API for XML: leitura seqüencial, ideal para extração de dados !! DOM – Document Object Model: leitura completa, ideal para manipulação (inserção, reordenação, alteração, remoção de nós) !! Via linguagens de processamento (suportadas por parsers e processadores padronizados pela W3C) !! XSLT, XPath, XLink, XPointer e XQuery: extração, transformação e localização de dados !! XSL-FO, XHTML, SVG: apresentação de dados
  25. 25. 15 Processamento XML PDF PDF PDF 2000 2001 SGBD <xml> <xml> <xml> !"#$%&!"#$%& Web XML para SGBD e vice-versa HTML CSS JavaScript VRML PDF e PostScript Gráficos SVG Imagens JPG e PNG WML VoiceXML "custom" XML DOM SAX texto RTF TeX SGML
  26. 26. 16 XPath !! Linguagem usada para navegar na árvore XML !! Uma expressão XPath é um caminho na árvore que resulta em um valor (número, texto, booleano), objeto (elemento, atributo, nó de texto) ou conjunto de objetos !! Expressões XPath são usadas dentro de atributos XML !! Usadas em XSLT, XLink, XQuery e XPointer celular 11 9999 4321 33 Severino Severovitch bill@norte.com.br •!Caminhos absolutos !"#$%&%#!'"#()*#+ ++!"#$%&%#!%,-,.#$,!'%)/#+ ++!"#$%&%#!%,-,.#$,!$01,2#!%,3%45+ •!Relativos ao contexto !"#$%&%#+: ++'"#()*#+!"#$6!'"#()*#%$ ++%,-,.#$,!'%)/#+!"#$6!%,-,.#$,!'%)/#%$ ++%,-,.#$,!$01,2#!%,3%45+
  27. 27. 17 XLink, XPointer e XQuery !! XLink: especificação W3C que define vínculos (de diversos tipos) entre documentos XML !! Funcionalidade mínima é igual ao <a href> do HTML !! É uma coleção de atributos, com namespace próprio, que podem ser usados em elementos de qualquer linguagem XML. !! XPointer: aponta para partes de documentos XML !! Identificador no destino, acessível por XLink: !"#$%&'()*+,-#.)$/,0 !! Caminho resultante de expressão XPath: !12#$/)(34"#5(24#.60 !! XQuery: linguagem para pesquisar documentos XML através de queries com sintaxe inspirada em SQL !! Exemplo: 7890:;0<=0.2>?@)$/3,?A?B(#2CDDE!@",64>2$/B/200 0000000FGH9H0$2@)+,I)5)(#$20I)5)(25#/>',0 00000009HJK9=0:;0
  28. 28. 18 XSL !! eXtensible Stylesheet Language !! Aplicação de XML para transformação e apresentação de dados disponíveis em XML !! Não existe mais como uma especificação. Foi dividida em duas !! XSLT – foca em transformação de dados. XSLT é uma linguagem funcional para processamento de templates !! XSL-FO – linguagem de descrição de página (como PDF, HTML+CSS) !! Cada especificação define um namespace próprio !! XSLT usa o identificador !""#$%%&&&'&(')*+%,---%./0%1*2345)*67 !! XSL-FO usa !""#$%%&&&'&(')*+%,---%./0%8)*62"7 !! Importante: as URLs acima são usadas como identificadores de namespace, e não representam nenhum endereço Web !! É muito comum usar URLs como identificadores de namespace !! Todas as aplicações XML do W3C usam URLs da forma: 77!""#$%%&&&'&(')*+%!"#$%&'%()*"("$+%!,'(#$-$.*"+/
  29. 29. 19 XSLT !! XSL Transformations (XSLT) !! Linguagem (XML) para criação de documentos que contêm regras de transformação para documentos XML !! Documentos escritos em XSLT são chamados de folhas de estilo (mas são na verdade templates) e contêm !!Elementos XSLT: !"#$%&'"#(, !)*(, !*+,-#'./(, ... !!Expressões XPath para localizar nós da árvore-fonte !!Texto ou XML a ser gerado no documento-resultado !! Usa-se um processador XSLT Processador XSLT Xalan, TrAX, Saxon Firefox, I. Explorer, etc. Folha de estilos Documento Resultado Documento Fonte fonteToHtml.xslt fonte.xml <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:template match="livro/titulo"> <td><xsl:value-of select="." /></td>
  30. 30. 20 XSLT: documento-fonte (1) !! Considere o seguinte documento-fonte: !"#$%&'#($!)*+,-./01,2! !!!"&%)3$4!5#%6)*#+,789:;,2<)&!*$!! !!!!!!!!!!!!!!!!!!!!!!!!!!!=#'$)%&">&%)3$42! !!!"*$?6)'&2@A&!-#BC&">*$?6)'&2! ">#$%&'#($2! !! E sua representação como uma árvore-fonte !"#$%&$'()&"*#$ +,-./$ 0$ 1"%$ 12(*3"%($ 4(&*#)(5&6$ 4#*"7&86$ 4%&93")#6$ :;<=>$ ?@#$:(AB#$
  31. 31. 21 XSLT: folha de estilos (2) !! O seguinte template (parte de uma folha de estilos XSLT) pode extrair os dados do documento-fonte !"#$%&'()$*&'+(*&,-./*'012*3'/4+ ++++!)45+*'012*3'+6'+)0'78"1++ ++++!"#$%3*$9':17+#'$',&./;86/+<4+6',1$19+ ++++6'+!"#$%3*$9':17+#'$',&./108='(/+<4+>#++ ++++!"#$%3*$9':17+#'$',&./108='(<;)*0&86*/+<4+ ++++&'261+,1(1+6'#&821+1+*'01)10&1+6'+++++ ++++!"#$%3*$9':17+#'$',&./6'#&821/+<4?!<)4+++++ !<"#$%&'()$*&'4+ !! Elementos XSLT são qualificados com prefixo (da forma !"#$%&$&'&()*+) para evitar conflitos com o documento-resultado !! O prefixo xsl e namespace precisam ser declarados com xmlns:xsl documento-fonte (em azul - XPath) documento resultado (em preto) elementos XSLT (em vermelho, com prefixo xsl)
  32. 32. 22 XSLT: documento-resultado (3) !! Após a transformação, o resultado será !"#$%!&'()*&+'!,'!#('-./)!! 01234!,'5)6)7! ,'!8.)!,'!9&*'.()!:;!! <=>?! @'*,)!5)A)!,';@.*)!)!&'()#)(@)!,'! BC)!0&76)D"E#$! !! Para obter outros resultados e gerar outros formatos com os mesmos dados, pode-se criar folhas de estilo adicionais
  33. 33. 23 XSL-FO !! XSL Formatting Objects !! Linguagem XML de descrição de página com os mesmos recursos que PostScript ou PDF !! Descreve o layout preciso de texto e imagens !! Possui centenas de elementos, atributos e propriedades (que são semelhantes às propriedades do CSS) !! Páginas são facilmente convertidas para PDF e PostScript !! Ideal para gerar documentos para impressão (livros, etc.) !! Normalmente gerada via XSLT Processador XSLT XSLT Documento XSLFO Fonte FOP Documento PDF XML XML XML <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format"> <fo:layout-master-set> <fo:simple-page-master master-name="p1"> <fo:region-body/>
  34. 34. 24 XSL-FO: menor documento !"#$%##&'!"#$%&'()*+,,-&..///0/10(23.4555.678.9(2":,*(' '''!"#$)*+#,&-.*/&0%-/0&(' '''''''!"#$/1.2)0-2*30-.*/&0%'.*/&0%-4*.056276(' '''''''''''!"#$%031#4-8#9+:(' '''''''!:"#$/1.2)0-2*30-.*/&0%(' !!!":"#$)*+#,&-.*/&0%-/0&(' ''''''!"#$2*30-/0;,04<0'.*/&0%-4*.056276(' ''''!"#$")#='")#=-4*.056>/)-%031#4-8#9+6(' !!!!!!!!"#$8)#<?'<#)#%568),06'"#4&-/1@056AB2&6(' ''''''''''C0))#'DEFG' '''''''!:"#$8)#<?(' ''''!:"#$")#=(' '''!:"#$2*30-/0;,04<0(' !:"#$%##&(' Este é o "<body>" do XSL-FO Este é o "<head>" do XSL-FO Ligação entre as regras de layout e o conteúdo afetado
  35. 35. 25 XHTML !! eXtensible HTML !! Linguagem XML de descrição de página Web !! Mesmos elementos do HTML 4.0 Strict !! Elementos descrevem somente a estrutura dos componentes da página. A forma precisa ser especificada usando CSS: não há elementos/atributos para mudar cor, alinhamento, etc. !! Pode ser misturada (estendida) com outras linguagens XML (MathML, SVG, linguagens proprietárias) !! Normalmente gerada via XSLT Processador XSLT XSLT Documento XHTML Documento Fonte XML XML XML <html xmlns="http://www.w3.org/1999/xhtml"> <head><title>Página XHTML</title></head> <body> <h1>Página XHTML</h1>
  36. 36. 26 SVG !! Scalable Vector Graphics (padrão W3C) !! Gráficos vetoriais em XML !! Plug-ins para principais browsers: concorre com Flash !! Suporta animações, links, JavaScript, CSS !! Produzido por ferramentas como Adobe Ilustrator !! Pode ser embutido no código XHTML e XSL-FO Zoom + Zoom + <svg xmlns="http://www.w3.org/2000/svg"> <circle style="fill: red" cx="3cm" cy="3cm" r="2.5cm" /> <rect style="fill: blue" x="6cm" y="6cm" height="2.5cm" width="1.5cm" />
  37. 37. 27 Exemplo de SVG !"#$%&'()*+,-./0,%*1'$*)+,-./0,2%% %%!$%34/5'/6+,7518)9:;5'/3<%43%$8<=3%->:?,2%% %%%%!/'8/51%")@51+,A'55B%81(,%% %%%%%%%%%%%%/C+,D/0,%/@+,D/0,%8+,EFG/0,%H2%% %%%%!81/)%")@51+,A'55B%I5<1,%C+,J/0,%@+,J/0,%% %%%%%%%%%%*1'$*)+,EFG/0,%&'()*+,-FG/0,%H2!H$2%% %%!$%34/5'/6+,7518)9:;5'/3<%43%$8<=3%E>:?,2%% %%%%!/'8/51%")@51+,A'55B%$8114K%3=7/')@B%.FG,%% %%%%%%%%%%%%/C+,G/0,%/@+,G/0,%8+,E/0,%H2!H$2%% %%!7%C054"B!"#$%+,*))=BHH&&&F&DF38$H-LLLHC5'46,%% %%%%%!"#$%B*81A+,*))=BHH&&&F&DF38$HM87=*'/"HNOM,2%% %%%%!)1C)%")@51+,/3538B%I57/6K%A34)PA70'5@B%)7*307K%% %%%%%%%%%%%%%%%%%A34)P"'Q1B%-E=),%C+,D/0,%@+,R/0,2% %%%%NOM%S%TUV!H)1C)2!H72%% !H"#$2%% CSS JavaScript XLink
  38. 38. 28 Outras aplicações populares do XML Classe oper(): void oper2(): int MathML SOAP WSDL UDDI ebXML CML Web Services XML-RPC XMI 1 * WML VoiceXML Classe3 oper(): void oper2(): int Classe2 oper(): void oper2(): int TEI DocBook
  39. 39. 29 Demonstração !! Exemplo de transformação XML Saxon FOP JFOR Texto texto texto texto texto texto texto texto texto <xslt> FO <xslt> HTML PDF 2000 2001 <xml> HTML <xsl:fo>(1) (2) <xslt> SVG (3) <xslt> Texto (4) (1.a) (1.b) SVG
  40. 40. 30 Conclusões !! XML é uma ótima solução para compartilhar dados !! Para implementar soluções em gestão de informações usando XML, pode-se usar !! DTD ou XSchema para especificar o modelo de dados e validar as informações !! As APIs DOM ou SAX para extrair dados dos documentos, gerar documentos, ler e gravar em bancos de dados !! XSLT e XPath para transformar os dados em outros formatos !! XLink, XPointer e XQuery para criar vínculos lógicos entre os documentos e localizar seus componentes !! XSL-FO ou XHTML para formatar os dados para impressão ou visualização na tela (PDF, Word ou Web) !! SVG para gerar informações em forma de gráfico vetorial
  41. 41. 1 XML: uma introdução prática X100 Helder da Rocha (helder@argonavis.com.br) Atualizado em setembro de 2001
  42. 42. 2 Como criar um documento XML !! XML não tem comandos, nem operadores, nem funções, nem tipos !! Não é exatamente uma "linguagem" !! A especificação XML não estabelece nenhum vocabulário !! Define apenas uma estrutura e sintaxe geral para a organização de informações estruturadas !! Para criar o menor documento XML !! Abra um editor de textos qualquer !! Salve o arquivo com extensão .xml !! Escreva um elemento raiz vazio; por exemplo: !"#$$%&'( !! Salve o arquivo !! Abra em um browser como Firefox ou Internet Explorer
  43. 43. 3 Especificação XML !! As regras para criação de documentos XML são definidas pelo World Wide Web Consortium (W3C) através de especificação !! !""#$%%&&&'&(')*+%,-%./0%1 !! A especificação não define !! nomes de elementos e atributos (cada aplicação define os seus) !! como escrever documentos válidos: a validade de um documento XML é definido pelo autor da aplicação em que ele é usado !! A especificação define !! tokens, caracteres e formatos de texto que podem ser usados em documentos XML (basicamente texto Unicode) !! elementos e atributos reservados (começam com o string xml) !! regras mínimas que possibilitam a leitura por um processador XML: um documento que segue essas regras é bem formado !! como uma aplicação pode validar um documento XML usando um DTD (Document Type Definition) com sintaxe similar a SGML
  44. 44. 4 Estrutura XML !! Um documento XML pode ser representado como uma árvore. A estrutura é formada por vários nós (galhos e folhas) <?xml version="1.0" encoding="iso-8859-1" ?> <!-- Isto é um comentário --> <cartao-simples> <logotipo href="/imagens/logo14bis.gif" /> <nome>Alberto Santos Dumont</nome> <endereco>Rua do Encanto, 22 - 2o. andar - Centro - 25600-000 - Petrópolis - RJ</endereco> <email>dumont@14bis.com.br</email> <telefone tipo="residencial" > <ddd>21</ddd> <numero>2313011</numero> </telefone> </cartao-simples> informações usadas pelo processador XML um "nó" pode ser ... •!um elemento, •!um atributo, •!um bloco de texto, •!um comentário, •!uma instrução, •!uma declaração, •!uma entidade, ...
  45. 45. 5 Árvore XML www.argonavis.com.br5 2313011 residencial 21 /imagens/logo14bis.gif Alberto Santos Dumont dumont@14bis.com.br Rua do Encanto, 22 - 2o. andar - Centro - 25600-000 - Petrópolis - RJ / nó raiz elemento raiz do documento cartao-simples telefone numero tipo ddd logotipo href nome email endereco nó de elemento nó de atributo nó de textoLEGENDA
  46. 46. 6 Componentes de um documento !! Um documento pode conter !! Prólogo !! Comentários !! Instruções de processamento !! Atributos nos elementos !! Nós de texto dentro dos elementos !! Elementos aninhados (sendo apenas um na raiz) !! Conteúdo misto (elemento e texto) dentro de elementos !! Entidades gerais !! Entidades de caractere !! Blocos CDATA
  47. 47. 7 Prólogo <?xml version="1.0" encoding="iso-8859-1" ?> <!-- Isto é um comentário --> <?comando tipo="simples" parametro ?> <!DOCTYPE cartao-simples SYSTEM "cartoes.dtd"> <cartao-simples> <logotipo href="/imagens/logo14bis.gif" /> <nome>Alberto Santos Dumont</nome> <endereco>Rua do Encanto, 22 - 2o. andar - Centro - 25600-000 - Petrópolis - RJ</endereco> <email>dumont@14bis.com.br</email> <telefone tipo="residencial" > <ddd>21</ddd> <numero>2313011</numero> </telefone> </cartao-simples> Declaração XML Comentário (pode aparecer em qualquer lugar) Instrução de processamento Declaração de tipo de documento
  48. 48. 8 Nó raiz e elementos nó raiz ( / ) elemento raiz do documento elementos elementos <?xml version="1.0" encoding="iso-8859-1" ?> <cartao-simples> <logotipo href="/imagens/logo14bis.gif" /> <nome>Alberto Santos Dumont</nome> <endereco>Rua do Encanto, 22 - 2o. andar - Centro - 25600-000 - Petrópolis - RJ</endereco> <email>dumont@14bis.com.br</email> <telefone tipo="residencial" > <ddd>21</ddd> <numero>2313011</numero> </telefone> </cartao-simples>
  49. 49. 9 Atributos !! Só podem conter um descendente: nó de texto atributos <?xml version="1.0" encoding="iso-8859-1" ?> <cartao-simples> <logotipo href="/imagens/logo14bis.gif" /> <nome>Alberto Santos Dumont</nome> <endereco>Rua do Encanto, 22 - 2o. andar - Centro - 25600-000 - Petrópolis - RJ</endereco> <email>dumont@14bis.com.br</email> <telefone tipo="residencial" > <ddd>21</ddd> <numero>2313011</numero> </telefone> </cartao-simples>
  50. 50. 10 Nós de texto !! Não podem ter descendentes (são as folhas da árvore) nós de texto <?xml version="1.0" encoding="iso-8859-1" ?> <cartao-simples> <logotipo href="/imagens/logo14bis.gif" /> <nome>Alberto Santos Dumont</nome> <endereco>Rua do Encanto, 22 - 2o. andar - Centro - 25600-000 - Petrópolis - RJ</endereco> <email>dumont@14bis.com.br</email> <telefone tipo="residencial" > <ddd>21</ddd> <numero>2313011</numero> </telefone> </cartao-simples>
  51. 51. 11 Entidades gerais !! São constantes associadas a um valor de texto !! Podem aparecer em qualquer lugar do documento !! São substituídas durante o processamento do documento !! Podem ser definidas pelo usuário (via DTD) !! Sintaxe: !"#$%&'&"() !! Exemplo: !! !"#$#%"&%'()&*+ !! Entidades pré-definidas: !! !*$()) )que corresponde a +) !! !,$()) )que corresponde a -) !! !'./() )que corresponde a !) !! !012$())que corresponde a 3) !! !'/24())que corresponde a 5))
  52. 52. 12 Entidades de caracteres !! Também são substituídas durante o processamento do documento !! Sintaxe: !! !"#$%&'()*+,-./0123456 !! !"7#$%&'()*+,-8/73./0123456 !! Exemplos: !! !"9+:56;"799<=566 !! !"799=95 representa um espaço em Unicode !! Veja mais em www.unicode.org/charts/ !! XML não define por default as entidades do HTML !! Não existe !>,?@56ou !3A14./56a menos que sejam definidas em um DTD (como no DTD do XHTML)
  53. 53. 13 Elementos e atributos: regras básicas !! Etiqueta inicial e final têm que ter o mesmo nome (considerando diferença de maiúscula e minúscula) !! Não pode haver espaço depois do ! nas etiquetas iniciais nem depois do !"#nas finais !! Atributos têm sempre a forma nome, seguido de '$', seguido do valor entre aspas ou apóstrofes !! !"#$%&'()"*&+ou !"#$+%+,'()"*, são válidos !! aspas podem ser usadas entre apóstrofes !! apóstrofes podem ser usados entre aspas !! aspas e apóstrofes não podem ser neutralizados, mas podem ser representados pelas entidades -./"01+e -(2"31+ !! Não pode haver atributos na etiqueta final !! Atributos não podem se repetir no mesmo elemento
  54. 54. 14 Um documento é bem formado quando !! Tem um único elemento raiz !! Todas as etiquetas iniciais e finais dos seus elementos combinam (levando em conta maiúsculos e minúsculos) !! Seus elementos estão bem aninhados !! Não acontece nada do tipo !"#!$#!"#$!%$#& !! Valores dos atributos estão entre aspas ou apóstrofes !! Os atributos não se repetem !! Elementos e atributos têm identificadores válidos !! Comentários não aparecem dentro de etiquetas !! Sinais < ou & nunca ocorrem dentro de atributos ou nós de texto do documento
  55. 55. 15 Elementos e atributos !! Elementos mal formados !"#$%&'(()%*+$,-'./.%"01$%&'(()%*! "23*"24*'./5!-5"0.6*"0.$*! !!".6*'./5!-5"0!.6*! !"/,-787%*9!:!;!"!<!:!="0/,-787%*! !">?@ABC*DEFGHH"0IJKLMN*! !! Atributos mal formados !"1$%&'((7%!.'1%OD*+$,-'./.%"01$%&'(()%*! !"8P7Q/!9ORSTUFVR#WFFR!0*! !!"7!9ORDR!;ORXR!<ORER!9ORHR!0*! !! Elementos e atributos bem formados !"1$%&'((7%!.'1%OYXY*Z[('8%"01$%&'(()%*! !"8P7Q/!9!O!RSTUFV,-%.]#WFFR!0*!
  56. 56. 16 Quando usar elementos ou atributos? !! Há várias maneiras de representar a mesma informação em XML !"#$#%&'()&(*++,!("#$#%- !"#$#-".#/0&'0-123/0)&0-#45/0*++,0-(%- !"#$#%- -!".#%&'!(".#%- -!123%)&!(123%- -!#45%*++,!(#45%- !("#$#%--
  57. 57. 17 Quando usar elementos ou atributos? !! Uma questão de design !! Elementos geralmente referem-se a coisas que têm atributos !! Atributos geralmente são características dessas coisas que podem ser descritas com poucas palavras !! Uma questão de suporte tecnológico !! Atributos não podem conter subelementos !! Atributos são mais fáceis de serem validados num DTD !! Sempre que possível, priorize os argumentos de design aos de suporte tecnológico
  58. 58. 18 Identificadores de elementos e atributos !! Nomes de atributos e elementos !! Podem conter !! qualquer caractere alfanumérico ou ideograma !! ! (ponto) !! " (hífen) !! #$(sublinhado) !! Não podem começar com !! ponto !! hífen !! número !! Não podem começar com a seqüência 'xml' !! É reservada para atributos e elementos com significado especial, definido em especificação (ex: xmlns, xml:lang)
  59. 59. 19 Identificadores de elementos e atributos !! Elementos bem formados !! Elementos mal formados <!"#$%&%'('$>)'"# )&#*%#+*$</!"#$%&%'('$> !"#$%&'()*+*,-./01203' ''!#&45&#$6375%6#$8'9#6%$#!:#&45&#$63' ''!&5;<='=<>?6#$6/@ABCC@'' '''''''''DE6=;F/@AGHB@3IJ6"D&#?='K6=%665$L'MN>"$#!:&5;<=3' !:"#$%&3' !OAO:3' !PQQ+.R-ST-U'PQQ+PVQ/@WWX@3Y-Z1VQ2[V',']^_!:PQQ+.R-ST-U3' !H`T-Z1V3a2-Q,)R-ZVb!:H`T-Z1V3' !P,1ZV'QR'P1cQTZV3AdHeXfBGGBfXeHdA!:P,1ZV'QR'P1cQTZV3' !()*T.2R3gVTb,b!:()*T.2R3''
  60. 60. 20 Conteúdo misto !! Texto misturado com elementos XML !"#$%&'() ))!*$%+'(,!-*$%+'() ))!.+#+/#+0'(1)2345+5$)5$)430'#6+78')))) ))5$3"#')5$)26)5'%26$3"')9:;)<)')) ))!5$0434%+'($=$6$3"'!-5$0434%+'(>)?6)) ))$=$6$3"')<)0'#6+5').'#)52+*)) ))!5$0434%+'($"4@2$"+*!-5$0434%+'()@2$)) ))+"#4A2$6)+=/26)*4/3404%+5')+')) ))%'3"$B5'>)!-.+#+/#+0'() !-"#$%&'())
  61. 61. 21 Bloco CDATA !! Ignora efeitos especiais dos caracteres !"#$#%&'()%*+'!,-!./0"1#$#%&'(! "-2-34&'()'5+$,-*-!'!+-6%$5#-!#*-78'!,-!./09! !"#$%&'&#! !!!!!"-34*-+:(! !!!!!!!!!"5'3-(;'<'!()/:*$:!=1>"15'3-(! !!!!!"1-34*-+:(! **+) !!"1-2-34&'(!!
  62. 62. 22 Instruções de processamento !! Instruções dependentes do processador !! Funcionam como comentários para os processadores que não a conhecem !"!"#$%&"%'()"*#$%&'(%'(&()*'"+'' !"+,$-.%/+(** ''*%,%-.'/)0%1'%0&2,'' '''''3$)0'&4%/(&'' '''''56%$%'2(789'' "+''
  63. 63. 23 Comentários !! Iguais aos comentários HTML !"##$%&'($)$*+$,(+-.'/01($##2$ !! Comentários não podem conter a seqüência -- !"##$$1&'($)$*+$-00($!!"&)01("$##2$
  64. 64. 24 Declaração XML !!É uma instrução de processamento para o processador XML !!É opcional !!Exceto quando o encoding não for UTF-8 (default) !"#$%&!'()*+,-./012/!! !!!!!!(-3,4+-5./+*,6778960/!! !!!!!!*:;-4;&,-(./<(*/!#=!!
  65. 65. 25 XML Namespaces !! Permite que elementos de mesmo nome de diferentes aplicações sejam misturados sem que haja conflitos !! Um namespace (universo de nomes) é declarado usando atributos reservados !! !"#$%&'()*$+(,(-.)/0'1(namespace default): associa o identificador com todos os elementos contidos no elemento que declara o atributo que não estão qualificados com prefixo. Ex: 2$/"*31 !! !"#$%450*,(!/&'()*$+(,(-.)/0': associa o identificador com os elementos e atributos contidos no elemento que declara o atributo cujo nome local é precedido do prefixo. Ex 250*,(!/4$/"*31 !! O prefixo é arbitrário e só existe dentro do documento !! O identificador (geralmente uma URI) deve ser reconhecido pela aplicação para validar o documento !! XML Namespaces é uma especificação a parte !! !""#$%%&&&'&(')*+%,-%./0123/45%6
  66. 66. 26 Exemplo <ct:cartao xmlns:ct="urn:B1-01.234.567/cartoes"> <ct:nome>Alberto Santos Dumont</ct:nome> <ct:endereco>Rua do Encanto, 22 - Centro 25600-000 - Petrópolis - RJ</ct:endereco> <ct:email>dumont@14bis.com.br</ct:email> <ct:telefone tipo="residencial"> <ct:ddd>21</ct:ddd> <ct:numero>2313011</ct:numero> </ct:telefone> </ct:cartao> Esta URI está associada a este prefixo Vale para todo o elemento <cartao>
  67. 67. 27 Exemplo com 3 namespaces <departamento xmlns:ct="urn:B1-01.234.567/cartoes" xmlns="emp:E2-3349.9.0001-89/empresa" xmlns:html="http://www.w3.org/WD/REC-HTML/Strict"> <ct:nome>Fulano de Tal</ct:nome> <nome>Contabilidade</nome> <endereco>Rua Projetada, 33</endereco> <html:a href="web.html"> <html:strong>link negrito HTML</html:strong> </html:a> <urgencia><ct:numero>2313011</ct:numero></urgencia> </departamento> URI padrão XHTML Namespace default
  68. 68. 28 Observações importantes sobre namespaces !! O escopo da declaração xmlns (sem prefixo) inclui !! O elemento onde ela acontece !! Os elementos-filho !! O escopo da declaração xmlns:prefixo inclui !! O próprio elemento se qualificado com mesmo prefixo !! Os elementos-filho qualificados com o prefixo !! Os atributos do elemento onde ocorre a declaração e elementos filho qualificados com o prefixo !! O identificador não representa endereço na internet !! Geralmente é escrito como URL, porque URLs são unívocas !! O identificador é string e não endereço: omitir ou incluir uma ! final faz diferença !! Declarar e usar um namespace pode ser opcional !! Depende da aplicação que irá processar o documento
  69. 69. 1 XML: uma introdução prática X100 Helder da Rocha (helder@argonavis.com.br) Atualizado em setembro de 2001
  70. 70. 2 Documentos XML bem formados !! Para que possa ser manipulado como uma árvore, um documento XML precisa ser bem formado !! Documentos que não são bem formados não são documentos XML – use um editor XML para descobrir !! Documentos bem-formados obedecem as regras de construção de documentos XML genéricos !! Regras incluem !! Ter um, e apenas um, elemento raiz !! Valores dos atributos estarem entre aspas ou apóstrofes !! Atributos não se repetirem !! Todos os elementos terem etiqueta de fechamento !! Elementos estarem corretamente aninhados
  71. 71. 3 XML válido !! Um XML bem construído pode não ser válido em determinada aplicação !! Aplicação típica pode esperar que !! elementos façam parte de um vocabulário limitado, !! certos atributos tenham valores e tipos definidos, !! elementos sejam organizados de acordo com uma determinada estrutura hierárquica, etc. !! É preciso especificar a linguagem! !! Esquema: modelo que descreve todos os elementos, atributos, entidades, suas relações e tipos de dados !! Um documento XML é considerado válido em relação a um esquema se obedecer todas as suas regras
  72. 72. 4 Por que validar? !! Para a maior parte das aplicações, um XML bem formado é suficiente !! É possível, em documentos XML bem-formados, mas que não são válidos !! Montar a árvore usando DOM !! Extrair nós, acrescentar nós, alterar o conteúdo dos elementos usando SAX ou DOM !! Transformar o documento em outro usando XSLT !! Gerar um PDF ou um SVG com dados contidos no documento !! Exibir o XML em um browser usando CSS !! Então porque ter o trabalho de criar um DTD ou um XML Schema?
  73. 73. 5 Definir um esquema !! Documentos não válidos são "individualistas" !! Um esquema representa um conjunto de documentos, que existem e que virão a existir !! É possível fazer muitas coisas com UM documento não válido. É difícil automatizar os processos sem considerar uma CLASSE de documentos !! Um esquema é uma formalidade necessária !! Se você tem uma grande coleção de documentos que foram construídos segundo determinadas regras, você já tem, informalmente, um esquema !! Para validar documentos de acordo com suas convenções, é preciso ter um esquema
  74. 74. 6 Esquema !! O esquema representa uma classe !! Os documentos são instâncias Esquema (universo de documentos válidos) Documentos que aderem à especificação (válidos) Documento fora da especificação !! Como definir esquemas: !! DTD - Document Type Definition !! W3C XML Schema
  75. 75. 7 Documentos válidos !! Um relacionamento pode ser estabelecido formalmente entre um esquema e sua instância !! Declaração de tipo de documento (para DTD) !! !"#$%&'()*!"#$%&%'+'+&),*-./012324535-6* !! Declaração de namespace e schema (para XML Schema), no elemento raiz !! !!"#$%&%'785/98:-;,<=&>-* ?@0AB:-133CDEEF.7478@-* ?@0ABD?B/:-133CDEEGGG4GH48I9EJKKLEM,N+712@FO/AB3FA72-* ?B/DB712@FN87F3/8A:-133CDEEF.7478@*./012324?B5-6*444* !! Para validar !! Use um parser validador (com suporte à linguagem de esquema desejada)
  76. 76. 8 O que define um esquema !! Um vocabulário !! Elementos, atributos !! Uma gramática !! Relacionamentos (que elementos são permitidos onde, e de que forma, e com que conteúdo) !! Uma coleção de entidades !! Variáveis que são substituídas por valores constantes durante o processamento (nem todo esquema tem suporte a declaração de entidades)
  77. 77. 9 !! Um DTD (Document Type Definition) declara todos os elementos e atributos de um documento XML !! Define quais elementos e atributos são válidos e em que contexto !! A sintaxe é baseada em SGML. Para definir um elemento: <!ELEMENT nome-do-elemento (modelo de conteudo)> !! O DTD do web.xml define principalmente elementos !! Exemplo: DTD para um documento simples <!ELEMENT pessoa (nome, web?, telefone+)> <!ELEMENT nome (prenome, inicial*, sobrenome)> <!ELEMENT prenome (#PCDATA)> <!ELEMENT inicial (#PCDATA)> <!ELEMENT sobrenome (#PCDATA)> <!ELEMENT web (email|website)> <!ELEMENT email (#PCDATA)> <!ELEMENT website (#PCDATA)> <!ELEMENT telefone (#PCDATA)> Elementos que só podem conter texto web pode conter ou um email ou um website nome tem um prenome, seguido de zero ou mais inicial e um sobrenome pessoa tem nome, seguido de zero ou um web e um ou mais telefone O que é um DTD?
  78. 78. 10 Documentos válidos segundo o DTD !! Os documentos abaixo são válidos segundo o DTD mostrado na página anterior <pessoa> <nome><prenome>Giordano</prenome> <sobrenome>Bruno</sobrenome></nome> <telefone>1199343232</telefone> </pessoa> <pessoa> <nome><prenome>Giordano</prenome> <inicial>F</inicial><inicial>R</inicial> <sobrenome>Bruno</sobrenome></nome> <web><email>giordano@web.net</email></web> <telefone>1199343232</telefone> <telefone>1134999992</telefone> </pessoa> <pessoa> <nome><prenome>Giordano</prenome> <sobrenome>Bruno</sobrenome></nome> <web><website>www.site.com</website></web> <telefone>1199343232</telefone> </pessoa>
  79. 79. 11 Documentos inválidos segundo o DTD !! Os documentos abaixo não são válidos de acordo com o DTD. !! Por que? <pessoa> <nome><prenome>Giordano</prenome> <sobrenome>Bruno</sobrenome></nome> </pessoa> <pessoa> <nome><prenome>Giordano</prenome> <sobrenome>Bruno</sobrenome></nome> <telefone>1199343232</telefone> <telefone>1134999992</telefone> <web><email>giordano@web.net</email></web> </pessoa> <pessoa> <nome><prenome>Giordano</prenome> <sobrenome>Bruno</sobrenome></nome> <web><website>www.site.com</website> <email>giordano@web.net</email></web> <telefone>1199343232</telefone> </pessoa>
  80. 80. 12 DTD para validar uma instância !! Considere o seguinte documento XML <bilhete codigo="ZMIKT8"> <voo transportador="JH" numero="2349" de="REC" para="CGH" /> <passageiro> <sobrenome>Newton</sobrenome> <prenome>Isaac</prenome> </passageiro> </bilhete>
  81. 81. 13 Possíveis regras de validação !! Os elementos permitidos são !! bilhete, voo, passageiro, sobrenome, prenome !! O elemento bilhete contém pelo menos um voo e exatamente um passageiro !! o elemento passageiro deve ter um elemento sobrenome e um elemento nome !! os atributos de e para de voo contém valores !! que podem ser escolhidos de uma lista em um DTD !! que podem ser qualquer coisa, em outro DTD
  82. 82. 14 UM possível DTD !! Este DTD valida o documento de forma pouco rigorosa !"#$#%#&'()*+,-.-(/(0112(345546-*71(8(9( !":''$;<'()*+,-.-(=1>*61(&%'?@#&(AB#CD;B#E(9( !"#$#%#&'(345546-*71(/(51)7-F1G-2(37-F1G-(8(9( !"#$#%#&'(37-F1G-(/(AHIE:':(8(9( !"#$#%#&'(51)7-F1G-(/(AHIE:':(8(9( !"#$#%#&'(011(#%H'J(9( !":''$;<'(011(>-(&%'?@#&(AB#CD;B#E(9( !":''$;<'(011(FKG-71(&%'?@#&(AB#CD;B#E(9( !":''$;<'(011(3474(&%'?@#&(AB#CD;B#E(9( !":''$;<'(011(.74F5317.4>17(&%'?@#&(AB#CD;B#E(9((
  83. 83. 15 Um DTD melhor !! Este DTD restringe as informações que podem ser usadas nos atributos de voo !"#$#%#&'()*+,-.-(/(01123(456657-*81(9(:( !";''$<='()*+,-.-(>1?*71(&%'@A#&(BC#DE<C#F(:( !"#$#%#&'(456657-*81(/(61)8-G1H-3(48-G1H-(9(:( !"#$#%#&'(48-G1H-(/(BIJF;';(9(:( !"#$#%#&'(61)8-G1H-(/(BIJF;';(9(:( !"#$#%#&'(011(#%I'K(:( !";''$<='(011(?-(/C#J(L(JMN(L(MCE(L(=FE9(BC#DE<C#F(:( !";''$<='(011(GOH-81(&%'@A#&(BC#DE<C#F(:( !";''$<='(011(4585(/C#J(L(JMN(L(MCE(L(=FE9(BC#DE<C#F(:( !";''$<='(011(.85G6418.5?18(/PN(L(CM9(BC#DE<C#F(:((
  84. 84. 16 Elementos de um DTD XML 1.0 !! !"#$%&'()*++ !! Vincula o DTD a um documento !! Usad0 no início do documento XML !! !"),)-).&*++ !! Define um elemento !! !"/&&,01&*++ !! Define os atributos de um elemento !! !").&0&'*++ !! Define uma entidade ( ex: !"#$%&') !! !".$&/&0$.*++ !! Define notação interna para uma URI
  85. 85. 17 Elemento <!DOCTYPE> !! O elemento <!DOCTYPE> é um elemento do DTD que deve ser usado dentro da página XML !! Identifica o elemento raiz !! Associa o arquivo a um DTD através de URL ou identificador público !! Como vincular um documento XML a um DTD !"#$%&'()*+,-./012/&(-3,4+-5./6789::;<90/&"=& !>!"#$%&'(3?)@?,9*+$A%(*&)%)$'*(/3?)@?,14@4/=& !3?)@?,9*+$A%(*=& &&&!-,$(=&B111C& !! Alguns DTDs possuem um identificador formal público (FPI) !! Neste caso, são declarados com a palavra PUBLIC e duas strings: o identificador seguido de uma URL onde pode ser encontrado nome do elemento raiz do documento onde buscar validação: SYSTEM ou PUBLIC URI ou identificador !>D8EFGHI&JFKL&&+,-.#(/9MMNOEMMDFD&JFKL&P12MMIQ/&&&&&&&&&&&&&&& &&&&/R@@ASMMTTT1TO1,)5MFUMUIE9R@$%P2M*@)+3@14@4/=&&
  86. 86. 18 DTD Interno !"#$%&!'()*+,-./012/!(-3,4+-5./+*,6778960/!#:! ";<=>?@AB!!"##$%&C! !!";BDBEBF?!G(**,H!I-,%(J!G),K+**H,LM:! !!";BDBEBF?!-,%(!IG)(-,%(J!*,N)(-,%(M:! !!";BDBEBF?!G)(-,%(!IOA><P?PM:! !!";BDBEBF?!*,N)(-,%(!IOA><P?PM:! !!";BDBEBF?!G),K+**H,!IOA><P?PM:! Q:! !"G(**,H:! !!"-,%(:! !!!!"G)(-,%(:R+3SH)4"TG)(-,%(:! !!!!"T*,N)(-,%(:U(V-%H-"T*,N)(-,%(:! !!"T-,%(:! "TG(**,H:!
  87. 87. 19 DTD incompleto !! O DTD foi importado, mas está incompleto. Parte dele é definido localmente !! Elementos, atributos e entidades definidos no documento têm prioridade sobre declarações importadas !! Processador lê primeiro elementos locais, depois os que foram carregados do DTD externo !! A primeira declaração é usada. Declarações adicionais para o mesmo elemento/atributo/entidade são desconsideradas – logo, declarações locais têm precedência !"#$%&'()*+,--./*!"!#$%&'()**+,-./.'0* ***!")1)2)3&*4.5,*67(%#8&89:* ***!")3&;&'**<=<*>#.?@5,4=*&A+,*#,BC4C=C.4>:* D:*
  88. 88. 20 DTD: exemplo <!ELEMENT cartao-simples ( logotipo?, nome, endereco, email*, telefone+ ) > <!ELEMENT logotipo EMPTY > <!ATTLIST logotipo href CDATA #REQUIRED > <!ELEMENT nome ( #PCDATA ) > <!ELEMENT endereco ( #PCDATA ) > <!ELEMENT email ( #PCDATA ) > <!ELEMENT telefone ( ddd, numero ) > <!ATTLIST telefone tipo ( residencial | comercial ) "residencial" codigo-pais NMTOKEN #IMPLIED > <!ELEMENT ddd ( #PCDATA ) > <!ELEMENT numero ( #PCDATA ) > zero ou uma ocorrência exatamente uma ocorrência cada zero ou mais ocorrências uma ou mais ocorrências não pode conter outros nós (exceto atributos) definição de elemento lista de atributos atributo obrigatório contém "Character DATA" atributo opcional contém nome ou número um ou o outro valor default
  89. 89. 21 Elemento <!ELEMENT> !! Sintaxe !!"#"$"%&'"#$%&'#&%(%$%")#*+#")%,'#*-* !! O conteúdo pode ser !! (1) ()*+,-&-., !! (2) (uma seqüência., !! (3) (uma lista de opções., !! (4) (conteúdo misto., !! (5) a palavra "$*&/ ou !! (6) a palavra -%/.
  90. 90. 22 Conteúdo #PCDATA !! Parsed Character Data !! Elemento declarado com esse tipo pode conter apenas texto simples !! Pode conter entidades &valor; !! Não pode conter elementos
  91. 91. 23 Conteúdo Seqüência !! O conteúdo deve ter uma lista de elementos separados por vírgula !! Indica que os elementos filho que podem aparecer dentro do elemento declarado !! Define uma ordenação dos elementos filho !! Podem ter sufixos indicando multiplicação !! ! zero ou mais !! " um ou mais !! # zero ou um !! Exemplos !! !"#$#%#&'($%&'%())*+,-.(/-0-1+*-2.(( ((((((((((((((((((-,3405.(6-784/-9:(;( !! !"#$#%#&'('&*+))0+<+,+/4=3.(=3>+-85:(;((
  92. 92. 24 Conteúdo lista de opções !! Lista de elementos separada por | !! Indica que um dentre os elementos filho listados pode ser usado como conteúdo do elemento declarado !! Exemplos !"#$#%#&'(!"#$%&')*+,,-./0,/-(1(23,+-(1(( (((((((((((((((((((,-4-./0,/-(1(*56./257(8(( !"#$#%#&'($("$)*&')9+:;,-<(),2/-(1(4/2=+;,-77(8( !"#$#%#&'(+&,!&'))><(?7(1(),<(@77(8( !"#$#%#&'(,&-#')A,+:-=+(1(B-C,+:-=+(1(( ((((((((((((((()A,+:-=+<(/:/9/25D<(B-C,+:-=+778(
  93. 93. 25 Conteúdo misto !! !"#$%&'&()(*+*,-()(...()(*+*,/01( !! Permite conteúdo de elementos, conteúdo de texto ou elementos misturados com texto !! Conteúdo misto não admite outra sintaxe !! "#$%&'&(tem que ser o primeiro elemento !! O * no final é obrigatório !! Não é possível controlar o número ou ordem dos filhos !! Exemplo: a seguinte declaração em DTD !"#$%$&$'(!2345*()*+,-.(.!/!*/245*012! permite o seguinte conteúdo (62345*7.!34567!897!6*/245*77:768*/245*7(:79!;<=!3=>!5! 897!6*/245*77:568*/245*7(=9?>9@682345*7(
  94. 94. 26 Conteúdo Vazio e Any !! Elementos que não podem conter nada devem ser declarados como EMPTY !! !"#$#%#&'()*+,(!"#$%-( !! Elementos EMPTY podem conter atributos !! !".''$/0'()*+,(12,)*+,(34.'.(56#78/6#4-( !! A declaração acima permite elementos como !! !)*+,(12,)*+,9:;*<=:(>-( !! ANY: use para elementos que podem conter qualquer coisa !! !"#$#%#&'(?*@*<(&'%-(
  95. 95. 27 Elemento <!ATTLIST> !! Sintaxe !"#$$%&'$(()*)+),-.(( (( ( ( (( (/-0123-.4(-15.(6/*.078)9/3*-:(( !"#$$%&'$(()*)+),-.(( (( ( ( ( (/-0123-.;(-15.(6/*.078)9/3*-:(( <<<(( ou(( !"#$$%&'$(()*)+),-.(( (( ( ( ( (/-0123-.4(-15.(6/*.078)9/3*-(( (( ( ( ( (/-0123-.;(-15.(6/*.078)9/3*-(( (( ( ( ( (/-0123-.=(-15.(6/*.078)9/3*-(( (( ( ( ( (/-0123-.>(-15.(6/*.078)9/3*-(( <<<(:(
  96. 96. 28 Exemplos !"#$%%&'(%!)**!+,!-.%/01-!!!2'.3&'14!5! "#$%%&'(%!)**!678,9*!:4$%$!2;'<14!=>?@A?B>=5! "#$%%&'(%!)**!CD9D!EF1:!G!:HI!G!HFJ!G!(4JK!2F1LJ'F14!5! "#$%%&'(%!)**!M9D6NC*9MD+*9!EFH!G!OIK!=FH=!5! ou !"#$%%&'(%!)**!+,!-.%/01-!!!!!2'.3&'14!! ! ! ! !!!!!!678,9*!:4$%$!!!2;'<14!=>?@A?B>=! ! ! ! !!!!!!CD9D!EF1:!G!:HI!G!HFJ!G!(4JK!2F1LJ'F14!!! ! ! ! !!!!!!M9D6NC*9MD+*9!EFH!G!OIK!=FH=!5!
  97. 97. 29 Tipos de dados !"#$#% &'$()*&% &'$()*&+% Lista de opções ,"% ,"-*.% ,"-*.+% *&$,$/% *&$,$,*+% &($#$,(&%
  98. 98. 30 Tipo CDATA e NMTOKEN !! CDATA (character data) representa qualquer texto arbitrário !! Pode conter espaços, pontuação, etc. !! NMTOKEN (name token). É semelhante a um nome de elemento ou atributo !! Caracteres alfanuméricos apenas !! Não pode conter espaços nem pontuação !! NMTOKENS representa um ou mais NMTOKEN separados por espaços. !"#"$"%&'()&*+,-&'./-$(0'+1(&*21(34(56/7(
  99. 99. 31 Tipo lista de opções !! Uma lista de NMTOKENS dentre os quais pode- se escolher o valor do atributo. !! As escolhas são separadas por |: !"#$%%&'(%!)**!+,-,!./0121342(567!8/096'/05:!! !"#$%%&'(%!;<-=*!+>-?*@*!.@?,2A*?B>7!CA*?B>C:!! !! Elementos não podem conter espaços ou outros caracteres não-alfanuméricos !! O tipo de cada opção é NMTOKEN!
  100. 100. 32 Tipo ID !! Atributos do tipo ID tem que conter um nome (e não NMTOKEN) que seja unívoco no documento. !! Nome tem mesmas regras que identificador XML (caracteres alfanuméricos, não começa com número, etc.) !! Não se pode usar um número como conteúdo de um atributo declarado como ID. !! A solução é colocar um prefixo antes do número que seja ou uma letra ou um sublinhado. !! Elementos só podem ter um tipo ID !! Não pode haver outro elemento na mesma página com o mesmo ID !! Exemplos !"#$%%&'(%!)**!!"#$%"&'(&+,-./',-01! "#$%%&'(%!234*5*!)*+,-"&'(&+,-./',-01!
  101. 101. 33 Tipo IDREF !! IDREF é referência para um ID. Exemplo: !"#$%%&'(%!)*+,-,!.+,/.0,!!"#$%&12345'2367! !! Aplicação ".89,),9-,7! !!":,,!/,0*;,<=#'()*=7!>>>!"?:,,7! !!":,,!/,0*;,<=#'+,-=7!>>>!"?:,,7! !!")*+,-,!@AB89,<=.(=!.+,/.0,<=#'()*=7!! !!!>>>!"?)*+,-,7! !!")*+,-,!@AB89,<=.)=!.+,/.0,<=#'+,-=7!! !!!>>>!"?)*+,-,7! "?.89,),9-,7!
  102. 102. 34 Tipo IDREFS !! Lista de elementos IDREF. Exemplo: !"#$%%&'(%!)*+,-,!.+,/.0,!!"#$%&'12345'2367!! !! Aplicação (codigo e numero são IDs) !".89,),9-,7!! !! !":,,!/,0*;,<=#()*+=7!>>>!"?:,,7!! !! !":,,!/,0*;,<=#(,-.=7!>>>!"?:,,7!! !! !")*+,-,!!@AB89,<=&*=!! !! ! ! ! ! !.+,/.0,<=#(,-.'#()*+=7!! !! !>>>!"?)*+,-,7!! !"?.89,),9-,7!
  103. 103. 35 Valores default !! #REQUIRED: força o autor do documento a definir um valor explícito ao atributo. !! #IMPLIED: o atributo é opcional. !! #FIXED: o atributo tem um valor fixo, constante !! Valor não pode ser mudado !! Autor não precisa definir atributo e, se o fizer, não pode mudar o valor. !! Exemplo: !"#$$%&'$()*+,-(.,/0*(12#$#(!"#$%&'()*+(3(( !! Valor inicial, entre aspas !! Autor não precisa definir atributo, mas pode mudá-lo !"#$$%&'$(),,(4,.5*678*(9:;(<(=>?((,-('3(( !"#$$%&'$(/60/-/4,(5*8@(12#$#((./0123(3(
  104. 104. 36 Elemento <!NOTATION> e tipo NOTATION !! Associa URI a um nome !! Usado frequentemente para associar valores !"#$#%a &'$()*& (mesmo onde não há URIs) !! Exemplos %+,!"#$#%"!&-.-/01%232$*'%45667899:::;-.-/01;<0.4=%% %+,!"#$#%"!&>-?1@A%232$*'%45667899:::;>1;<0.4=%% !! Tipo &($#$B(&%de +,#$$CB2$=%é útil em situações onde não se pode usar !"#$# %+,#$$CB2$%>00D%% %%%%%%%%%%A60?@%!"#$#%"!&E-.-/01%F%>-?1@AG%HI*JKBI*"=%% !! Assim pode-se limitar melhor valores dos atributos %+>00D%A60?@L4-.-/014%9=%
  105. 105. 37 Elemento <!ENTITY> !! Há vários tipos de !"#$%&%'() !! Definem entidades: variáveis usadas nos DTDs e documentos XML !! Entidades de parâmetro (*+,-./): usadas apenas no DTD !! internas – contém texto declarado localmente no DTD !! externas – contém conteúdo de arquivos externos (sub DTDs) !! Entidades gerais (0+,-./): usadas apenas no XML !! internas (são sempre processadas) !! caractere – código Unicode: ō 㪴 !! globais – cinco entidades: &lt; &gt; &amp; &quot; e &apos; !! definidas pelo usuário – contém texto declarado no DTD !! externas (carregam dados de arquivos externos) !! processadas – incluem texto de arquivos externos no XML; o processador resolve as entidades e blocos CDATA se houver !! não-processadas – incluem formatos binários (ex: imagens); o processador ignora o conteúdo e não processa (usado em atributos apenas)
  106. 106. 38 Entidades gerais internas !"#$%&%'()*+,(-./0*1-2( !! Exemplos: !"#$%&'&(!,+31,4/()*+,$!'-./01234!54678!!!! !!!!!!!!!!!!!!!!!!!+96:2;39!.<!+93040!=>*>)?! "#$%&'&(!5*361789:()"14@A<?! "12?! !!!"1.?+97B23CD1!5EFGG*H!IGGG"J1.?! "J12?! "J14@A<?)?! !! Uso !"1<F19?!K3031<!4!;,+31,4/<!43-.4!D9L<#>!! "J1<F19?! !!".3M?!;5*361789:<("J.3M?!!
  107. 107. 39 Entidades gerais externas !! Carregam texto de arquivos externos ao XML !! !"#$%&'&(!)*+,!-(-&$.!/012/3! !! !"#$%&'&(!)*+,!4567'8!/9:2/!/012/3! !! Exemplo !"#$%&%'()*+,-.,/(-(-&$.!01.*21)*+,34)506( !! Uso !*5*)*+786( ;+,)0<=0:>! !*5*)*+786( !! Conteúdo de menu.xml: !)*+,6( %*478( !1)*+,6( !! Resultado !*5*)*+786( ((!)*+,6( ((((%*478( ((!1)*+,6( !1*5*)*+786(
  108. 108. 40 Entidades gerais externas não processadas !! Usadas para carregar dados que não podem ser processados (que não são texto) através de atributos !"#$%&'&(!)*+,!-(-&$.!/012/!%34&4!)*5678*9!! !! Depende de uma declaração NOTATION !! Neste caso típico usada para informar tipo de dados !! Exemplo de uso no DTD !"#$%&'&(%$!:2;!)*)&+,!-./01231.4-5!! !"#+$&(&*!<*:*!)*)&+,!-671781.4-!%34&4!:2;5!! !! Atributos podem declarar receber tipo ENTITY !"#'&&9()&!2+6:,+!;*)5,!$%&'&(!:;+<=(;+>5! !! Uso no XML: !"2+6:,+!;*)5,?-<*:*-5!! Esta entidade geral logo é usada apenas em atributos A sintaxe é diferente: seria &logo; se fosse uma entidade processada
  109. 109. 41 Entidades de parâmetro internas !"#$%&%'()(*+,-(./01+2.3( !! Variáveis declaradas e usadas apenas dentro do DTD !! Em vez de repetir !"#$%$&$'(!)**!+,!!!-.$/!0!/12!0!1.3!0!141!0!56378! "#$%$&$'(!)**!9:;:!-.$/!0!/12!0!1.3!0!141!0!56378! !! Declare as entidades !"#$'(4(<!)(0-2+45((=/12!0!1.3=8! "#$'(4(<!)(0-2+26+(=141!0!563=8! !! E use no DTD "#$'(4(<!)(0-2+5+27+4(=.$/!0!)0-2+26+8(0!)0-2+458=8! "#>((%45(!)**!+,!-)0-2+5+27+487!?.$@34.$6!8 "#>((%45(!)**!9:;:!-)0-2+5+27+487!?.$@34.$6!8!
  110. 110. 42 Entidades de parâmetro externas !! Carregam fragmentos de DTDs externos !"#$%&%'()(*+,-(.'.%#/(0123+405( !! Exemplo !"#$%&'&(!)(627-32()()&$*!+1++89:6:+,! !! É preciso chamar a entidade dentro do DTD. !! Uso !"#$%&'&(!---,!! )627-32;(! "#$.$*$%&!---,! !---!! !! Conteúdo de voos.dtd: !"#$%&'&(!/!01!!+2345367+,!! !"#$%&'&(!/!89:!+3'35);7+, •! Resultado "#$%&'&(!---,!! "#$%&'&(!/!01!!+2345367+,!! "#$%&'&(!/!89:!+3'35);7+,! "#$.$*$%&!---,!
  111. 111. 43 Condicionais !! À primeira vista parecem inúteis !! Servem para construir DTDs configuráveis e modulares !! Módulos permitem segmentação e reuso !! São usados por aplicações como XHTML 1.1, SVG 1.1 !! Bloco IGNORE: ignora o conteúdo !"#$!"#$%&'$! !!!"#%&%'%()!*+,-./+0!123456)678! 998! !! Bloco INCLUDE: declara que o texto deve ser interpretado !"#$!#()*+&'$! !!!"#%&%'%()!*+,-./+0!123456)678! 998!
  112. 112. 44 Utilidade de blocos condicionais !! Se texto "IGNORE" OU "INCLUDE" for atribuído a entidades de parâmetro, pode-se "ligar" ou "desligar" declarações !! Exemplo: no DTD importado !"#$%&%'(!"#$%&'$()*#(+)")&*$+,#)-( !"#$%&%'(!"#$%&'$()*#(#*&,")&*$+,#)-( !"./0123415670586(.( (((!"#9#:#$%(;73<=<(>?@ABC%CD-( EE-( !"./01234156705073<(.( (((!"#9#:#$%(6=3<;73<=<(>?@ABC%CD-( EE-( !! Blocos acima são "desligados" por default !! Em um DTD local, pode-se "ligar" o que se deseja usar (!"#$%&%'(!"#$%&'$()*#(+)")&$A9FB#)-( !! Agora elemento <coisas> faz parte do DTD!
  113. 113. 45 Validação: além do DTD !! DTD !! vantagem: é simples !! desvantagens: (1) não usa sintaxe XML; (2) é limitado. !! XML Schema !! vantagem: (1) é XML; (2) permite especificação muito mais precisa e detalhada. !! desvantagem: é muito mais complicado que DTD !! Schema ainda não resolve todos os problemas !! Outras alternativas: Trax, RELAX, Schematron !! XML Schema é extensível e permite usar essas linguagens para completar a validação !! Em certos casos ainda pode ser preciso realizar validação adicional usando alguma linguagem (Python, Java)
  114. 114. 46 XML Schema !! XML Schema é uma alternativa ao DTD !! Oferece mais recursos !! Usa sintaxe XML !! Exemplo (trecho do XML Schema para o bilhete de vôo) !"#$%&'()*+,-./012/"3& !#*4*56($7&#$%-*4#*./68894::;;;1;<1,)=:>220:?@AB56($7/3& &!#*4(%($(-8&-7$(./C+%6(8(/3& &&!#*45,$9%(#DE9(3& &&&!#*4*(FG(-5(3& &H111I& &&!#*4(%($(-8&-7$(./',,/3& &&&!#*45,$9%(#DE9(3& &&&&!#*4788)+CG8(&-7$(./J(/&G*(./)(FG+)(J/3& &&&&&!#*4*+$9%(DE9(3& &!#*4)(*8)+58+,-&C7*(./#*4*8)+-=/3& &&!#*4(-G$()78+,-&'7%G(./KLM/&:3& &&!#*4(-G$()78+,-&'7%G(./MNO/&:3& &&!#*4(-G$()78+,-&'7%G(./NKP/&:3& &&!#*4(-G$()78+,-&'7%G(./BQP/&:3& &!:#*4)(*8)+58+,-3& &&&&&!:#*4*+$9%(DE9(3& &&&&!:#*4788)+CG8(3&H111I& &!:#*4(%($(-83& !:#*4*56($73&
  115. 115. 1 XML: uma introdução prática X100 Helder da Rocha (helder@argonavis.com.br) Atualizado em setembro de 2001
  116. 116. 2 Programação com XML !  Há duas maneiras populares para manipular (interpretar, gerar, extrair dados e tratar eventos) arquivos XML: !  Document Object Model (DOM) – representação em árvore !  Simple API for XML (SAX) – representação sequencial !  As duas técnicas servem a finalidades diferentes. !  SAX é mais simples. Oferece métodos que respondem a eventos produzidos durante a leitura do documento !  Notifica quando um elemento abre, quando fecha, etc. !  Permite ler dados enquanto XML carrega !  DOM monta uma estrutura hierárquica de objetos, em forma de árvore, que permite a navegação na estrutura do documento !  Propriedades dos objetos podem ser manipuladas !  Viabiliza scripting em aplicações como XHTML e SVG !  Oferece suporte a várias APIs que usam XPath para extrair dados, permitindo maior produtividade e eficiência
  117. 117. 3 SAX ou DOM? !  SAX !  Gasta menos memória: não precisa carregar o documento inteiro !  Ideal para aplicações simples que não precisam manipular com toda a árvore de objetos (ex: busca simples) !  Programação em nível mais primitivo: foco em eficiência !  Pode-se usar SAX para montar uma árvore DOM !  Não é um 'padrão'; é mais uma técnica de processamento que uma API; há várias alternativas similares: StAX (Java), SAX2, etc. !  DOM !  Mais novo (linguagens mais antigas suportam apenas SAX) !  Baseado em objetos e mais fácil de usar (API de nível mais alto) !  Há uma API padrão do W3C (há outras APIs similares: JDOM, etc.) !  É a única opção para manipulação no cliente (via scripts) !  Permite validação e busca sofisticada combinado com XPath !  APIs disponíveis em várias linguagens !  Java, VB, C/C++, Objective-C, C#, Python, Ruby, JavaScript (DOM)
  118. 118. 4 Bibliotecas e APIs populares !  Em C e C++ (parsers, SAX e DOM) !  libxml2 (projeto Gnome): http://www.xmlsoft.org !  Apache Xerces C++: http://xerces.apache.org/xerces-c !  Em Java !  Pacotes nativos: javax.xml (parsers), org.w3c.dom, org.w3c.sax !  Microsoft .NET !  XmlTextReader (navegação na árvore), XmlReader (SAX) !  XmlDocument (DOM), XPathNavigator !  PHP !  xml_parser_create() (SAX, desde PHP3) !  new DomDocument (DOM, desde PHP5) !  Python !  Pacotes nativos: xml.sax e xml.dom !  Objective-C na plataforma Apple !  Mac OS X: NSXML (SAX) NSXMLDocument (similar a DOM) !  iOS 4: NSXML (SAX) – DOM somente usando bibliotecas de terceiros
  119. 119. 5 W3C DOM !  Document Object Model – API padrão !  Padrões do W3C: DOM Level 1, DOM Level 2 !  Usado também por HTML !  Objetivo da especificação: oferecer uma interface de programação uniforme, independente de plataforma e linguagem, para aplicações que manipulam XML !  Serve para !  criar um novo documento XML !  navegar na árvore XML !  modificar, remover ou adicionar nós (elementos, atributos, texto, comentários, PIs, etc.)
  120. 120. 6 SAX !  Simple API for XML !  Técnica de processamento que dispara eventos durante processamento do documento !  eventos representam componentes lidos e podem ser capturados por objetos ouvintes cadastrados !  ações podem ser tomadas em cada situação !  Exemplos de eventos !  inicio e fim do documento !  início e fim do elemento (pode-se descobrir qual) !  nó de caractere !  nó de comentário !  ...
  121. 121. 7 Como escolher entre SAX e DOM !  Não são concorrentes – são complementares !  DOM é ideal para manipular a árvore XML recursivamente e fundamental para scripting !  SAX é ideal para ler o documento seqüencialmente !  DOM requer carga de todo o documento antes de iniciar o processamento: consome mais memória !  SAX não "lembra" de tarefas realizadas: não serve para validar referências cruzadas !  Em aplicações típicas, havendo suporte a DOM, use-o! !  É muito mais produtivo, moderno e fácil de entender !  Use SAX quando precisar de eficiência !  Use SAX quando não puder ter o XML inteiro na memória (ex: extração seletiva, busca, processos paralelos, etc.)
  122. 122. 8 SAX: exemplo do funcionamento !  Se um processador SAX receber o documento ... !"#$%&$'! !!"()*+$,)(!-./010'23(!.-$4"5()*+$,)('! "5#$%&$'! !  ... ele irá disparar os seguintes eventos: ! !"#$"%&'()*+",-. ! !"#$"/0*)*+",1'#$"#12.34-. ! !"#$"/0*)*+",1)*+!#5*)12.36""$78("*,179121:1-4-. ! ';#$#'"*$!,1<&).97#=1-. ! *+9/0*)*+",1)*+!#5*)1-. ! *+9/0*)*+",1'#$"#1-. ! *+9%&'()*+",-. !  Programador deve implementar um objeto "ouvinte" para capturar os eventos e extrair as informações desejadas
  123. 123. 9 Como usar SAX em Java !  Crie classe ouvinte estendendo !"#$%&'$()*$+,-)./01)23/,"4 !"#$%&'&$())'567)*1)23/,"4*+,*-.)'/*0("$,1(-.$*2'34445' !  Implemente os métodos de evento desejados nessa classe !  Crie outra classe para inicializar o parser e processar o documento XML !  Importe as classes 789:)"(,";)'0!"6, 789:)"(," e 95<=,)3," de !"#$%&'$()*4 6789(2)*2:(&,;2<')!0'='6789(2)*2:(&,;2<4-*>?-),(-&*@AB' 6789(2)*2')!'=')!04-*>6789(2)*2@AB' 8CDE*(.*2'2*(.*2'=')!4F*,8CDE*(.*2@AB' 2*(.*24)*,G;-,*-,1(-.$*2@2,%4567)*1)23/,">?AB'HH' 2*F%),2;'.*'%-,*20(&*' 2*(.*24!(2)*@I3!'.@,20!$*@/JAB'
  124. 124. 10 Exemplo em Java: handlers de eventos !"#$%&'()%*'!"#$#!%&$'+&,-./0'&,1'%23'43-.31'%23'$5263,7'8' ''9).'+%23'%':'43-.3;'%'<'$5263,;'%==7'8' ''''>?435@A)"3A!.%23$2+&,/%07;' ''B' B' !"#$%&'()%*''%#$%()&*&+%+>3.%26'".%1'>3.%26'$)&-$C-@51' '''''''''''''''''''''''''>3.%26'DC-@51'E33.%#"354'-337'8' ''>?435@A)"3A!.%23+F<F'='DC-@57;' ''9).'+%23'%':'G;'%'<'-33A653H5263,+7;'%==7'8' ''''>?435@A)"3A!.%23+F'F'='-33A653IC-@5+%7'='F:JF' '''''''''''''''''''''''''='-33A653K-$"5+%7'='FJF7;' ''B' ''>?435@A)"3A!.%23$2+FLF7;' B' !"#$%&'()%*'&+,()&*&+%+>3.%26'".%1'>3.%26'$)&-$C-@51' '''''''''''''''''''''''''''''''''''>3.%26'DC-@57'8' ''>?435@A)"3A!.%23$2+F<MF'='DC-@5'='FLF7;' B'
  125. 125. 11 Processamento XML com DOM !  Leitura do documento (pode usar SAX) !  Passo 1: carregar o documento e identificar os tokens !  Passo 2: identificar elementos e outros nós !  Passo 3: montar a árvore (pode ser feito durante passo 2) !  Alteração (com a árvore na memória) !  Localiza o nó de referência !  Remove, altera, muda posição, cria nó antes ou depois. !  Criação !  Cria raiz; cria elemento raiz; cria elementos filho e atributos; cria nós de texto !  Monta árvore ! coloca atributos em elementos, nós de texto em elementos, elementos filho em elementos pai, elemento raiz na raiz
  126. 126. 12 W3C DOM (padrão): tipos de dados !  Coleções: NodeList, NamedNodeMap !  Raiz da hierarquia de nós: Node !  Subclasses de Node !  Attr (atributo) !  CharacterData (classe abstrata) !  Text (nó de texto) !  CDATASection (seção CDATA) !  Comment (comentário) !  Document (documento inteiro) !  DocumentFragment (sub-árvore) !  DocumentType <!DOCTYPE> !  Element (elemento) !  Entity (valor da entidade - conteúdo) !  EntityReference (nome da variável) !  Notation (valor de uma notação) !  ProcessingInstruction (instrução de processamento)
  127. 127. 13 W3C DOM: Hierarquia DocumentFragment Document CharacterData Text Comment CDATASection Attr Element DocumentType Notation Entity EntityReference ProcessingInstruction Node NodeList NamedNodeMap
  128. 128. 14 W3C DOM: tipos de nó !  DOM usa constantes para identificar tipos de nó (nodeType) Constante* (opcional) Tipo valor !  !"!#!$%&$'(!) ) ) ) ) )!*+,+-. ) ) ) ) )/) !  0%%1234%!&$'(! ) ) ) ) )0..5 ) ) ) ) ) )6) !  %!7%&$'(!) ) ) ) ) ) )%+8. ) ) ) ) ) )9) !  :(0%0&;!:%2'$&$'(! ) ) ) ):(0%0;+<.=>-) ) ) )?) !  !$%2%@&1!A!1!$:!&$'(! ) ) )!-.=.B1+C+5+-<+) ) )D) !  !$%2%@&$'(! ) ) ) ) ) )!-.=.B) ) ) ) ) )E) !  F1':!;;2$G&2$;%14:%2'$&$'(! )F5><+HH=-I2-H.5J<.=>- )K) !  :'##!$%&$'(!) ) ) ) ) ):>,,+-. ) ) ) ) )L) !  (':4#!$%&$'(!) ) ) ) ) )(><J,+-. ) ) ) ) )M) !  (':4#!$%&%@F!&$'(! ) ) ) )(><J,+-.%BN+) ) ) )/O) !  (':4#!$%&A10G#!$%&$'(!) ) )(><J,+-.A5PI,+-.) ) )//) !  $'%0%2'$&$'(!) ) ) ) ) )$>.P.=>- ) ) ) ) )/6) * Nomes das constantes às vezes variam, conforme a implementação
  129. 129. 15 Alguns métodos da interface Node !  Node appendChild(Node) !  Node cloneNode(boolean) !  NamedNodeMap getAttributes() attributes !  NodeList getChildNodes() childNodes !  boolean hasAttributes() !  boolean hasChildNodes() !  Node insertBefore(Node, Node) !  Node removeChild(Node) !  Node replaceChild(Node, Node) !  Node getFirstChild() firstChild !  Node getLastChild() lastChild !  Node getNextSibling() nextSibling !  Node getPreviousSibling() previousSibling !  String getNodeName() nodeName !  short getNodeType() nodeType !  String getNodeValue() nodeValue !  Document getOwnerDocument() ownerDocument !  Node getParentNode() parentNode atalhos!
  130. 130. 16 Métodos para listas e mapas !  NamedNodeMap !  Node item(int) !  Node getNamedItem(String) !  Node nextNode() !  void reset() !  int getLength() length !  NodeList !  Node item(int) !  Node nextNode() !  void reset() !  int getLength() length
  131. 131. 17 Interface Element !  String getAttribute(String) !  String getAttributeNS(String, String) !  Attr getAttributeNode(String) !  Attr getAttributeNodeNS(String, String) !  NodeList getElementsByTagName(String) !  NodeList getElementsByTagNameNS(String, String) !  String getTagName() tagName !  boolean hasAttribute(String) !  boolean hasAttributeNS(String, String) !  void removeAttribute(String) !  void removeAttributeNS(String, String) !  void setAttribute(String, String) !  void setAttributeNS(String, String, String)
  132. 132. 18 Interfaces Attr e Text !  Attr !  String getName() name !  Element getOwnerElement() ownerElement !  String getValue() value !  void setValue(String) !  Text e CharacterData !  void appendData(String) !  String getData() data !  int getLength() length !  void insertData(int, String) !  void replaceData(int, int, String) !  void setData(String)
  133. 133. 19 W3C DOM 2.0 com namespaces !  Use métodos que levam em conta o namespace !  É necessário para acessar elementos e atributos que usam namespaces (ex: xlink) !  É necessário quando se usa XML com namespaces (ex: quando usado junto com SVG, XHTML, XSL-FO, etc.) !  Em vez de getAttribute, getElement, etc. !  Use getAttributeNS, getElementNS, etc. !  Exemplo usando Java !"#$%&'()&*!'+',-""./0011121324#&056660()&,7' !"#$%&'89$%:*!'+',-""./0011121324#&0;<<<089$%:,7' *4=>'?$#?9>'+'=4?2?#>@">A9>B>%"*!C()&*!D,?$#?9>,E7' ?$#?9>2(>"F""#$GH">*!C%H99D,?8,DI66E7' ?$#?9>2(>"F""#$GH">*!C%H99D,?J,DI66E7' ?$#?9>2(>"F""#$GH">*!C89$%:*!D',-#>K,D',-""./001112@0?4B,E7'
  134. 134. 20 Interface Document !  Attr createAttribute(String) !  Attr createAttributeNS(String, String) !  Element createElement(String) !  Element createElementNS(String, String) !  Text createTextNode(String) !  DocumentType getDocType() docType !  Element getDocumentElement() documentElement !  Element getDocumentById(String) !  NodeList getElementsByTagName(String) !  NodeList getElementsByTagNameNS(String, String) 20
  135. 135. 21 Exemplo criação de árvore !  Usando interfaces do W3C DOM padrão !  Atributos !" #$%&'()*" +%,-*,." /0('()*" +'()1,2('." /0('()*" 3$'"45,6" 7*-5)2" texto := document.createTextNode("Bom dia!") mens := document.createElement("mensagem") carta := document.createElement("carta") Obter objeto do tipo Document (depende de processador): document +%,-*,"5489:9." carta.setAttribute("id", "1")
  136. 136. 22 DOM: montagem da árvore !  Usando interface DOM padrão !  1. Sub-árvore <mensagem> !  2. Sub-árvore <carta> !  3. Árvore completa !" #$%&'()%$*" +,$"-.(/" mens.appendChild(texto) carta.appendChild(mens) document.appendChild(carta) +,$"-.(/" #0(12(".-3454*" #$%&'()%$*" +,$"-.(/" #0(12(".-3454*" #$%&'()%$*"
  137. 137. 23 Como obter o document !  Para usar DOM é preciso obter uma referência a um elemento do tipo Document !  Em C#, use classes do System.XML !  Em Java, inicialize um processador (pacote javax.xml e objeto DocumentBuilder) e use a API DOM em org.w3c.dom !  Em PHP 5, crie um DomDocument !  Em aplicações XML que rodam no browser (XHTML, SVG) há um objeto pre-definido document !  Em browsers HTML, o objeto document pode ser usado em scripts (ex: document.getElementById('nome')) !  Nas implementações de visualizadores SVG o objeto default também se chama document
  138. 138. 24 Obtenção do Document em Java !  Use os pacotes javax.xml.parsers.* e org.w3c.dom.* !  Para obter um Document !  Crie um javax.xml.parsers.DocumentBuilder !"#$%&'()*%+,-'./0$)#.1!20$)#.1!3!!!!!! !!!!!!!!!!!!!!!!"#$%&'()*%+,-'./0$)#.14('56(7)0($'89:!! !"#$%&'()*%+,-'.!!"#$%&'(3!20$)#.14('5"#$%&'()*%+,-'.89:! !  Chame builder.newDocument() para obter um elemento raiz de um documento vazio (org.w3c.dom.Document) !"#$%&'()!%)*"+&,-!3!;%+,-'.4('5"#$%&'()89:! !  Ou chame builder.parse("documento.xml") para obter o elemento raiz de um documento XML existente !"#$%&'()!%)*"+&,-(3!;%+,-'.4<0.7'8=-#$%&'()#4>&,=9:!! !  Exemplo de uso de DOM com Java !  ?,'&'()!','&'()#!3!%)*"+&,-4@')?,'&'()*16-8=7'$0#=9:! !  ','&'()#40<<'(-AB+,-8%)*"+&,-4$.'0)'?,'&'()8=<=99:!
  139. 139. 25 Java: gravação em XML !  Uma vez criada a árvore DOM, ela pode ser serializada para XML (arquivo de texto) !  Solução padrão é usar XSLT (javax.transform) !  javax.xml.transform.* !  javax.xml.transform.dom.DOMSource; !  javax.xml.transform.stream.StreamResult; !  O trecho abaixo imprime o documento XML contido em document na saída padrão (System.out) TransformerFactory tFactory = TransformerFactory.newInstance(); ! Transformer transformer = tFactory.newTransformer(); !! DOMSource source = new DOMSource(document); !! StreamResult result = new StreamResult(System.out); !! transformer.transform(source, result);
  140. 140. 26 Exemplo de DOM com .NET (C#) !  Use a biblioteca System.XML !"#$%&'(")*+,-./0& !  Para criar um Document vazio (e obter a referência para o seu elemento raiz): -+1234!+*$)&!"#$%&'()5&$*6&-+1234!+*$)780& !  Para processar um documento existente -+1234!+*$)&!"#$%&'()5&$*6&-+1234!+*$)780& 934!+*$),13:9-+17;<=*""3:><$3+*>,,,<?=*""3:>;80& !  Exemplo de uso de DOM com C# @1*+*$)&*1*+*$)3&5&!"#$%&'(,%*)@1*+*$)A(B97;"*4:3;80& *1*+*$)3,:==*$9CD#197!"#$%&'(,4E*:)*@1*+*$)7;=;880& !  Para gravar em texto em arquivo 934!+*$),':F*7;4GHHE*"!1):93,I+1;80&
  141. 141. 27 Exemplo de DOM em PHP 5 !  Para obter o Document de uma árvore nova: $document = new DomDocument; !  Para processar um documento XML existente e obter seu Document: $document = new DomDocument; $document->load('arquivo.xml'); !  Exemplo de uso de DOM em PHP $elemento = $document.getElementById("secao"); $elemento->appendChild($document->createElement("p")); !  Para gravar a árvore novamente em XML (imprimindo na saída padrão) !  print $document->saveXML();
  142. 142. 28 Exemplo em Objective-C (Mac OS) !  Para criar um Document novo !"#$%&'()(*+,-./01,2,, 3!"#$%&'()(*+,-45!"#$%!67(,('()(*+80+9!/)(:;<=(>>6/<?@, !"#$%A6BC)(*+,!"#$%&'()2,, 55!"#$%A6BC)(*+,/''6B?,0*0+80+9D66+&'()(*+:./01?@, !  Para obter o Document de um documento existente !"ED%,-FC.',2,5!"ED%,F0'(ED%80+9G/+9:;</.HC0I6JK)'<?@, !"#$%A6BC)(*+,!"#$%&'()*2,55!"#$%A6BC)(*+,/''6B?,,, ,,,,,0*0+80+9L6*+(*+>MFED%:FC.',, ,,,,,,,,,,,,,,,,,,,6=+06*>:!"#$%!67(G.(>(.I(890+(>=/B(,,,,,,,,,,,,, ,,,,,,,,,,,,,,,,,,,,,(..6.:N(..?@, !  Exemplo de uso (não usa interfaces DOM padrão) !"#$%&'()(*+,-('()(*+6,2,3!"#$%&'()(*+,-4,55"#$%&'(), *67(>O6.#G/+9:;<-5;072P>(B/6P?<,(..6.:,N(..4,6QR(B+S+T*7(K:U?@, 5('()(*+6,/77L90'7:5!"#$%&'()(*+,('()(*+80+9!/)(:;<=<??@ !  Gravação de XML !"A/+/,-K)'A/+/,2,5"#$%&'()* #$%A/+/80+9M=+06*>:!"#$%!67(G.(++VG.0*+?@,,,,, 5K)'A/+/,W.0+(X6O0'(:;<.(>C'+/76JK)'<,/+6)0B/''V:Y&"?4@,,
  143. 143. 29 DOM padrão: usar o não usar !  Em linguagens de script, que rodam no browser, use sempre DOM padrão W3C !  Usar soluções proprietárias em aplicações que rodam no cliente não é recomendado !  Em aplicações no servidor ou standalone, escolha a solução mais adequada à sua aplicação !  Use as soluções nativas se existirem !  Escolha entre soluções de acordo com recursos desejados, eficiência, etc (ex: várias APIs DOM diferentes para Mac OS e iPhone) !  Java oferece APIs mais fáceis de usar que são alternativas ao DOM padrão com JDOM e DOM4J
  144. 144. 1 XML: uma introdução prática X100 Helder da Rocha (helder@argonavis.com.br) Atualizado em setembro de 2001
  145. 145. 2 Apresentação do XML !! Por que apresentar os dados? !! Impressão !! Web !! Verificação !! Edição !! Soluções !! Cascading Style Sheets (CSS) !! Document Style Semantics and Specification Language (DSSSL) !! eXtensible Stylesheet Language Transformations (XSLT): transforma em qualquer coisa: PDF, SVG, XSL-FO, etc.
  146. 146. 3 O que é uma folha de estilos? !! Conjunto de regras para formatar !! um documento !! vários documentos !! Comum em !! processadores de texto (Word: .DOT) !! DTP (Framemaker: .FOS, Ventura Pub: .STY) !! Separa estrutura e conteúdo da apresentação !! portabilidade maior !! maior facilidade para gerar visões diferentes dos dados !! facilita manutenção e promove reutilização !! Veja exemplos (HTML + CSS)
  147. 147. 4 CSS e XSL !! Principais linguagens de folhas de estilo disponíveis para XML !! CSS !! utiliza a estrutura existente do documento !! regras informam ao browser como ele deve formatar cada elemento da árvore !! interpretada em tempo de execução (não pode guardar o resultado da transformação) !! XSL (XSLT + XSL-FO) !! altera a estrutura do documento (transforma) !! regras informam ao processador elementos e atributos que devem ser substituídos !! formatação estilo-CSS via especificação XSL-FO !! interpretada em tempo de execução ou previamente (pode guardar o resultado da transformação)
  148. 148. 5 Por que usar CSS? !! Em HTML !! Alterar a forma original determinada pelo estilo do browser !! Separar conteúdo da forma de apresentação !! Simplificar a manutenção de um grande site !! Ter grande controle sobre cores, fontes, layout !! Tornar as páginas mais leves e o site mais rápido !! Em XML !! Dar forma a elementos que não têm forma predefinida !! Solução para a Web (browsers que suportam XML e CSS) !! Suporte: depende do visualizador (nem tudo que funciona para HTML em um browser funciona para XML) !! Aplicações como SVG e XHTML definem em especificação suporte formal a recursos do CSS (suporte é parcial em SVG)
  149. 149. 6 Como usar CSS !! Em XML (inclusive XHTML) !! Folha de estilos externa !"#$%&'()*&+(,++)!)*-+./)+$)01((/!,2+3./45161((/!#7! !! Em HTML (e também XHTML) !! Folha de estilos externa (use dentro de ",+487) "&9:;!2+&./()*&+(,++)/!)*-+./)+$)01((/!! !!!!!!!!!!!!!!!!!!!!!!!,2+3./45161((/7! !! Folha de estilos embutida (use dentro de ",+487) !"()*&+7!! ! !-!<1=&=2>!2+8?!3=:)'(9@+>!AB-)C!! !"0()*&+7! !! CSS aplicado em elementos individuais !"-!()*&+./1=&=2>!2+8?!3=:)'(9@+>!AB-)/7)+$)="0-7!
  150. 150. 7 CSS essencial: regras !! Uma folha de estilo CSS é um conjunto de regras. Cada regra tem a forma !"#$#%&'()!***)!"#$#%&'+!,!-'&-'.#/0/#1!20$&'3! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!***3!! !!!!!!!!!!!!!!!!!!!!!!!!!!!-'&-'.#/0/#1!20$&'!! !!!!!!!!!!!!!!!!!!!!!!!!4! !! Alem das regras, uma folha de estilos CSS pode ter !! Comentários: !56!"#$#%&'!.7+&'0/&!,8&+%1!(9-%4!!65! !! Instruções: !:.;-&'%! !:;#/.0! !:-07#! !:8&+%<80=#! !:=>0'"#%! !:+&;#!
  151. 151. 8 Seletores !! Identifica um ou mais elementos !! Um elemento identificado por ID (xml:id ou id definido pel DTD da aplicação SVG, XHTML, XSL-FO, HTML, etc.) !! Um ou mais elementos determinados por !!nome do elemento !!atributos que contém !!valores dos atributos !!padrões encontrados nos valores dos atributos (predicados) !!contexto hierárquico !!contexto de posição no documento !!modificador (pseudo-classe) !!atributo de classe (vale para SVG, HTML e XHTML) !! Exemplo de seletores !"#$!"#$#$%&!'()*#$+,-&%./*&0'1234567-4*$89:';('<$0:.+;=$
  152. 152. 9 Seletores elementares !! Os seletores mais simples são nomes de elementos !! Definem estilo para todos os elementos identificados com o mesmo nome !"#"$%&!'(&%&)*!+%$,-!! !!!!!!!!.&/"01#2,*!345"-6! !5!'!",7"0#/8,/"*!9:;,<!=#<5&)">/"!6!! "8?!%#?!$%!'!.&/"*!935"!1>/101,)#.6!! ">+%,!'!.&/"01#2,*!3@5"!6!! !A!'.&/"01#2,*!3B5"6!CA!1,%,"&)!$/#D,)1>%AC! !! Estilo aplicado é herdado pelos elementos filho
  153. 153. 10 Resolução de conflitos !! Ao importar folhas de estilo, definir novas regras, pode haver conflitos de precedência !! Regras básicas !! Estilos mais específicos predominam: ser mais específico é mais importante que chegar depois !! Propriedades não sobrepostas são herdadas !! Elementos filho herdam propriedades dos pais !!exceto quando filhos definem suas propriedades (mesmo que antes das dos pais): vale a regra do 'mais específico' !! Regra aplicada via * (seletor universal) é considerada mais específica que uma regra herdada pela estrutura !! O seletor mais específico de todos é o ID
  154. 154. 11 Predicados !! Usam valor do atributo para identificar elemento !! Exemplos !! !"#$!%&'"" " " " " " " " "()*+*,-",&./" !! !"#$!%&"0"12$2)2*3.!34!52$!1'" "()*+*,-",&./" !! !"#$!%&"60"14!52$!1'" " " " "()*+*,-",&./" !! !"#$!%&"70"12$2)2*31'""" " " "()*+*,-",&./" !! !"#$!%&'#8,&9601%&:;2<&=)*%1'"" "()*+*,-",&./" !! Podem ser aplicados no eletor universal !! Exemplo: todos os elementos que tenham atributo name com valor "coisa" >#$!%&"0"1)*2;!1'""
  155. 155. 12 IDs !! Atributos especificados na DTD, ou no esquema, ou por xml:id, como sendo do tipo ID !! Podem ser referenciados diretamente usando o identificador do elemento no documento !! Sintaxe !! !"!#!$%&'()!$%(*(+,)&-.. !! '()!$%(*(+,)&- (recomendada) !! Exemplo: !! /)(0.()12*-!)23.444./5)(03. !! '*-!).6+&"&-7.8-!!$9..
  156. 156. 13 Seleção por contexto hierárquico !! Dois ou mais nomes correspondem a um seletor !! Relação ancestral-descendente !! !"#$%&'!()*$%#$"*$"&$)+#,(,'-)'$*.) !! &!/($)&*0)1()/)+#,(,'-2$((,3.) !! /,*2)4)567)+/,'*$'835*&9-):4;.) !! Descendência direta, do tipo pai-filho !! $($6$"&,<4!5)=)$($6$"&,<>5(9,)+#,(,'-)'$*.) !! &!/($)=)&')=)&*)+#,(,'-)/(1$.) !! Outra forma (há pelo menos um elemento entre ancestral e descendente): !! !"#$%&'!()?)*$%#$"*$"&$)+#,(,'-)7'!2.)
  157. 157. 14 Seleção por contexto de posição !! Pode-se selecionar um elemento com base no seu vizinho anterior usando-se o símbolo “+”. !! O elemento vizinho anterior (preceding-sibling) é um elemento irmão !! Exemplo: !! !"#$%&'()*+),-.-$!'$/$0"-12"3"/4-536$7- !! seleciona o elemento 8$!'$/$2"9-que está no mesmo nível de 8!"#$-&'()*+)9-e imediatamente após o mesmo.
  158. 158. 15 Pseudo-classes !! Pseudo-classes permitem selecionar elementos marginais e acrescentar texto antes ou depois de um elemento. !! Uma pseudo-classe liga-se ao nome de um elemento através de “:” !! !"#$%"&!'()%*+,-(.*."#,/"0012,, 34,5$0!5,6"%70%".,8!+9,43, !! 6#:0$."0,-(.1!01!#,;8+%<,(*5&&=>65"5/"5$.>9;2, 6#5$!0",-(.1!01!#,;83+%<9;2, !! 5&&?1!.#$%"&!'()%*+#:0$."0,, ,,,,,,,,-(.1!01!#,;@&&?1!.&#,;A,$.1!#,:.*+2, !! Em HTML, pseudo-classes alteram elemento <a> !! 5#<%&%!0+B,5#*%1CB,5#5(!%<0B,5#).<0",,
  159. 159. 16 Classes !! Classes permitem agrupar vários elementos !! Depende de suporte formal por parte da aplicação XML: requer a definição de um atributo class (logo não funcionam com qualquer XML) !! São suportadas por XHTML (e HTML) e SVG !! Exemplo usando classes em XHTML: !! Para dar a cada parágrafo de um mesmo personagem (mesma classe) os mesmos atributos de estilo, usa-se: !"#!"#$$%&'#()*&$%&#'()*'+#+#,&(#-*..(/#0+1+!2"$## !"#!"#$$%&+),"-&$3()*'45-+#+&#51+#'()*'45-+/#+#64)+#7# ,&(#+#8489+''+#(5)(''+&:.(#(;#<4)*;!2"$## !"#!"#$$%&.,$'-&$=;#8489+''+>#%5)(''4-+#(;#<4)*;>#!2"$## !"#!"#$$%&'#()*&$%5)(''4-+#<4)*5-+/#?(59+'#@*."+/#A&/# 4&/#4&/#51+#.4B(>#!2"$## #/+),"-0C#8+<+'D#;4'++5#E## #/'#()*0C#8+<+'D#B<48F#E## #/.,$'-0C#8+<+'D#54GH#E#
  160. 160. 17 @import !! Importa outra folha de estilos !! Implementa a cascata !! Regras podem ser herdadas ou sobrepostas !! Regras mais específicas persistem !!Exemplo: !"#$%&!'&()*(#!+'&!+"#$%&, !!Aplicar estilo em "#$%: ,"#$%,-.#/#01,0)$2 afeta ' somente se ' já não tiver estilo definido !! Exemplo !! 345'#0(,6)7(4/#8.779:, !! 345'#0(,6;(('1++<<<8)7(4/#78#0=+)7(4/#8.779:,
  161. 161. 18 @font-face !! Descreve uma fonte para uso na página !! !"#$%&"'()*!"" """"#$%&'#()*+,-"./0(1&21.3"" """"415-"61+7.0&&8-994*&29#$%&4950(1&21.:" ";"" !"#$%&"'()*!"" """#$%&'#()*+,-".<=*44">?@.3"" """415-"61+74=*44>?@A8#1:3"9B"<=*44">?@"B9"" ;"" !! " &*&6+$""""!"#$%&'#()*+,-".<=*44">?@.C"4(%4'421*#";"" 8(1(D1(#$"!"#$%&'#()*+,-"./0(1&21.C"421*#";""
  162. 162. 19 @page e @media !! !"#$% controla a aparência de mídia paginada !! !&%'(#)define estilos diferentes para mídias diferentes !! Opções: all, aural, braille, embossed, handheld, print, projection, screen, tty, tv !"#$%&!'!()*&+!,-.)/!00)/1!! !!!!!!!!2$3%)/+!0)/!4!! !"#$%&!'!()*&+!50622!578221!! !!!!!!!!2$3%)/+!5-.92!4!! !"2&:)$!;$/:;&<:!'! !!!"#$%&!'! !!!!!!()*&+!056#=!056#=1! !!!!!!2$3%)/+!.#=1! !!!4! !!!#!'>?/@A()*&+!,#@14! 4!
  163. 163. 20 Propriedades de estilo !! Atributos que alteram a aparência dos dados, e que são aplicados aos seletores !! Sempre dependem de suporte da aplicação XML e do processador !! Aplicar propriedades CSS em um XML genérico qualquer poderá funcionar em um browser que saiba como aplicá-las !! Aplicar propriedades em um XML que especifica formalmente suporte a CSS deve funcionar em um visualizador compatível !! Sintaxe de declarações !! Quando usadas dentro de folhas de estilos !"#$%&'()*#+,' !! Quando usadas em atributos -./*% de aplicações XML que o suportam (XHTML, SVG, etc.) 0%*%$%".#'-./*%12"#$%&'()*#+23' !! Valores válidos dependem de suporte da aplicação !! Para browsers, aplicações XHTML e SVG, valores válidos incluem nomes, unidades, porcentagens, cores, URIs, etc.
  164. 164. 21 Propriedades de classificação !! display !! muda o papel do elemento !! bloco, tabela, lista, inline, invisível !! essencial para formatar XML genérico em um browser, pois elementos não têm estrutura default !! white-space !! definem a forma de tratamento de espaços !! list-style-* !! marcadores, números, etc. !! estilos para listas de tópicos !! content !! substitui seletor por outro conteúdo
  165. 165. 22 Fontes !! font-* !! Alteram propriedades relativas a fontes !! font-family !! família (tipo) !! font-size !! tamanho, em várias unidades: !"#$%&#$'(#$!)#$*&#$*)#$!%$ !! font-weight !! peso: +,-.#$-'/0"#$122#$322#$444$#$522$ !! font-style !! estilo de grifo: '"6-'%#$,+-'78*$ !! font-variant !! variação9$:&6--;%6!:$ !! font-stretch !! expande ou condensa a fonta !! font !! atalho para especificar várias propriedades de uma vez
  166. 166. 23 Atributos de texto !! text-transform !! !"#$%"&$'()*+##(,!"-()*&./(,!"-(* !! text-decoration !! +01(,&$0()*.2(,&$0()*3&$04)*&$0(5%6,.+76* !! text-align !! &(8%)*,$76%)*9+-%$8:)*!(0%(,* !! vertical-align !! 3"-(&$0()*%.#)*%(;%5%.#)*<$11&()*3.%%.<)*%(;%53.%%.<* !! -+3)*-+#(,* !! #.,!(0%"7(<* !! text-indent !! valor ou porcentagem para endentar primeira linha* !! line-height !! leading (valor ou porcentagem) !! letter-spacing e word-spacing !! valor
  167. 167. 24 Cores !! Unidades !! !"#$%&&'%&&'%&&() !! !"#$*++,'*++,'*++,() !! -!!""##) !! ./0123124/!) !! color !! cor do texto !! background-color !! cor do fundo (para qualquer elemento) !! default:)5!6.786!1.5) !! CSS 2 suporta também RGBA (transparência) !! SVG usa fill e stroke para preenchimento de objetos e traços, em vez de color
  168. 168. 25 Background !! background-image !! !"#$%&'()&*+ !! !"#$,--./001112%&'()3425"(0%&'()&2(%6*+ !! background-repeat !! Como tratar a imagem de fundo !! ").)'-7+").)'-897+").)'-8:7+358").)'-+ !! packground-position !! Posicionamento da imagem de fundo !! ;'<=("5!3>8.54%-%53/+.54?,+.54?@+ !! .54?,/+@'#5"7+A+5!+#)6-7+<)3-)"7+"%(,-+ !! .54?@/+@'#5"7+A+5!+-5.7+<)3-)"7+;5--5&+ !! background-attachment !! 6%9)> - preso à janela !! 4<"5## - preso à página !! background (atalho)
  169. 169. 1 XML: uma introdução prática X100 Helder da Rocha (helder@argonavis.com.br) Atualizado em setembro de 2001
  170. 170. 2 XLink !! Coleção de atributos, do namespace http:// www.w3.org/1999/xlink usado para oferecer recursos de hipertexto a documentos XML !! Tipos de links disponíveis !! links simples (como os que já existem em HTML) !! links estendidos com capacidade de !!apontar para vários destinos ao mesmo tempo !!ser destino e fonte ao mesmo tempo !!ser vértice de um grafo e controlar toda uma teia de navegação !! Combinado com XPointer e XPath pode apontar para partes de um documento ou até caracteres individuais.
  171. 171. 3 XPointer !! Função e sintaxe para apontar para pedaços de um documentos XML !! XPointer usa a linguagem XPath para representar elementos e conjuntos de elementos. !! Possui funções para navegar no interior dos elementos e apontar para caracteres individuais de texto !! Pode selecionar uma faixa de valores, com base nas coordenadas individuais !! Pode ser ou não destino de um XLink !! Aplicações não só na Web !! também em interfaces de processamento de texto!
  172. 172. 4 XLink é coleção de atributos !! Namespace: !! http://www.w3.org/1999/xlink !! Atributos: !! !"#$%=!"#$%&'!(!')*'+,',!(!&-./*-0!(!! !!!!!!!!!!/0.!(!*#*&'!(!0'"-10.'! !! &'$(%=!a URI destino do vínculo !! )&*+%=!+'2!(!0'%&/.'!(!'$3',!(!-*4'0!(!+-+'! !! ,-!.,!$%=!-+5-/,!(!-+6'71'"*!(!-*4'0!(!+-+'! !! !/!0$ = descrição detalhada !! '*0$ = papel / contexto do vínculo !! 0,1$0 = descrição sucinta (para exibição) !! Exemplo de uso típico !! !8'&'$'+*-!20/345&'$(9:4**%;<<&1=/0>.-$:!<?!
  173. 173. 5 Exemplos de link "tipo <a href>" e "<img>" !"#$%&'()$&*'+,-.//")001112132456078880$&*'+-## #$&*'+)/9":,-(*%"&:-## #$&*'+).5:;,-<:'=-## #$&*'+)(.41,-5:"&>?:-## #$&*'+)>?/@>/:,-4'A:B@:(/-C&*'+!0"C## !*%6#$%&'()$&*'+,-.//")001112132456078880$&*'+-## #$&*'+)/9":,-(*%"&:-## #$&*'+).5:;,-7D3EF2G"6-## #$&*'+)(.41,-:%H:=-## #$&*'+)>?/@>/:,-!"#!$%-0C## ... quando o documento for carregado. Conteúdo será substituído... ...quando o usuário solicitar. Conteúdo será embutido no documento...

×