CEFETES Unidade da Serra Coordenadoria de Informática Prof. Mateus Barcellos Costa Notas de Aula XML Última Atualização: 2008-1 Criando documentos XML Introdução <?xml version='1.0' encoding='utf-8'?> A definição acima denomina-se declaração do documento e deve ser o primeiro elemento de um documento XML. No exemplo, a declaração está dizendo que: documento é compatível com a versão 1.0 de XML O documento utiliza o padrão de codificação de caracteres utf de 8 bits. Este padrão não codifica acentos e c cidilha. Se quisermos usar um padrão de codificação que aceite acento podemos usar o padrão ISO-8859-1. Comentário em XML são elementos que devem ser ignorados pelo parser a ser utilizado. O texto que segue é um comentário. <!--COMENTÁRIOS --> Depois da declaração, um documento XML define exatamente 1 elemento denominado elemento raiz (root element). Qualquer outro elemento dentro do documento deverá estar contido dentro do elemento raiz. A definição do elemento raiz e de qualquer outro elemento será feita definindo-se uma tag. Por exemplo, o elemento slideshow que a seguir será o nosso elemento raiz. <slideshow> </slideshow> Todo elemento deve ser terminado por sua tag de fim. Note que XML é sensível ao caso. Assim a tag final deve ser exatamente como a inicial. Introduzindo Atributos a um Elemento A apresentação de slides possui uma série de itens de dados. Como nenhum destes itens requer estrutura, é natural definí-los como atributos do elemento slideshow. Para definir estes atributos podemos fazer como segue: <slideshow title="apresentação de Slides" date="data da publicação" author=" Nome do autor" >
</slideshow> Quando criamos uma tag ou um atributo podemos usar os caracteres menos (-) underline ( _ ), dois pontos (:) ou ponto (.), além de números e letras Valores para os atributos são sempre colocados entre aspas. Conjuntos de atributos nunca são separados por vírgula ",". Adicionando Elementos aninhados XML permite dados hierarquicamente estruturados. Isso significa que um elemento pode conter outros elementos. No exemplo abaixo adicionamos um elemento slide que contem um outro elemento denominado title. No elemento slide foi também definido o atributo type. O significado deste atributo é ressaltar o tipo de audiência do slide. <slideshow title="exemplo Apresentação de Slides" date="data da publicação" author=" Nome do autor" > <slide type="all"> <title>acordem para as grandes Novidades!</title> </slide> </slideshow> A diferença entre coisas que serão elementos (ex. title) e coisas que serão atributos (ex. type) é um importante aspecto deste ponto. Não existe uma regra exata para isso. Portando deve-se aplicar certas heurísticas. Destacamos aqui duas: A primeira heurística aqui é a questão da visibilidade. O título será uma coisa vista pela audiência. então ele será um elemento. O tipo, por outro lado, é algo que nunca estará presente. Logo, ele é um atributo. Outra forma de se pensar a respeito de atributos e elementos filhos de um elemento pai é imaginar que o elemento pai é um recipiente. O tipo do recipiente é um atributo do recipiente como, por exemplo, garrafa, caixa ou lata. Logo ele será o atributo do elemento pai. Já o título descreveria o conteúdo do recipiente, por exemplo, leite, cerveja ou chocolate. Logo ele não é um atributo do recipiente sendo representado neste caso como um elemento. Conforme citamos, não existe uma regra exata para esta escolha. Adicionando texto HTML XML permite definir qualquer tipo de TAG. Logo, faz sentido definirmos um conjunto de Tags semelhantes às tags HTML. O Padrão XHTML faz exatamente isto.
<slide type="all"> <title>visão Geral</title> <item>por que <em>novidades</em> são boas</item> </item> <item>quem <em>compra</em> Novidades</item> </slide> A definição acima especifica um slide usando a tag html <em></em> que enfatiza o texto entre elas (colocando em itálico). Adicionando Elementos Vazios Documentos XML devem ser obrigatoriamente bem-formados (well formed). Isso significa que: Toda tag deve possuir uma tag de fim ou ser uma tag vazia. Um elemento vazio é pode ser definido com o nome da tag terminando com a /. Por exemplo <item/> define um elemento item vazio. Um documento XML bem formado também precisa respeitar os aninhamentos. Por exemplo, <b><i> texto</i></b> é bem formada, ao passo que <b><i>texto</b></i> não é. Finalizando, o documento completo em XML para a apresentação de Slides pode ser visto abaixo <?xml version='1.0' encoding='utf-8'?> <slideshow title="exemplo de Apresentacao de Slides" date="data da publicacao" author=" Nome do autor" > <! Titulo do SLIDE --> <slide type="all"> <title>acordem para as Novidades!</title> </slide> <! Visao geral--> <slide type="all"> <title>visao Geral</title> <item>por que <em>novidades</em> sao boas</item> <item/> <item>quem <em>compra</em> Novidades</item> </slide> </slideshow>
Visão geral dos padrões e APIS para processamento de Documentos XML. Uma API (Interface de programa de aplicação Application Program Interface), fornece uma série de elementos de programação que permitem realizar uma atividade específica como, por exemplo processar arquivos XML, comunicar-se usando sockets ou acessar um banco de dados. As APIs para processamento de XML obedecem a certos padrões definidos, principalmente pela W3C World Wide Web Consortium. As APIs para acesso a documento podem ser: Em modo serial (SAX) Em modo aleatório (DOM) Antes de estudarmos estas APIS vamos ver brevemente alguns dos principais padrões de XML e tentar digerir esta verdadeira sopa de letras. Padrões básicos SAX Simple API for XML Este padrão materializa o protocolo de acesso serial a documento XML. SAX é a maneira mais rápida de se ler e escrever documento XML. SAX pode ser visto como um protocolo orientado a eventos. Isso porque, usando SAX, o manipulador de arquivos se associa a um parser SAX, que responde a ocorrência de eventos (tags, erros, etc) na leitura do documento ativando os métodos apropriados. DOM Document Object Model O Modelo de objetos para documentos (DOM) é um protocolo que converte documento XML em objetos de um programa. Após isto, os objetos podem ser manipulados como qualquer outro objeto do programa. O mecanismos do DOM é chamado de protocolo de acesso aleatório porque qualquer parte do documento pode ser visitada em qualquer tempo. Esta visita implica que com o DOM é possível modificar, remover ou adicionar dados ao documento. DTD Document Type Definiton DTD é uma parte da especificação de XML, sendo entretanto opcional. Um DTD especifica o conjunto de tags que podem ocorrer em um documento e os arranjos válidos destas tags. Um DTD portanto pode ser usado para verificar se um documento XML não está sendo escrito incorretamente. Pode também ser usado para verificar se a estrutura de um documento XML que está sendo lida é válida ou não. Um DTD pode ser explicitado no início do documento XML como parte do prólogo do documento ou ser uma entidade separada. Namespaces Namespaces permitem a construção de documentos XML utilizando um ou mais conjuntos de tags de forma modular. A principal função de um namespace é qualifica os nomes de forma a eliminar possíveis ambigüidades.
XSL - Extensible StyleSheet Language O Padrão XML especifica como identificar dados e não com apresentá-los. HTMl por outro lado permite definir como os dados são apresentados mas não o que são estes dados. XSL por sua vez possui as duas partes: XSTL - Padrão de transformação XSL-FO A parte que define objetos de formatação (flow objects). XSL FO permite definir múltiplas área em uma pagina e ligar umas com as outras. Quando a seqüência de texto é direcionada a uma coleção destas áreas, ela preenche a primeira área e depois automaticamente flui para a segunda área quando a primeira for totalmente preenchida. XSLT Padrão de transformação XSLT é basicamente um mecanismo de permite transformar documento XML em um formato de apresentação como, por exemplo, HTML, PDF ou OS. XPATH é mecanismo de endereçamento que pode ser usado para construir as instruções de transformação Fazendo um dump do documento através de um Parser SAX. Um parser SAX é geralmente utilizado para obter os dados de um documento XML para realizar algum tipo de processamento com os mesmo. Aqui utilizaremos o parser didaticamente, para ler o documento XML e apresentar os dados que estão dentro do mesmo. O parser será definido na aplicação denominada Echo.java O esqueleto da classe e as importações necessárias são mostradas a seguir: import java.io.*; import org.xml.sax.*; import org.xml.sax.helpers.defaulthandler; import javax.xml.parsers.saxparserfactory; import javax.xml.parsers.parserconfigurationexception; import javax.xml.parsers.saxparser; public class Echo extends DefaultHandler { static private Writer out; public Echo() { public static void main(string argv[]){ if (argv.length!= 1) { System.err.println("Usage: cmd filename"); System.exit(1); try { // Set up output stream out = new OutputStreamWriter(System.out, "UTF8"); catch (Throwable t) { t.printstacktrace();
System.exit(0); Analisando a classe echo vemos: O método main foi especificado para ler o argumento de entrada (nome do arquivo a ser processado) Foi configurado o outputstream (out) onde será escrita a saída. Para utilizarmos o parser, a principal interface usada é a ContentHandler. Esta interface define uma série de operações usadas em resposta aos diversos eventos que ocorrem no parsing. A forma mais fácil de implementarmos uma interface ContentHandler é estendermos a classe DefaultHandler. Vejam no código acima que a classe Echo estende (herda) a classe DefaultHandler. A seguir adicionamos o código necessário para realizar o parser: public static void main(string argv[]){ if (argv.length!= 1) { System.err.println("Usage: cmd filename"); System.exit(1); // Use uma instancia de Echo como o SAX EventHandler DefaultHandler handler = new Echo(); // Usa o parser SAX default (sem validação) SAXParserFactory factory = SAXParserFactory.newInstance(); try { // Configura a saída out = new OutputStreamWriter(System.out, "UTF8"); // Processa a entrada SAXParser saxparser = factory.newsaxparser(); saxparser.parse( new File(argv[0]), handler ); catch (Throwable t) { t.printstacktrace(); System.exit(0); O código que segue implementa alguns métodos auxiliares para a apresentação do documento. São eles, o método emit que apresenta uma string s na saída out e o método nl que imprime uma mudança de linha em out. private void emit(string s)
throws SAXException { try { out.write(s); out.flush(); catch (IOException e) { throw new SAXException("I/O error", e); private void nl() throws SAXException { String lineend = System.getProperty("line.separator"); try { out.write(lineend); catch (IOException e) { throw new SAXException("I/O error", e); A seguir temos as implementações dos métodos startdocument, enddocument, starelement e endelement definidos na interface DefaultHandler. public void startdocument() throws SAXException { // emit("<?xml version='1.0' encoding='utf-8'?>"); nl(); public void enddocument() throws SAXException { try { nl(); out.flush(); catch (IOException e) { throw new SAXException("I/O error", e); public void startelement(string namespaceuri, String sname, // simple name (localname) String qname, // qualified name Attributes attrs) throws SAXException { String ename = sname; // element name if ("".equals(ename)) ename = qname; // namespaceaware = false emit("<"+ename); if (attrs!= null) { for (int i = 0; i < attrs.getlength(); i++) { String aname = attrs.getlocalname(i); // Attr name if ("".equals(aname)) aname = attrs.getqname(i); emit(" "); emit(aname+"=\""+attrs.getvalue(i)+"\"");
emit(">"); public void endelement(string namespaceuri, String sname, // simple name String qname // qualified name ) throws SAXException { emit("</"+sname+">"); public void characters(char buf[], int offset, int len) throws SAXException { String s = new String(buf, offset, len); emit(s); Substituindo e Inserindo Texto em documentos XML Tratando caracteres especiais Entidades Uma entidade em XML é uma estrutura ou texto que possui um nome. Referenciando-se uma entidade pelo seu nome causa a inserção da entidade no documento no local onde a referência foi feita. Para se criar um referência a uma entidade, o nome da entidade e colocado entre os caracteres & (ampersand e comercial) e ; (semicolon ponto e vírgula), como: &nomedaentidade; Entidades predefinidas: Uma referencia a uma entidade como, por exemplo, & Esta entidade se refere a um texto que irá substituir a referência no documento, como uma macro em C. Existem as seguintes entidades predefinidas para caracteres especiais: Caractere Referência & & < < > > " " ' ' Caracteres podem ser referenciados com nomes de entidades se necessário. Nestes casos o caractere ser representados pelo # seguido pelo unicode que o representa. Por exemplo, A representa a letra A. Usando referências a entidades.
Suponha que você deseja inserir o texto Tamanho do Mercado < Previsto O problema surge por que quando o parser ver o caractere < ele pensará que está sendo iniciada uma nova tag. E procurará pelo nome da tag. Para contornar este problema substituímos o < pela referência < Tratando Texto com sintaxe parecida com XML Quando partes do texto incluem muitos caracteres especiais à sintaxe XML, pode se tornar inconveniente ficar inserindo muitas referências a entidades. Para estas situações pode-se usar uma seção CDATA Em uma seção CDATA espaços em branco são considerados e nenhum caractere é interpretado como caractere especial de XML. Um seção CDATA inicia com <![CDATA[ e termina com ]]> Exemplo: <slide type="tech"> <title>how it Works</title> <item>first we fozzle the frobmorten</item> <item>then we framboze the staten</item> <item>finally, we frenzle the fuznaten</item> <item><![cdata[diagram: ]]></item> </slide> frobmorten <------------ fuznaten <3> ^ <1> <1> = fozzle V <2> = framboze Staten+ <3> = frenzle <2> No exemplo acima, o diagrama é tratado inteiramente como se fosse uma cadeia de caracteres. Definindo Data Types Conforme vimos até agora, o parser só verifica o fato do documento XML ser bemformado. Entretanto, podemos inserir regras que de verificação sintática para os documentos por meio de DTDs: Data Type Definition. DTD permitem verificar se um documento bem formado é Válido. O Documento abaixo é um DTD., que permite definir uma gramática para um documento XML. <!-- XML declaration --> <?xml version='1.0' encoding='utf-8'?> <!-- DTD for a simple "slide show". --> <!ELEMENT slideshow (slide+)>
<!ELEMENT slide (title, item*)> <!ELEMENT title (#PCDATA)> <!ELEMENT item (#PCDATA item)* > O item slide+ indica os conteúdos válidos para o elemento slideshow. Neste caso um ou mais elementos do tipo slide. Os qualificadores podem ser +,? ou * Qualificador Nome? * + Interrogação - Question Mark Asterisco - Asterisk Mais - Plus Sign Significado Opcional (zero ou um) Zero ou mais Um ou mais Pode também haver aninhamento de parênteses nos itens. Por exemplo ((title, image)+) Nas declarações acima definimos o tipo do elemento slide e os tipos que constituem este elemento: title e item A declaração de title indica que seu conteúdo é formado puramente por conjuntos de caracteres processáveis (Parsed Character Data - PCDATA). O caractere # indica que o que segue é uma palavra reservada e não um elemento. Na declaração item a " " indica a condição OU, indicando que um PCDATA ou um item podem ocorrer. Limitação Seria interessante se pudéssemos especificar se um item contem por exemplo um PCDATA ou um PCDATA seguido de um item. Sintaticamente esta expressão ficaria assim: <!ELEMENT item (#PCDATA (#PCDATA, item+)) > Infelizmente esta especificação incorre em um erro pois, assim que o parser encontrar um #PCDATA ele vai tentar encontrar um item. Isso ocorre porque ele não consegue saber se o PCDATA que encontrou é da expressão #PCDATA ou de (#PCDATA,item+) Definições duplas também não funcionam: <!ELEMENT item (#PCDATA) > <!ELEMENT item (#PCDATA, item+) > Neste caso o Parser gera um warning e a ultima declaração é ignorada.
Também não existe forma de especificar posteriormente o tipo de conteúdo esperado quando PCDATA é usado. Não é possível especificar se o dado é uma seqüência de dígitos ou um formato de data, por exemplo. Em DTDs não existe também nenhum sentido de hierarquia. Por exemplo, a definição do elemento title para o slide aplica-se totalmente ao título de um item. Digamos que se queira usar a mesma definição diferenciando apenas uma característica de um ou outro. Por exemplo, o tamanho do texto quando o documento for apresentado. Isto não é possível, a não ser que se defina dois elementos distintos (slide-title e item-title). A falta de hierarquia força a introdução de "hierarquia hifenizada" (hyphenization hierarchy). Estas limitações são as motivações fundamentais para o desenvolvimento de padrões de especificação de esquemas (XML Schema). ANY e EMPTY A utilização de ANY em um elemento indica que este elemento pode conter qualquer outro elemento definido ou PCDATA. A especificação EMPTY indica que um elemento não contem nenhum elemento. Referenciando o DTD Quando o DTD é descrito em um arquivo separado do documento XML associado este precisa ser referenciado. Para referenciar o DTD deve ser adicionada uma linha no documento XML como a especificada abaixo: <!DOCTYPE slideshow SYSTEM "slideshow.dtd"> <slideshow.. A tag DOCTYPE indica que o documento é um slideshow. Ou seja o documento consiste de um slideshow e de todos os elemento de dentro dele. A tag DOCTYPE tem que ocorrer depois da declaração XML e antes do elemento raiz. Um DTD pode ser colocado internamente em um documento XML. Da seguinte forma: <!DOCTYPE slideshow SYSTEM "slideshow1.dtd" [...local subset definitions here... ]> Exercícios: 1. Cite duas semelhanças e duas diferenças entre XML e HTML. 2. Cite 3 cenários práticos onde XML pode ser aplicada. 3. Quais são as regras que um documento XML bem-formado deve seguir? 4. Analise o documento abaixo e responda às questões 4.1 a 4.5.
<artigo data= 01/02/2006 data= 01/02/2006 > <autor nome= João sobrenome= Silva /> <autor nome= José sobrenome= Silva /> <titulo>introdução a XML</titulo> <resumo>este artigo trata dos conceitos de XML. O que descrevemos aqui é tão verdade quanto 5<4</resumo> </artigo> 4.1. O documento acima é um documento bem formado? Se não, por quê? 4.2. Como seria possível usar o símbolo < no texto 5<4 para que não houvesse erros na hora do parsing? Escreva pelo menos duas maneiras diferentes. 4.3. Quem é o primeiro autor deste artigo? Nomes Elementos e Atributos em XML são referenciados por seus nomes. Para garantir que estes nomes seja interpretados de forma não ambígua, tanto elementos e atributos utilizam URIs (Uniform Resource Identifiers). URIs são utilizadas para garantir que conflitos de nomes não irão ocorrer em documentos XML contendo elementos e atributos vindos de diferentes fontes e com diferentes escopos. Uma URI pode ser tanto um URN (Uniform Resource Name) ou um URL (Uniforme Resource Locator). Um URN é um identificador independente de localização, como, por exemplo um UUID (Universally Unique Identifier). Um UUID é um número de 16 bytes com um formato canônico. O númereo 550e8400-e29b-41d4-a716-446655440000 está no formato de um UUID. Já uma URL embute aspectos da localização no identificador. Em ambos os casos, quando uma URI é utilizada para tratar ambigüidades de nomes em XML, esta é tratada como um identificador de um conjunto abstrato de nomes chamados de Namespace. Não é necessário que uma referência a um namespace vá produzir alguma coisa diferente no documento XML. Preferencialmente, URIs serão simplesmente identificadores opacos. Namespaces são críticos para a produção de documentos XML que serão trocados entre múltiplas organizações, para identificar o contexto no qual elementos e atributos tem significado. Namespaces também podem ser usados para tratar ambigüidades de documentos internos de uma organização. Elementos e atributos XML possuem dois componentes: um nome local e o namespace URI. Um nome local deve obedecer a regra de produção de NCName (Ver em http://www.w3.org/tr/1999/rec-xml-names-19990114/). Um NCName inicia com caracteres alfabéticos ou anderscore seguido de 0 ou mais caracteres alfanuméricos, pontos, hífens ou underscores.
Seja o elemento < pessoas /> este elemento é identificado pelo seu nome local (pessoa) e não está relacionado com nenhum namespace. pessoas é um nome sobrecarregado que pode aceitar múltiplas interpretações, tanto por parte de seres humanos, quanto por aplicações de software. Dessa forma, é conveniente a utilização de namespaces. A forma seguinte introduz o namespace: < pessoas xmlns = uuid: 550e8400-e29b-41d4-a716-446655440000 /> A declaração xmlns= uri-reference associa a referência URI ao namespace default do elemento. Dessa forma, o namespace definido aplica-se a todos os elementos filhos deste elemento. No documento abaixo, o namespace do elemento Pessoa é também uuid: 550e8400- e29b-41d4-a716-446655440000. < pessoas xmlns = uuid: 550e8400-e29b-41d4-a716-446655440000 <pessoa /> /pessoas> Elementos filhos podem ter seus próprios namespaces. < pessoas xmlns = uuid: 550e8400-e29b-41d4-a716-446655440000 <pessoa xmlns = http://www.examplo.net/pessoas/schema /> /pessoas> Se pessoa tiver elementos filho, o ns deles será http://www.examplo.net/pessoas/schema e não o de pessoas. Para remover pessoa de qualquer ns definido em seus pais: < pessoas xmlns = uuid: 550e8400-e29b-41d4-a716-446655440000 <pessoa xmlns = /> /pessoas> Para facilitar a edição de documentos, pode-se usar apelidos para namespaces. Uma declaração de um namesapce segue a seguinte forma: xmlns:myns = uri-reference O prefixo local,myns segue a regra de formação de NCNames e será o apelido local para o ns. Posteriormente este apelido pode ser usado para a construção de nomes de elementos e atributos. A combinação de apelidos com nomes locais deve aderir a regra de produção de nomes Qualificados (QName) (veja em http://www.w3.org/tr/1999/rec-xml-names- 19990114/). Exemplo: < pessoas xmlns= http://www.examplo.net/pessoas/schema
xmlns: meuns= http://tdn.si.cefetes.br > <meuns:pessoa /> </pessoas> Se o nome de um elemento é constituído apenas do nome local sem prefixo, o seu ns será o ns default.. Se um nome de um atributo é constituído apenas de seu nome local este atributo não está associado a nenhum ns, independente do ns default de seu elemento. Declarações de ns podem ser aplicadas na definição de nomes do elemento onde foi declarada, de seus atributos e seus filhos e atributos de seus filhos. Exemplo: A declaração < pessoas xmlns= http://www.examplo.net/pessoas/schema xmlns: meuns= http://tdn.si.cefetes.br > <meuns:pessoa /> </pessoas> é equivalente a: < pessoas xmlns= http://www.examplo.net/pessoas/schema <pessoa xmlns= http://tdn.si.cefetes.br /> </pessoas> e a: < x: pessoas xmlns: x= http://www.examplo.net/pessoas/schema xmlns: meuns= http://tdn.si.cefetes.br > <meuns:pessoa /> </pessoas> No caso de haver declarações de ns diferentes com o mesmo prefixo, fica valendo a declaração mais interna (em termos de escopo). No exemplo: < x:a xmlns:x= http://develop.com > <x:b xmlns:x= http://exemplo.com > <x:c /> </x:b> <x:d /> </x:a> o ns de a e d é http://develop.com e o de b e c é http://exemplo.com. Cada atributo de um elemento deve estar associado a um único par (ns, nomelocal). Assim, a declaração abaixo é correta: <a xmlns = http://x.org xmlns:y= http://y.org b: Olá y:b= Adeus /> O atributo b sem estar asociado a um ns é diferente de y:b, associado ao ns http://y.org. Já a declaração abaixo está incorreta: <a xmlns:x = http://z.org xmlns:y= http://z.org
x:b: Olá y:b= Adeus /> Exercícios Faça uma DTD que valide os documentos abaixo (uma única DTD deve ser usada para validar ambos os documentos). Adicione aos documentos XML a declaração da DTD (DOCTYPE): Documento 1: <publicacoes> <artigo> <autor>jose</autor> <autor estudante="true">joao</autor> <autor>maria</autor> <titulo>uma avaliação de desempenho em ambientes paralelos</titulo> <local-publicacao> <cidade>manaus</cidade> <congresso>sbbd</congresso> </local-publicacao> <ano>2003</ano> </artigo> <artigo> <autor estudante="true">carlos</autor> <autor>joao</autor> <autor>márcia</autor> <titulo>xml aplicado</titulo> <local-publicacao> <cidade>gramado</cidade> <congresso>sbbd</congresso> </local-publicacao> <ano>2002</ano> <obs>artigo muito bom sobre <assunto>xml</assunto></obs> </artigo> </publicacoes> Documento 2: <artigo> <autor>jose</autor> <autor estudante="true">jorge</autor> <autor>maria</autor> <titulo>xml e suas aplicações</titulo> <local-publicacao> <cidade>dallas</cidade> <periodico>tods</periodico> </local-publicacao> <ano>2003</ano> <obs>artigo muito bom sobre <assunto>xml</assunto></obs> </artigo> 3 Escreva uma DTD que siga os seguintes critérios: possui um elemento livro que pode conter título e vários autores título e autor são strings o elemento livro possui os seguintes atributos: i. gênero, cujo valor pode ser: romance, policial ou suspense ii. língua, cujo valor pode ser: inglês ou português, e o valor default é português iii. código, que é único no documento XML como um todo
4 Escreva um documento XML válido de acordo com a DTD declarada no exercício 3. 5 Qual a diferença entre os valores possíveis de um atributo declarado como CDATA e outro declarado como NMTOKEN? 6 Explique os conceitos de documento válido e documento bem-formado. Um conceito pode ser considerado pré-requisito para o outro? Se sim, qual é pré-requisito de qual? Escrevendo uma aplicação distribuída usando Sockets e XML O Código abaixo implementa um cliente para um socket. package client; import java.io.*; import java.net.*; import system.interface1; public class KnockKnockClient { public static void main(string[] args) throws IOException { Socket kksocket = null; PrintWriter out = null; BufferedReader in = null; +porta) porta é conexao try { /** A declaraçao * kksocket = new Socket(Interface1.HOST, 4444); * ria um novo objeto Socket com o nome de kksocket. * Um socket estará associado a um ponto final TCP (Host * Neste caso o HOST está configurado como localhost e a * a de número 4444, onde o servidor estár esperando por uma kksocket = new Socket(Interface1.HOST, 4444); /** * A Declaraçao * out = new PrintWriter(kkSocket.getOutputStream(), true); * obtem o stream de saída do socket e o associa ao objeto * PrintWriter out. Entao, para escrever no kksocket usaremos o objeto out. out = new PrintWriter(kkSocket.getOutputStream(), true); /** * A Declaraçao * in = new BufferedReader(new InputStreamReader(kkSocket.getInputStream())); * obtem o stream de entrada do socket e o associa ao objeto BufferReader in. * Entao para lermos dados do kksocket usamos o objeto in.
in = new BufferedReader(new InputStreamReader(kkSocket.getInputStream())); /** * Se o host nao for encontrado gera a exceçao abaixo catch (UnknownHostException e) { System.err.println("Don't know about host:" + Interface1.HOST + "."); System.exit(1); /** * Se o servidor nao estiver escutando a porta procurada ocorre a exceçao abaixo catch (IOException e) { System.err.println("Couldn't get I/O for the connection to:" + Interface1.HOST + "."); System.exit(1); /** * A declaraçao * BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); * Cria um objeto BufferReader para permitir a leitura do teclado BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); String fromserver; String fromuser; /** * Enquanto a leitura do Socket retornar uma string nao nula continua no * while abaixo while ((fromserver = in.readline())!= null) { System.out.println("Server: " + fromserver); /* Se o servidor retornar a string Bye. o cliente termina if (fromserver.equals("bye.")) break; /* le a pergunta do usuário fromuser = stdin.readline(); if (fromuser!= null) { /* envia a pergunta do usuário para o servidor através do kksocket System.out.println("Client: " + fromuser); out.println(fromuser); out.close(); in.close(); stdin.close(); kksocket.close();
O Código do servidor é dado a seguir por duas classe uma classe que implementa um protocolo de conversação e a classe que implementa o socket Server package server; public class KnockKnockProtocol { private static final int WAITING = 0; private static final int SENTKNOCKKNOCK = 1; private static final int SENTCLUE = 2; private static final int ANOTHER = 3; private static final int NUMJOKES = 5; private int state = WAITING; private int currentjoke = 0; private String[] clues = { "Turnip", "Little Old Lady", "Atch", "Who", "Who" ; private String[] answers = { "Turnip the heat, it's cold in here!", "I didn't know you could yodel!", "Bless you!", "Is there an owl in here?", "Is there an echo in here?" ; public String processinput(string theinput) { String theoutput = null; if (state == WAITING) { theoutput = "Knock! Knock!"; state = SENTKNOCKKNOCK; else if (state == SENTKNOCKKNOCK) { if (theinput.equalsignorecase("who's there?")) { theoutput = clues[currentjoke]; state = SENTCLUE; else { theoutput = "You're supposed to say \"Who's there?\"! " + "Try again. Knock! Knock!"; else if (state == SENTCLUE) { if (theinput.equalsignorecase(clues[currentjoke] + " who?")) { theoutput = answers[currentjoke] + " Want another? (y/n)"; state = ANOTHER; else { theoutput = "You're supposed to say \"" + clues[currentjoke] + " who?\"" + "! Try again. Knock! Knock!"; state = SENTKNOCKKNOCK; else if (state == ANOTHER) { if (theinput.equalsignorecase("y")) { theoutput = "Knock! Knock!"; if (currentjoke == (NUMJOKES - 1)) currentjoke = 0; else currentjoke++;
state = SENTKNOCKKNOCK; else { theoutput = "Bye."; state = WAITING; return theoutput; package server; import java.net.*; import java.io.*; public class KnockKnockServer { public static void main(string[] args) throws IOException { ServerSocket serversocket = null; try { /** * A declaraçao * serversocket = new ServerSocket(4444); * tenta criar um objeto ServerSocket associado a porta 4444 * Se esta porta estiver em uso ocorre a exceçao IOException serversocket = new ServerSocket(4444); catch (IOException e) { System.err.println("Could not listen on port: 4444."); System.exit(1); Socket clientsocket = null; try { /** * A declaracao * clientsocket = serversocket.accept(); * é bloqueante e fica esperando até um cliente faça uma conexao. clientsocket = serversocket.accept(); catch (IOException e) { System.err.println("Accept failed."); System.exit(1); /** * Apos um cliente estabelecer uma conexao valida * o servidor cria um objeto out e um in para escrever e ler no * socket associado ao cliente conectado PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true); BufferedReader in = new BufferedReader( new InputStreamReader( clientsocket.getinputstream())); String inputline, outputline; /** o servidor cria também uma instancia do protocolo de conversaçao
* KnockKnockProtocol. Este é um protocolo ilustrativo de perguntas * e respostas. KnockKnockProtocol kkp = new KnockKnockProtocol(); outputline = kkp.processinput(null); out.println(outputline); while ((inputline = in.readline())!= null) { outputline = kkp.processinput(inputline); out.println(outputline); if (outputline.equals("bye.")) break; out.close(); in.close(); clientsocket.close(); serversocket.close(); Implementação de um sistema para envio e recebimento de Pedidos Neste sistema, o cliente irá enviar um pedido através da emissão de um documento pedido.xml para o servidor. O servidor recebe o pedido, processa e armazena o pedido em um HashSet. O código do cliente é o seguinte: package edi.client; import java.io.*; import java.net.*; import system.interface1; public class Emissor { public Emissor() { public static void main(string[] args) throws IOException { Socket kksocket = null; PrintWriter out = null; BufferedReader in = null; try { /** A declaraçao * kksocket = new Socket(Interface1.HOST, 4444); * ria um novo objeto Socket com o nome de kksocket. * Um socket estará associado a um ponto final TCP (Host +porta) * Neste caso o HOST está configurado como localhost e a porta é * a de número 4444, onde o servidor estár esperando por uma conexao kksocket = new Socket(Interface1.HOST, 4444);
/** * A Declaraçao * out = new PrintWriter(kkSocket.getOutputStream(), true); * obtem o stream de saída do socket e o associa ao objeto * PrintWriter out. Entao, para escrever no kksocket usaremos o objeto out. out = new PrintWriter(kkSocket.getOutputStream(), true); /** * A Declaraçao * in = new BufferedReader(new InputStreamReader(kkSocket.getInputStream())); * obtem o stream de entrada do socket e o associa ao objeto BufferReader in. * Entao para lermos dados do kksocket usamos o objeto in. in = new BufferedReader(new InputStreamReader(kkSocket.getInputStream())); /** * Se o host nao for encontrado gera a exceçao abaixo catch (UnknownHostException e) { System.err.println("Nao encontrei o host:" + Interface1.HOST + "."); System.exit(1); /** * Se o servidor nao estiver escutando a porta procurada ocorre a exceçao abaixo catch (IOException e) { System.err.println("Nao obtive uma conexao com o servidor no host:" + Interface1.HOST + "."); System.exit(1); /** * A declaraçao * BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); * Cria um objeto BufferReader para permitir a leitura do teclado BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); String fromserver; String fromuser; String linha; BufferedReader pedido = new BufferedReader(new FileReader("pedido.xml")); /** * Enquanto a leitura do Socket retornar uma string nao nula continua no * while abaixo System.out.println("Enviando o arquivo Pedido.xml.."); while ((linha = pedido.readline())!= null) { out.println(linha); System.out.println("Arquivo Pedido.xml enviado com sucesso..");
out.close(); in.close(); stdin.close(); kksocket.close(); A interface Interface1 especifica a constante HOST package system; public interface Interface1 { public static final String HOST = "LOCALHOST"; A implementação do Servidor envolve as seguintes classes: HashSet (from util) IOException (from io) Interface (from server) ColecaoDePedidos (from server) Interface() main() ColecaoDePedidos() Pedido (from server) 1 umpedido Receptador (from server) Receptador() recebepedido() * Item (from server) Processador (from server) DefaultHandler (from helpers) Attributes (from sax) Date (from util) -$out Writer (from io) SAXException (from sax) As classes Pedido e Item possuem os seguintes atributos e operações:
Pedido empresa : Logical View::java::lang::String data : Date cliente : Logical View::java::lang::String itens : HashSet getitens() getempresa() getdata() setcliente() setitens() setempresa() setdata() getcliente() AdicionaItem() Pedido() Item descricao : Logical View::java::lang::String marca : Logical View::java::lang::String embalagem : Logical View::java::lang::String quantidade : int getmarca() getdescricao() getquantidade() setembalagem() setmarca() setdescricao() setquantidade() getembalagem() Item() A seguir temos o código de cada classe implementada: Item package edi.server; public class Item { private String descricao; private String marca; private String embalagem; private int quantidade; public String getmarca() { return marca; public String getdescricao() { return descricao; public int getquantidade() { return quantidade; public void setembalagem(string embalagem) { this.embalagem = embalagem; public void setmarca(string marca) { this.marca = marca; public void setdescricao(string descricao) { this.descricao = descricao; public void setquantidade(int quantidade) { this.quantidade = quantidade;
public String getembalagem() { return embalagem; public Item() { Pedido package edi.server; import java.util.calendar; import com.sun.tools.javac.v8.util.set; import java.util.date; import java.util.hashset; public class Pedido { private String empresa; private Date data; private String cliente; private HashSet itens; public HashSet getitens() { return itens; public String getempresa() { return empresa; public Date getdata() { return data; public void setcliente(string cliente) { this.cliente = cliente; public void setitens(hashset itens) { this.itens = itens; public void setempresa(string empresa) { this.empresa = empresa; public void setdata(date data) { this.data = data; public String getcliente() { return cliente; public void AdicionaItem(Item item){ itens.add(item); public Pedido() { this.itens= new HashSet();
ColecaoDePedidos package edi.server; import java.util.hashset; public class ColecaoDePedidos extends HashSet{ public ColecaoDePedidos() { Receptador package edi.server; import java.net.*; import java.io.*; public class Receptador { public Receptador() { public Pedido recebepedido() throws IOException { ServerSocket serversocket = null; try { /** * A declaraçao * serversocket = new ServerSocket(4444); * tenta criar um objeto ServerSocket associado a porta 4444 * Se esta porta estiver em uso ocorre a exceçao IOException serversocket = new ServerSocket(4444); catch (IOException e) { System.err.println("Nao consigo escutar na porta: 4444. Ela deve estar ocupada"); System.exit(1); Socket clientsocket = null; try { /** * A declaracao * clientsocket = serversocket.accept(); * é bloqueante e fica esperando até um cliente faça uma conexao. clientsocket = serversocket.accept(); catch (IOException e) { System.err.println("Falha no Accept."); System.exit(1); /** * Apos um cliente estabelecer uma conexao valida * o servidor cria um objeto out e um in para escrever e ler no * socket associado ao cliente conectado PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
BufferedReader in = new BufferedReader( new InputStreamReader( clientsocket.getinputstream())); BufferedWriter doc= new BufferedWriter(new FileWriter("doc.xml")); String inputline, outputline; while ((inputline = in.readline())!= null) { doc.write(inputline); out.close(); in.close(); doc.close(); clientsocket.close(); serversocket.close(); Processador p= new Processador(); return p.processapedido("doc.xml"); Processador package edi.server; import java.io.*; import org.xml.sax.*; import org.xml.sax.helpers.defaulthandler; import javax.xml.parsers.saxparserfactory; import javax.xml.parsers.saxparser; import java.util.date; public class Processador extends DefaultHandler { static private Writer out; Pedido umpedido; public Processador() { umpedido = new Pedido(); public Pedido processapedido(string pedido){ DefaultHandler handler = this; SAXParserFactory factory = SAXParserFactory.newInstance(); try { out = new OutputStreamWriter(System.out, "ISO-8859-1"); // Parse the input SAXParser saxparser = factory.newsaxparser(); saxparser.parse( new File(pedido), handler ); catch (Throwable t) { t.printstacktrace(); return this.umpedido;
private void emit(string s) throws SAXException { try { out.write(s); out.flush(); catch (IOException e) { throw new SAXException("I/O error", e); private void nl() throws SAXException { String lineend = System.getProperty("line.separator"); try { out.write(lineend); catch (IOException e) { throw new SAXException("I/O error", e); public void startdocument() throws SAXException { public void enddocument() throws SAXException { try { // nl(); out.flush(); catch (IOException e) { throw new SAXException("I/O error", e); public void startelement(string namespaceuri, String sname, // simple name (localname) String qname, // qualified name Attributes attrs) throws SAXException { Item umitem; String ename = sname; // element name if ("".equals(ename)) ename = qname; // namespaceaware = false if (ename.equals("pedido")){ this.umpedido = new Pedido(); name if (attrs!= null) { for (int i = 0; i < attrs.getlength(); i++) { String aname = attrs.getlocalname(i); // Attr if ("".equals(aname)) aname = attrs.getqname(i); if (aname.equals("empresa")) this.umpedido.setempresa(attrs.getvalue(i));
if (aname.equals("date")) this.umpedido.setdata(new Date(attrs.getValue(i))); if (aname.equals("cliente")) this.umpedido.setcliente(attrs.getvalue(i)); else if (ename.equals("item")){ umitem = new Item(); if (attrs!= null) { for (int i = 0; i < attrs.getlength(); i++) { String aname = attrs.getlocalname(i); // Attr name if ("".equals(aname)) aname = attrs.getqname(i); if (aname.equals("descricao")){ umitem.setdescricao(attrs.getvalue(i)); emit("descricao: " + attrs.getvalue(i)); if (aname.equals("marca")) umitem.setmarca(attrs.getvalue(i)); if (aname.equals("embalagem")) umitem.setembalagem(attrs.getvalue(i)); if (aname.equals("quantidade")) umitem.setquantidade(new Integer(attrs.getValue(i)).intValue()); umpedido.adicionaitem(umitem); public void endelement(string namespaceuri, String sname, // simple name String qname // qualified name ) throws SAXException { // emit("</"+sname+">"); // nl(); public void characters(char buf[], int offset, int len) throws SAXException { String s = new String(buf, offset, len); // emit(s);
Usando XSTL para apresentar os dados XSLT é uma linguagem para transformar documentos XML em outros documentos XML. XSL é abreviação de extensible Stylesheet Language (Linguagem de Folha de Estilos Extensível). O World Wide Web Consortium (W3C) começou a desenvolver o XSL porque havia uma necessidade linguagem de filha de estilos baseada em XML. XML não usa tags predefinidas (as tags podem ser ao "gosto do freguês") e os significados dessas tags são não "interpretáveis". A tag <table> pode significar uma tabela HTML ou um móvel, e o browser não sabe como mostrá-la. Deve haver algo então, que adicionado ao documento XML, descreve como o documento deve ser mostrado; e isso é o XSL! XSL consiste de 3 partes: XSLT é uma linguagem para transformar documentos XML XPath é uma linguagem para definir partes de um documento XML XSL-FO é uma linguagem para formatar documentos XML Pense em XSL como um conjunto de linguagens que podem transformar XML em XHTML, filtrar e ordenar dados XML, definir partes de um documento XML, formatar dados XML baseados nos valores dos dados, como mostrar valores negativos em vermelho, e exportar dados XML para mídias diferentes, como telas, papel ou voz. Transformações XSLT XSLT é a parte mais importante dos padrões XSL. Ele é a parte do XSL usada para transformar um documento XML em outro documento XML, ou um outro tipo de documento que é reconhecido por um browser, como HTML e XHTML. Normalmente XSLT faz isso transformando cada elemento XML em um elemento (X)HTML. XSLT também pode adicionar novos elementos no arquivo de saída, ou remover elementos. Ele pode rearranjar e ordenar elementos, testar e tomar decisões sobre quais elementos mostrar, e muito mais. Um modo comum de descrever o processo de transformação é dizer que o XSLT transforma uma árvore de origem XML em uma árvore de resultado XML. Declarando um documento XSL O elemento raiz que declara o documento a ser uma folha de estilos XSL é <xsl:stylesheet> ou <xsl:transform>. Nota: <xsl:stylesheet> e <xsl:transform> são completamente sinônimos e um ou outro pode ser usado! A maneira correta de declarar uma folha de estilos XSL de acordo com a Recomendação W3C XSLT é:
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/xsl/transform"> ou: <xsl:transform version="1.0" xmlns:xsl="http://www.w3.org/1999/xsl/transform"> Exemplo: Vamos supor que queiramos apresentar o conteúdo do documento XML abaixo: <?xml version="1.0" encoding="iso-8859-1"?> <catalog> <cd> <title>empire Burlesque</title> <artist>bob Dylan</artist> <country>usa</country> <company>columbia</company> <price>10.90</price> <year>1985</year> </cd>... </catalog> O documento original está em cdcatalog.xml. Para tanto vamos criar uma folha de estilo (cdcatalog.xsl) com o seguinte conteúdo: <?xml version="1.0" encoding="iso-8859-1"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/xsl/transform"> <xsl:template match="/"> <html> <body> <h2>my CD Collection</h2> <table border="1"> <tr bgcolor="#9acd32"> <th align="left">title</th> <th align="left">artist</th> </tr> <xsl:for-each select="catalog/cd"> <tr> <td><xsl:value-of select="title"/></td> <td><xsl:value-of select="artist"/></td> </tr> </xsl:for-each> </table> </body> </html> </xsl:template> </xsl:stylesheet>
Para ligar o documento XML com a folha de estilo deve-se adicionar a seguinte linha após a declaração do arquivo XML: <?xml-stylesheet type="text/xsl" href="cdcatalog.xsl"?> O elemento <xsl:template> Uma folha de estilos XSL consiste de um conjunto de regras chamados moldes (templates). Cada elemento <xsl:template> contém regras para aplicar quando um nó específico é encontrado. XSL utiliza moldes para definir como um elemento deve ser aproesentado. O atributo match é usado para associar um molde com um elemento XML. O atributo match também pode ser usado para definir um molde para toda uma seção de um documento XML (por exemplo, match="/" define o documento todo).. A folha de estilos XSL a seguir contém um molde para emitir o Catálogo de CDs XML de nosso exemplo: <?xml version="1.0" encoding="iso-8859-1"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/xsl/transform"> <xsl:template match="/"> <html> <body> <h2>my CD Collection</h2> <table border="1"> <tr bgcolor="#9acd32"> <th>title</th> <th>artist</th> </tr> <tr> <td>.</td> <td>.</td> </tr> </table> </body> </html> </xsl:template> </xsl:stylesheet> A tag <xsl:template> define o início de um molde. O atributo match="/" associa (combina) o molde com a raiz (/) do documento XML de origem. O resto do documento contém o molde propriamente dito, exceto pelas duas últimas linhas que definem o fim do molde e o fim da folha de estilos. O elemento <xsl:value-of> O elemento <xsl:value-of> extrai o valor de um nó selecionado e pode ser usado para selecionar o valor de um elemento XML e adicioná-lo no resultado da transformação:
<?xml version="1.0" encoding="iso-8859-1"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/xsl/transform"> <xsl:template match="/"> <html> <body> <h2>my CD Collection</h2> <table border="1"> <tr bgcolor="#9acd32"> <th>title</th> <th>artist</th> </tr> <tr> <td><xsl:value-of select="catalog/cd/title"/></td> <td><xsl:value-of select="catalog/cd/artist"/></td> </tr> </table> </body> </html> </xsl:template> </xsl:stylesheet> O valor do atributo select requerido contém uma expressão XPath. Ela funciona como a navegação num sistema de arquivos onde uma barra à frente (/) seleciona subdiretórios. O elemento <xsl:for-each> O elemento <xsl:for-each> permite a você fazer iterações (loops) em XSLT e pode ser usado para selecionar todo elemento XML de um conjunto de nós específico: <?xml version="1.0" encoding="iso-8859-1"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/xsl/transform"> <xsl:template match="/"> <html> <body> <h2>my CD Collection</h2> <table border="1"> <tr bgcolor="#9acd32"> <th>title</th> <th>artist</th> </tr> <xsl:for-each select="catalog/cd"> <tr> <td><xsl:value-of select="title"/></td> <td><xsl:value-of select="artist"/></td> </tr> </xsl:for-each> </table> </body> </html> </xsl:template> </xsl:stylesheet>
O for-each aparece no exemplo 6 Filtrando a saída Nós podemos filtrar a saída de um arquivo XML adicionando um critério ao atributo select de um elemento <xsl:for-each>. <xsl:for-each select="catalog/cd[artist='bob Dylan']"> Operadores de filtragem válidos são: = (igual)!= (diferente) < (menor que) > (maior que) <?xml version="1.0" encoding="iso-8859-1"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/xsl/transform"> <xsl:template match="/"> <html> <body> <h2>my CD Collection</h2> <table border="1"> <tr> <th>title</th> <th>artist</th> </tr> <xsl:for-each select="catalog/cd[artist='bob Dylan']"> <tr> <td><xsl:value-of select="title"/></td> <td><xsl:value-of select="artist"/></td> </tr> </xsl:for-each> </table> </body> </html> </xsl:template> </xsl:stylesheet> O filtro está no exemplo 6 O elemento <xsl:sort> O elemento <xsl:sort> é usado para ordenar o resultado. Para gerar um arquivo XML como um arquivo XHTML, e ordená-lo ao mesmo tempo, simplesmente adicione um elemento sort dentro de um elemento for-each no seu arquivo XSL: <xsl:for-each select="catalog/cd"> <xsl:sort select="artist"/> o sort aparece no exemplo 7.
O elemento <xsl:if> O elemento <xsl:if> contém um padrão que só será aplicado se uma condição específica for verdadeira. Para colocar um teste condicional frente ao conteúdo de um arquivo, simplesmente adicione um elemento <xsl:if> no documento XSL como abaixo: <xsl:if test="price > 10"> alguma saida... </xsl:if> O valor do atributo obrigatório test será a expressão a ser avaliada. O if aparece no exemplo 8. O elemento <xsl:choose> O elemento <xsl:choose> é usado em conjunto com <xsl:when> e <xsl:otherwise> para expressar múltiplos testes condicionais. Para inserir o teste condicional choose frente ao conteúdo de um arquivo XML, simplesmente adicione os elementos <xsl:choose>, <xsl:when> e <xsl:otherwise> no seu arquivo XSL como abaixo: <xsl:choose> <xsl:when test="price > 10">...algum código... </xsl:when> <xsl:otherwise>...algum código... </xsl:otherwise> </xsl:choose> Os arquivos xsl 9 e 10 apresentam o uso de choose.