Universidade Federal de Minas Gerais

Instituto de Ciências Exatas Departamento de Ciência da Computação

WELLINGTON GOMES DE VASCONCELOS

Utilizando de XML para integração de sistemas de informação

Belo Horizonte 2009

Universidade Federal de Minas Gerais Instituto de Ciências Exatas

Departamento de Ciência da Computação Especialização em Informática: Ênfase: Engenharia de Software

Utilizando de XML para integração de sistemas de informação Por

Wellington Gomes de Vasconcelos

Monografia de final de Curso

CEI-ES0326-T14-2008-1

Profª Dra. Mirella Moura Moro

Orientadora

Belo Horizonte 2009

2

WELLINGTON GOMES DE VASCONCELOS

Utilizando de XML para integração de sistemas de informação

Monografia apresentada ao Programa de Pós-Graduação em Ciência da Computação do Instituto de Ciências Exatas da Universidade Federal de Minas Gerais, como requisito parcial para a obtenção do grau de Especialista em Informática.

Área de concentração: Engenharia de Software Orientador: Profª Dra. Mirella M. Moro

Belo Horizonte 2009

3

RESUMO

O principal objetivo deste trabalho é explicar a utilização da tecnologia XML juntamente com a tecnologia PHP para a integração de sistemas de informação. A linguagem XML é uma meta-linguagem universal que pode ser utilizada por qualquer aplicação de plataformas diferentes. Atualmente, é a base de WebServices, que são serviços utilizados para integrar sistemas através da Web. Este trabalho apresenta alguns conceitos de XML e PHP e como acessar um documento XML para leitura, gravação e alteração de dados, através da tecnologia PHP.

Palavras-chave: PHP, XML, WebService em PHP, SimpleXML, Dom em PHP.

4

ABSTRACT

This work focuses on integration of information systems. Specifically, its main goal is to explain the use of XML with PHP technology. XML is a universal meta-language that can be used for any application on different platforms. XML is the base of WebServices, which are the main technology for integration over the Web. This work presents some concepts of XML and PHP and how to access an XML file for reading, storing and updating data through a PHP-based system.

Keywords: PHP, XML, WebService in PHP, SimpleXML, Dom in PHP.

5

LISTA DE FIGURAS

FIG 1: Partes de um documento XML............................................................................9

6

LISTA DE SIGLAS

API: Application Programming Interface

CGI: Common Gateway Interface

DOM: Document Object Model

DTD: Document Type Definition

HTML: HyperText Markup Language

IP: Instruções de Processamento

PECL: Hypertext Preprocessor Extension Community Library

PHP: Hypertext Preprocessor

SAX: Simple API for XML

SGML: Standard Generalized Markup Language

SQL: Structured Query Language

UTF-8: 8-bit Unicode Transformation Format

W3C: World Wide Consortium

XML: Extensible Markup Language

XSL: Extensible Stylesheet Language

XSLT: Extensible Stylesheet Language Transformations

7

SUMÁRIO

1. Introdução ........................................................................................................................ 9

2. Referencial Teórico ......................................................................................................... 10

2.1. XML - Extensible Markup Language ............................................................................... 10

2.1.1. Estrutura ...................................................................................................................... 10

2.1.1.1. Caracteres ................................................................................................................ 10

2.1.1.2. Tags ........................................................................................................................... 11

2.1.1.3. Documentos .............................................................................................................. 11

2.1.1.4. Elementos ................................................................................................................. 12

2.1.1.5. Atributos .................................................................................................................. 12

2.1.1.6. Entidades .................................................................................................................. 12

2.1.1.7. Marcações diversas ................................................................................................. 13

2.1.1.7.1. Comentários ............................................................................................................. 13

2.1.1.7.2. Instruções de Processamento .................................................................................. 13

2.1.1.7.3. Seções CDATA ......................................................................................................... 13

2.1.2. Validação ...................................................................................................................... 14

2.1.3. XPath ............................................................................................................................ 14

2.1.4. DOM ............................................................................................................................. 15

2.1.5. SAX ............................................................................................................................... 15

2.2. PHP ....................................................................................................................................... 15

2.2.1. PHP e XML .................................................................................................................. 16

2.2.2. SimpleXML .................................................................................................................. 16

2.2.3. DOM em PHP .............................................................................................................. 17

2.2.4. XML Reader ................................................................................................................ 20

2.3. XSLT .................................................................................................................................... 21

2.4. WebService .......................................................................................................................... 23

3. Implementação ................................................................................................................ 24

3.1. Construção do arquivo XML ............................................................................................. 24

3.2. Construção da estrutura PHP para acesso ao arquivo XML .......................................... 25

3.3. Construção da estrutura PHP para gravação em um arquivo XML ............................. 26

4. Conclusão ........................................................................................................................ 29

5. Bibliografia ..................................................................................................................... 30

8

1. Introdução

Este trabalho visa o estudo de uma tecnologia a ser utilizada na integração de vários sistemas utilizados em uma linha de produção. Para a sua realização, serão utilizadas as tecnologias XML, uma meta-linguagem que utiliza de marcadores para descrever dados, PHP, uma linguagem de programação utilizada para desenvolvimento de páginas Web. Apresentam-se aqui, as formas de criação, de utilização, de validação, de exibição e de armazenamento de uma estrutura XML e como acessar seu dado através de um sistema Web confeccionado em PHP.

O XML é um formato utilizado para gerar documentos com dados organizados hierarquicamente. Pode ser utilizado como, por exemplo: Banco de Dados, imagens vetoriais e documentos de textos formatados.

Melhorias e novas funcionalidades foram introduzidas na linguagem PHP a partir de sua versão cinco, o que ocasionou grandes avanços para a criação e utilização de Web Services e XML.

Através de Web Service torna-se possível a integração e comunicação de sistemas e aplicações distintos independente de qual plataforma foram desenvolvidos. Com um serviço web os dados são enviados e recebidos por aquelas aplicações em formato XML, que é uma linguagem universal.

Com isso, o produto deste estudo será utilizado para gerar um WebService de controle de produção e apoio a tomadas de decisões. Este novo sistema acessará um arquivo XML alimentado com dados determinados, retirados de diversos bancos de dados.

Esta monografia está organizada da seguinte maneira. A seção 2 apresenta tecnologias utilizadas neste trabalho. A seção 3 deste trabalho apresenta como implementar em linguagem PHP o acesso a um arquivo XML e como utilizar os dados nele contido.

9

2. Referencial Teórico

Este capítulo foi desenvolvido para demonstrar as tecnologias utilizadas no desenvolvimento deste trabalho. Serão apresentadas explicações de forma sucinta com o intuito de aumentar o entendimento sobre XML, PHP e Webservices.

Sobre XML é demonstrado uma apresentação sobre a linguagem, sobre a sua estrutura e como utilizá-la. A respeito da Linguagem PHP será apresentado uma explicação sobre a linguagem, como ela foi desenvolvida para o tratamento de documentos XML e como utilizar bibliotecas para isso. Contém também, uma explicação sobre Web Services apresentando sua forma de utilização e o motivo de sua idealização.

2.1. XML - Extensible Markup Language

XML é uma linguagem que contém marcadores, assim como o HTML, foi projetada para descrever dados. Ela é extensível, o que é uma grande vantagem, pois permite criar as suas próprias tags. Foi desenvolvido pelo World Wide Consortium (W3C) e provê um simples e poderoso mecanismo para armazenamento, processamento e distribuição da informação.

HTML e XML derivam do SGML, identificam elementos em um documento Web e utilizam sintaxes similares. A diferença entre HTML e XML é que a primeira descreve a aparência e a ações em uma página Web, enquanto a outra descreve o que cada trecho de dados é ou representa.

Apesar de XML ser muito semelhante com HTML não foi idealizado para exibir dados e sim para o transporte deles. É utilizado em desenvolvimento de serviços Web para compartilhar, armazenar e simplificar dados, suas tags são descritivas e podem ser definidas pelo autor do documento.

As marcações são utilizadas para rotular ou limitar trechos de textos ou outras tags, com isso, o processamento do documento se torna possível por programas especializados, sem elas um software não entende as delimitações do conteúdo, tratando-o como uma unidade, limitando sua capacidade de acesso aos dados contidos.

O XML descreve dados de forma estruturada através de uma plataforma simples e independente. É uma meta-linguagem que permite criar marcações para que os dados estejam descritivos e codificados através de nomes para que possam ser compreendidos por aplicações e seres humanos.

Em resumo, XML é uma linguagem, Case Sensitive1, de marcação de texto utilizada para armazenamento de dados. Um arquivo contém tags que disponibilizam o texto de uma forma fácil de compreender, tanto para humanos quanto para softwares.

2.1.1. Estrutura 2.1.1.1. Caracteres

A especificação atual da linguagem XML indica a utilização do conjunto de caracteres

ISSO-10646, apesar de usar a maioria dos caracteres dispostos no conjunto Unicode, porém, os dois conjuntos são mantidos em sincronia.

1 Case sensitive é um termo em computação que significa que a diferença entre letras maiúsculas e minúsculas são percebidas.

10

Em um documento XML o espaço em branco contém um significado, onde fica a cargo da aplicação determinar a sua utilização.

Para determinar um nome é necessário que comece com uma letra ou um sublinhado e que sejam seguido de uma combinação de caracteres (alfanuméricos, períodos, hífens, sublinhados e dois pontos).

Entendem-se caracteres dados como sendo tudo o que se difere de marcação, o que significa que é o conteúdo do documento como, por exemplo: declarações XML para o tipo de documento; elemento; entidade referências; referências de caracteres; comentários; instruções de transformação (IPs); secção CDATA delimitadores; texto declarações; e qualquer elemento branco fora do documento e não contidos em outras marcações.

2.1.1.2. Tags

Tags definem as fronteiras de elementos, nas quais o programa que processa o documento quebrá-lo em objetos discretos.

As etiquetas de marcação (tags) podem ser de diferentes tipos de objetos XML como: Elemento vazio, elemento de conteúdo, declarações, processamento de instruções, comentários, CDATA e entidade de referencias.

As tags são case sensitive¹, ou seja, o nome de uma tag fechada tem de ser escrita da mesma forma em que está a tag aberta. Por exemplo, a tag <nome></nome>.

2.1.1.3. Documentos

Documentos XML possuem regras rígidas, como por exemplo, um atributo sem aspas torna o documento inutilizável, enquanto que no HTML isso é tolerado. As aplicações não precisam identificar o que está errado em um arquivo, mas sim parar sua interpretação e reportar o erro.

Os dados em um arquivo XML são organizados obedecendo uma hierarquia. Esse formato é visto frequentemente em documentos de textos formatados, imagens vetorias, etc. O que o faz ser considerado um ótimo formato de criação de dados.

Um documento XML é uma entidade lógica, ou seja, o documento pode ser contido em vários arquivos dispostos em máquinas diferentes. O analisador terá de ter a capacidade de ler o documento e reunir as peças em um todo coerente.

Um documento XML é dividido em Documento Prolog e Documento Elemento. O primeiro agrupa metadados em uma seção especial. O segundo, também denominado como Elemento Raiz, conte o conteúdo do documento. A figura abaixo exemplifica o que foi descrito acima:

11

FIG 2: Partes de um documento XML

Documentos XML são arquivos texto onde são armazenados dados e disponibilizados de forma hierárquica através de marcações para fácil entendimento e utilização por softwares.

2.1.1.4. Elementos

Elementos dividem o documento XML em blocos que servem a uma finalidade específica, atendendo a uma hierarquia. Existem elementos recipientes utilizados para guardar textos ou outros elementos e, existem também, elementos vazios, marcando um lugar especial para transformações.

Um elemento é constituído por uma tag de abertura, uma de fechamento e entre essas tags, o conteúdo. Um elemento vazio é constituído por uma única tag e não possui nenhum conteúdo.

Concluindo, não necessariamente tem de ter uma tag abrindo e outra fechando, se o elemento estiver vazio pode-se utilizar o caracter “/” para simbolizar que a tag está fechada, como por exemplo, <nome />. Porém, caso o elemento conter um valor a tag terá de ser fechada da seguinte forma: <nome> João da Silva </nome>.

2.1.1.5. Atributos

Os atributos são usados para descrever os elementos XML ou para fornecer uma informação adicional. Podem existir dentro de tags e elementos vazios. Porém, não poderão aparecer em uma tag de fechamento. Eles usam a seguinte sintaxe: Nome = "Valor" ou Nome='Valor'. Sendo que, valores podem ser delimitados por aspas simples ou duplas. No entanto, você deve usar o mesmo tipo de aspas para encapsular o valor do atributo. Também é perfeitamente aceitável usar um estilo de aspas para um atributo e outro estilo para outro atributo.

Os atributos, além serem utilizados para guardar informações sobre um elemento, podem ser usados para acrescentar um rótulo para um único elemento, colocá-lo em uma categoria, adicione um sinalizador Booleano, ou associar um curto seqüência de dados.

Em resumo, os atributos armazenam valores que descrevem um elemento e têm de ser descritos na tag inicial, não podendo ocorrer repetições, ou seja, atributos com o mesmo nome. Dados podem ser armazenados também em atributos e não somente no corpo dos elementos.

2.1.1.6. Entidades 12

Em XML, entidades são referencias que podem ser utilizadas de maneiras distintas que

podem ser declaradas no Documento Prolog ou em um DTD, elas podem ser consultadas várias vezes no contexto do documento.

Entidades de referencia são utilizadas para determinar strings definidas anteriormente, sua representação pode ser feita utilizando caracteres numéricos, caracter de referências. Entidades têm a forma de “&”, seguido por um nome legal e finalizado por ponto e vírgula, muito parecido com o conceito em HTML.

Entidades têm de ser declaradas antes de sua utilização em um documento. Podem ser declaradas no subconjunto interno, ideal para as entidades locais, e em um DTD externo, que é mais adequado para entidades compartilhadas entre documentos. Se o analisador é executado através de uma entidade de referência que não tenha sido declarada, ou implicitamente (uma entidade predefinida) ou explicitamente, não é possível inserir texto de substituição no documento, porque não saberá o que substituir na entidade.

A melhor forma de exemplificar uma entidade é o comando ‘&nbsp;’, ao referenciar este comando em uma página HTML, em seu lugar é exibido um espaço em branco, que, já havia sido especificado anteriormente.

2.1.1.7. Marcações diversas

Comentários, instruções de processamento e seções CDATA não estão definidos como objetos de marcação.

2.1.1.7.1. Comentários

O conteúdo dos comentários não é interpretado pelo processador XML, são utilizados

para indicar a finalidade de arquivos e seções ajudando a navegação em um documento desconhecido, assim como um programador adiciona notas em seu código fonte, sem afetar o documento.

Os analisadores não são obrigados a processar observações, embora a maioria permitirá o acesso ao conteúdo. Isto é o que parece ser um comentário: <! - Este é um comentário ->”.

2.1.1.7.2. Instruções de Processamento

Instruções de Processamento (PI) são constituídas por uma meta-chave e alguns dados. O analisador carrega a instrução, o seu manipulador reconhece a palavra-chave e pode utilizar os dados descritos, caso contrário, eles são rejeitados.

A PI indica para a aplicação o que deve ser processado, ela assume a forma de <?, seguido por um nome válido (alvo), um espaço em branco, logo após a instrução é determinada e termina com ?>, como no exemplo abaixo:

<? Alvo instruções ?>

2.1.1.7.3. Seções CDATA

CDATA é uma “não marcação” constituída de dados, ou seja, o analisador entende como sendo um texto regular sem qualquer tipo de marcação. Essa seção é delimitada por “]]>”, o que significa que, o que estiver após esse delimitador não é parte daquele texto.

13

Seções CDATA permitem que qualquer caracter UNICODE, em sua forma literal, pode ser utilizado. Elas são formatadas da seguinte maneira: começam com “<![CDATA[”, seguida pelo conteúdo e delimitada por “]]>”, como no exemplo mostrado abaixo:

<! [CDATA [... conteúdo aqui ...]]>”.

2.1.2. Validação

Para que um documento XML seja um arquivo válido temos que usar a Definição do Tipo de Dados. O seu propósito é definir uma construção de blocos válidos para um documento XML, e definir a estrutura do documento usando uma lista de elementos válidos, podendo ser declarada dentro de um documento XML ou num arquivo á parte.

Um documento válido tem de estar de acordo com uma estrutura delineada em um DTD ou um esquema, ao ocorrer uma inserção de dados diferente do modelo ocasionará um erro. Isso segue a mesma idéia de um esquema de banco de dados, onde uma tabela define os campos, tipos de dados, padrões e tamanhos.

As DTDs descrevem como elementos estão dispostos em um documento. Sobre o conteúdo do documento informam apenas se podem conter caracteres de dados, não podendo limitar o conteúdo de elementos, porém, atributos podem ser declarados de tipos diferentes.

O esquema define a forma de observar um documento, define a hierarquia de elementos e o tipo de conteúdo específico que podem conter podendo aplicar restrições semelhantes para várias peças do documento.

Declarações de um tipo de Elemento são feitas como o exemplo a seguir:

<! ELEMENTO nome_elemento tipo_conteudo>...

A parte “nome_elemento” diz o nome específico para o elemento. A parte “tipo_conteudo” indica qual tipo de conteúdo é definido para o elemento, pode ser utilizado os valor EMPTY (significa que o elemento não pode conter conteúdo) ou ANY (significa que pode conter qualquer tipo de conteúdo inclusive não para todos), ou também, pode ser um modelo do tipo misto ou um nodo filho.

Um elemento pode conter apenas filhos e nenhum outro conteúdo, para declarar seus elementos filhos na DTD basta colocar na tag de elemento o nome dos filhos entre parênteses e separados por vírgulas como no exemplo seguinte: <! ELEMENTO nome_elemento (Filho1, Filho2).

Todas as declarações são carregadas na memória antes que ocorra qualquer validação, então tudo o que é necessário é que cada elemento seja contabilizado, desta forma, a ordem de declarações de elementos não importa.

Através da tag <!ATTLIST pode-se declarar os atributos de um elemento e informar se ele é requerido, ou não é necessário ou se tem um valor fixo. Para isso, após <!ATTLIST coloque o nome do elemento, o nome do atributo, o tipo de dado e um dos comandos #REQUIRED, #IMPLIED ou #FIXED.

2.1.3. XPath

XPath é uma linguagem que utiliza de expressões pra buscar e localizar informações de uma árvore XML. A linguagem desempenha um papel importante quando se usa XSLT e XPointer. Ele abre muitas possibilidades de acesso a documentos e facilita a tecnologias como o DOM e XSLT. O XML Pointer Language (XPointer) dá uma maior abrangência para XPath permitindo localizar informações em outros documentos”.

14

Tipos em XPATH são determinados pelo contexto. O operador ou função pode transformar um tipo de expressão para outra, se necessário. Por esta razão, existem regras bem definidas para determinar quais os valores e quando serão transformados em outro tipo.

A linguagem XPath é utilizada para buscar informações em um documento XML navegando através de elemento se atributos. Usando expressões que determinam caminhos para selecionar nós e atributos.

2.1.4. DOM É uma linguagem neutra para representar em memória um documento XML, permite que,

através de sua estrutura de interfaces, programas e scripts possam acessar e atualizar o conteúdo, estilo e estrutura de documentos de forma dinâmica. Existem versões do DOM para as linguagens Java, ECMAscript, Perl, dentre outras. A W3C recomenda a sua utilização mas em várias especificações não é citado.

O documento é carregado na memória como uma estrutura de árvore partida em unidades

menores derivadas de um nó. O nó é o principal tipo de dados, o que estiver abaixo dele são tipos derivados de nós. Assim, o documento pode ser processado, transformado e apresentados de volta nas aplicações que o processam.

2.1.5. SAX

SAX é uma API que provê acesso serial ao conteúdo de um documento XML, esse acesso possibilita menor gasto de memória, que é sua principal vantagem. Ao contrário do DOM, que carrega todo o documento na memória. Ele é um dos primeiros e atualmente o método mais popular para trabalhar com dados XML.

O analisador processa pedaços de dados, a cada vez que estes são processados, ele libera a corrente processada e busca mais. Este procedimento se repete até que não a mais dados ou processos.

A sua meta é fornecer uma maneira simples para processar XML utilizando menos recurso de sistema. Esse analisador é muito popular por causa de sua simplicidade e sua estrutura leve, essas qualidades foram fatores determinantes para a sua implementação em várias linguagens e, também, foi determinante para que muitos analisadores DOM forem construídos utilizando SAX.

2.2. PHP

Em 1994, surgiu como um pacote de programas CGI nomeada Personal Home Page Tools substituindo um conjunto de scripts Perl que era utilizado por Rasmus Lerdof, em desenvolvimento de sua página pessoal.

Já em 1997 foi lançado o novo pacote da linguagem com o nome de PHP/FI, com um interpretador de comandos SQL, o Forms Interpreter.

PHP é uma linguagem de programação interpretada utilizada especialmente para desenvolvimento para a Web e pode ser incorporado a um código HTML, permite a criação de páginas geradas dinamicamente por parte dos desenvolvedores.

A linguagem é extremamente modularizada de script Open Source2. Diversos módulos são criados no repositório de extensões PECL (PHP Extension Community Library) e alguns destes

2 Softwares Open Source têm o código fonte aberto podendo ser modificado por usuários que tiverem sua licença.

15

módulos são introduzidos como padrão em novas versões da linguagem. Existem versões do PHP disponíveis para os seguintes sistemas operacionais: Windows, Linux, FreeBSD, Mac OS, OS/2, AS/400, Novell Netware, RISC OS, AIX, IRIX e Solaris.

O código em PHP é executado no servidor, o cliente apenas recebe os resultados da execução um script, sem determinar como é o código fonte. É possível configurar um servidor para processar arquivos HTML como PHP, então, não haverá como usuários descobrirem qual linguagem está sendo utilizada.

2.2.1. PHP e XML

Melhorias e novas funcionalidades foram introduzidas na linguagem PHP a partir de sua versão cinco, o que ocasionou grandes avanços para a criação e utilização de Web Services e XML.

XML (eXtensible Markup Language) pode ser utilizado como um formato para intercâmbio de dados, é um padrão definido pela W3C. A linguagem PHP contém uma extensão denominada expat3, que permite analisar, mas não validar, documentos XML. Ele suporta três padrões de caracteres, também fornecido pelo PHP: US-ASCII, ISO-8859-1 e UTF-8.

2.2.2. SimpleXML

O SimpleXML é uma biblioteca em PHP que disponibiliza ferramentas para converter XML em objetos. Estes podem ser processados normalmente com seletores de propriedades e iteradores de arrays. Ela proporciona uma maneira fácil de lidar com XML e um odo intuitivo para processar documentos.

A SimpleXMLElement é a classe principal para todas as operações,os objetos referentes ela são criados utilizando a função simplexml_load_file(), ou então, a função simplexml_load_string”.

• Abaixo estão listados os métodos da classe SimpleXML e uma descrição de usas funções:

• SimpleXMLElement->addAttribute(): Adiciona um atributo à elemento SimpleXML

• SimpleXMLElement->addChild(): Adiciona um elemento filho à um nó XML

• SimpleXMLElement->asXML(): Retorna uma string XML bem formada (well-formed) baseada em um elemento SimpleXML

• SimpleXMLElement->attributes(): Identifica um atributo de um elemento

• SimpleXMLElement->children(): Encontra os nós filhos de um dado nó

• SimpleXMLElement->__construct() : Cria um novo objeto SimpleXMLElement

• SimpleXMLElement->getDocNamespaces(): Retorna um namespace declarado no documento.

• SimpleXMLElement->getName(): Pega o nome de um elemento XML.

• SimpleXMLElement->getNamespaces(): Retorna os namespaces utilizados no documento .

3 Expat: A extensão expat tem por objetivo possibilitar a análise de documentos XML.

16

• SimpleXMLElement->registerXPathNamespace(): Cria um prefixo/namespace de contexto para a próxima consulta XPath .

• SimpleXMLElement->xpath(): Executa uma consulta XPath em dados XML.

• simplexml_import_dom(): Recebe um objeto SimpleXMLElement de um nó DOM.

• simplexml_load_file(): Converte um arquivo XML em um objeto.

• simplexml_load_string(): Transforma uma string XML em objeto.

O biblioteca simpleXml torna possível que um arquivo xml seja manipulado como um objeto de maneira fácil e intuitiva.

2.2.3. DOM em PHP

A biblioteca DOM oferece a maior flexibilidade e funcionalidade para manipular um documento XML, mas também, é muito complexa de ser utilizada. A API em PHP é totalmente orientada a objetos, porém existem várias funções que podem ser referenciadas de forma não orientada, elas foram preservadas garantir a compatibilidade com versões antigas da extensão, recomenda-se não utilizá-la em scripts novos.

Abaixo, detalhamento dos métodos utilizados para tratamento de arquivos XML:

• DomAttribute->name — Retorna o nome do atributo;

• DomAttribute->set_value — Define o valor de um atributo;

• DomAttribute->specified — Verifica se o atributo é especificado;

• DomAttribute->value — Retorna o valor do atributo;

• DomDocument->add_root — Adiciona um nó raiz [obsoleto];

• DomDocument->create_attribute — Cria um novo atributo;

• DomDocument->create_cdata_section — Cria um novo nó cdata;

• DomDocument->create_comment — Cria um novo nó de comentário;

• DomDocument->create_element_ns — Cria um novo elemento associado a um namespace;

• DomDocument->create_element — Cria um novo elemento nodo;

• DomDocument->create_entity_reference — Cria uma nova entidade de referencia;

• DomDocument->create_processing_instruction — Cria num novo nó PI;

• DomDocument->create_text_node — Cria um nó texto;

• DomDocument->doctype — Retorna o tipo do documento;

• DomDocument->document_element — retorna o nodo raiz;

• DOMDocument-> dump_file - carrega a árvore interna XML em um arquivo de volta;

• DOMDocument-> dump_mem – carrega a árvore XML interna novamente em uma seqüência;

17

• DOMDocument-> get_element_by_id - Procura por um elemento com um determinado id;

• DOMDocument-> get_elements_by_tagname - Retorna array de nodos com TagName determinado no documento ou uma matriz vazia, se não for encontrado;

• DOMDocument-> html_dump_mem – carrega a árvore XML em um arquivo HTML;

• DomDocument->xinclude — Substitui XIncludes in a objeto DomDocument;

• DomDocumentType->entities - Retorna lista de entidades;

• DomDocumentType-> internal_subset - Retorna subconjunto interno;

• DomDocumentType-> name - Retorna nome do tipo de documento;

• DomDocumentType-> notations - Retorna lista de notações;

• DomDocumentType-> public_id - Retorna id do tipo de documento;

• DomDocumentType-> system_id - Retorna o sistema de identificação de tipo de documento;

• DomElement-> get_attribute_node - Retorna o nó do dado atributo;

• DomElement-> get_attribute - Retorna o valor de determinado atributo;

• DomElement-> get_elements_by_tagname – retorna os elementos por TagName;

• DomElement-> has_attribute - Controles para ver se existe um atributo no nó atual;

• DomElement->remove_attribute — Remove atributos;

• DomElement-> set_attribute_node - Adiciona novo atributo;

• DomElement-> set_attribute - Estabelece o valor de um atributo;

• DomElement-> TagName - Retorna o nome do elemento corrente;

• DomNode-> add_namespace - Adiciona uma declaração namespace para um nó;

• DomNode-> append_child - Adiciona um novo filho, após todos os outros;

• DomNode-> append_sibling - Adiciona novo irmão para um nó;

• DomNode-> atributtes - Retorna lista de atributos;

• DomNode-> child_nodes - Retorna filho de um nó ;

• DomNode-> clone_node - Clona um nó;

• DomNode-> dump_node - esvazia um único nó;

• DomNode-> first_child - Retorna primeiro filho do nó;

• DomNode-> get_content – busca o conteúdo do nodo;

• DomNode-> has_attributes - Verifica se nó possui atributos;

• DomNode-> has_child_nodes - Verifica se nó tem filhos;

18

• DomNode-> insert_before - Insere como novo nó filho;

• DomNode-> is_blank_node - Verifica se nó está em branco;

• DomNode-> last_child - Retorna último filho do nó;

• DomNode-> next_sibling - Retorna o próximo irmão do nó;

• DomNode-> node_name - Retorna nome do nó;

• DomNode-> node_type - Retorna tipo de nó;

• DomNode-> node_value - Retorna valor de um nó;

• DomNode-> owner_document - Retorna o documento pertence a este nó;

• DomNode-> parent_node - Retorna o pai do nó;

• DomNode-> prefix - Retorna prefixo do name space do nó;

• DomNode-> previous_sibling - Retorna o irmão anterior do nó;

• DomNode-> remove_child - Remove filho da lista de filhos;

• DomNode-> replace_child - Substitui um filho;

• DomNode-> replace_node – muda um nó;

• DomNode-> set_content - Define conteúdo do nodo;

• DomNode-> set_name - Define nome do nó;

• DomNode-> set_namespace - Define nomes de um nó;

• DomNode-> unlink_node - Apaga nó;

• DomProcessingInstruction-> data - Retorna os dados da PI do nó;

• DomProcessingInstruction-> target - Retorna o alvo de uma PI de um nó;

• DomXsltStylesheet-> process - Aplica a XSLT-Transformation em um Objeto DOMDocument;

• DomXsltStylesheet-> result_dump_file - descarrega o resultado de um XSLT-Transformation em um arquivo;

• DomXsltStylesheet-> result_dump_mem - descarrega o resultado de uma Transformação XSLT para uma string;

• domxml_new_doc - Cria novo documento XML vazio;

• domxml_open_file - Cria um objeto DOM a partir de um arquivo XML;

• domxml_open_mem - Cria um objeto DOM de um documento XML;

• domxml_version – Inicializa a versão da biblioteca XML;

• domxml_xmltree - Cria uma árvore de PHP objetos de um documento XML;

19

• domxml_xslt_stylesheet_doc - Cria um Objeto DomXsltStylesheet de um Objeto DOMDocument;

• domxml_xslt_stylesheet_file - Cria um objeto DomXsltStylesheet de um documento em um arquivo XSL;

• domxml_xslt_stylesheet - Cria um objeto DomXsltStylesheet de um documento XSL em uma string;

• domxml_xslt_version – Inicializa a versão XSLT da biblioteca;

• xpath_eval_expression - Avalia a XPath Location em determinada seqüência;

• xpath_eval - Avalia o caminho XPath de uma dada seqüência;

• xpath_new_context - Cria um novo contexto XPath;

• xpath_register_ns_auto - Registra o nome dado no contexto XPath passado;

• xpath_register_ns - Registra o nome dado no contexto XPath passado;

• xptr_eval - Avalia o caminho XPtr de uma dada seqüência;

• xptr_new_context - Cria um novo contexto XPath.

Logo, nota-se que a biblioteca Dom em PHP é complexa, porém, provê recursos que

tornam o manuseio de documentos XML mais fácil e flexível.

2.2.4. XML Reader

XmlReader é um analisador de buscas em XML. O leitor contém um cursor que passa pelo documento XML parando em cada nó no caminho. A biblioteca é baseada em um analisador de fluxo que se move através do documento. O analisador posiciona seu cursor sobre os diferentes nós, isso proporciona acesso a informações contidas no nó atual oferecendo vantagens adicionais às oferecidas pelo XML

Ela tem a mesma funcionalidade de um analisador SAX e pretende proporcionar transformação de dados de maneira mais rápida, porém, em PHP, normalmente não é verdade, pois o programador é o responsável pela analise e os dados serão acessados apenas quando necessário.

Abaixo, detalhamento dos métodos utilizados para tratamento de arquivos XML:

• XMLReader::close — Fecha a entrada de XMLReader .

• XMLReader::expand — Retorna uma cópia do nó atual como um objeto DOM.

• XMLReader::getAttribute — Obter o valor de um atributo chamado.

• XMLReader::getAttributeNo — Obter o valor de um atributo pelo índice.

• XMLReader::getAttributeNs — Obter o valor de um atributo por localname e URI.

• XMLReader::getParserProperty — Indica se a propriedade especificada foi definida.

20

• XMLReader::isValid — Indica se o documento analisado é válido.

• XMLReader::lookupNamespace — Busca de um namespace.

• XMLReader::moveToAttribute — Move o cursor para um atributo chamado.

• XMLReader::moveToAttributeNo — Move o cursor para um atributo do índice.

• XMLReader::moveToAttributeNs — Move o cursor para um atributo chamado.

• XMLReader::moveToElement — Posiciona o cursor sobre o elemento pai do Atributo atual.

• XMLReader::moveToFirstAttribute — Posicione o cursor sobre o primeiro atributo.

• XMLReader::moveToNextAttribute — Posicione o cursor sobre o próximo Atributo.

• XMLReader::next — Move o cursor para o próximo nó saltando todas as subárvores.

• XMLReader::open — Defina a URL contendo do XML para se analisada

• XMLReader::read — Move para o próximo nó no documento.

• XMLReader::setParserProperty — Defina ou apaga opções do analisador.

• XMLReader::setRelaxNGSchema — Defina o nome do arquivo ou para um URI RelaxNG Schema.

• XMLReader::setRelaxNGSchemaSource — Defina os dados que contêm uma RelaxNG Schema.

• XMLReader::XML — Defina os dados que contém o XML para analisar.

2.3. XSLT

XSLT é parte de linguagem de transformação XML, e possui uma recomendação desenvolvida pela W3C.

O XSL define a transformação e apresentação de um documento XML e é constituído de três partes:

• XSL Transformations (XSLT): linguagem utilizada para transformar XML; • XML Path Language (XPath): utilizada pela linguagem XSLT em forma de

expressão para acessar ou referir-se a partes de um documento XML; • XSL Formatting Objects (XSL-FO): especifica a semântica de formatação através

de um vocabulário XML.

É uma linguagem utilizada para transformar um documento XML em outro, como, por exemplo, em XHTML ou WAP. É projetada para se usada como parte do XSL, inclui um vocabulário XML para especificar formatação. Em resumo, XSL demonstra o estilo de um arquivo XML e utilizando XSLT para informar como o documento é transformado em outro documento.

21

A stylesheet is é representado por um elemento xsl:stylesheet em um documetno XML. xsl:transform é usada como sinônimo para xsl:stylesheet”.

O xsl:stylesheet pode conter os seguintes tipos de elementos:

• xsl:import

• xsl:include

• xsl:strip-space

• xsl:preserve-space

• xsl:output

• xsl:key

• xsl:decimal-format

• xsl:namespace-alias

• xsl:attribute-set

• xsl:variable

• xsl:param

• xsl:template

22

2.4. WebService

Web Services são interfaces programáticas para utilização de comunicação de uma aplicação para outra, visto que, a World Wide Web está, a cada vez mais, sendo usada para este fim.

O Web service é utilizado na integração de sistemas para a comunicação entre aplicações diferentes, possibilitando que sistemas desenvolvidos em plataformas diferentes sejam compatíveis através de componentes que permitem às aplicações enviar e receber dados em formato XML. A falta de integração de sistemas, que é um grande problema da informática, pode ser corrigido através destes componentes de maneira compreensível, reutilizável e padronizada.

A maioria dos departamentos de TI já precisou fazer uma integração de sistemas, era necessário um conjunto de ferramentas ou uma plataforma comum para as aplicações e, ainda, era controlada apenas por um programador, por isso, era uma tarefa difícil. Com isso, muito tempo e dinheiro foram perdidos.

Para ama integração ser bem sucedida é importante que a abordagem de integração não seja rigorosamente vinculada umas as outras para que ocorra a independência e reutilização de serviços.

Concluindo, o Web Services tem como base o XML, que é utilizado para envio e recebimento de dados. O XML é um formato de linguagem universal, podendo ser acessado por qualquer aplicação de plataformas distintas. Sendo assim, a integração entre sistemas pode ser feita de maneira simples e independente para que os serviços sejam reutilizados.

23

3. Implementação 3.1. Construção do arquivo XML

Este capítulo demonstra conceitos fundamentais em XML, demonstra a estrutura de um documento explicando a sintaxe que compõe um documento.

XML através utiliza de tags para estruturar dados e marcar textos em um documento. Estes, de acordo com especificações do XML, podem ser montados com variedade de elementos, por exemplo, construções sintáticas, declarações de namespaces, atributos, instruções de processamento, comentários e textos.

Informações sobre o documento são encontradas na Prolog nas seguintes declarações: uma declaração XML, qualquer quantidade de comentários, PIS, ou branco, uma declaração de tipo de documento, depois, novamente, qualquer número de comentários, PIS, ou branco. Essas declarações provêm detalhes que prepara o analisador para trabalhar com o documento XML.

Abaixo, um exemplo de uma declaração XML.

<?xml version=’1.0’ encoding=’uft8’ ?>

Abaixo seguem lista de especificações e atributos disponíveis para a declaração XML:

• Version: informa a versão do XML usada. • Encoding: Define a codificação de caracter usada no documento. • Standalone: Informa para o analisador se existem quaisquer declarações fora do documento.

Através da declaração de tipo do documento (DOCTYPE) apresenta-se um DTD, podendo ser um subconjunto interno e/ou externo. O subconjunto interno mostra as declarações contidas no DOCTYPE, já o externo, inclui declarações de uma fonte externa. Para o identificador DTD são disponibilizados dois métodos para identificação: o sistema específico e o publico. Utiliza-se a palavra-chave SYSTEM seguido por um caminho ou URL de diretórios, entre aspas.

Abaixo, um exemplo de uma declaração de tipo de documento:

<!DOCTYPE dados SYSTEM ‘xml-resources/dtds/dados.dtd [

]>

Uma entidade, ENTITY, pode ser entendida como um trecho de código que pode ser reutilizado a qualquer momento no documento XML, porém, é declarado anteriormente tendo um nome como referência.

Abaixo, um exemplo de uma declaração de entidade:

<!ENTITY meunome=’Wellington Gomes de Vasconcelos’>

O corpo do documento XML é formado pelo documento elemento e de seu conteúdo, onde, pode ser um único elemento vazio. Também pode ser chamado de documento árvore, que é assim que os elementos estão dispostos.

O documento elemento está demonstrado na figura 1 e no exemplo abaixo:

<funcionarios>

24

<funcionario cpf=’123.456.789-10’> <nome>João da Silva</nome> <cargo>Analista de Sistemas</cargo> <salario moeda=’real’>2500,00</salario> <contato> <email>joao.silva@gmail.com</email> <fone>3133330000</fone> </contato> </funcionario> </funcionarios>

Um elemento, como <salario moeda=’real’>2500,00</salario>, por exemplo, pode conter atributos que o descreve e também armazenam valores. Ele pode conter também elementos filhos ou pode ser um elemento vazio.

3.2. Construção da estrutura PHP para acesso ao arquivo XML

A biblioteca SimpleXML disponibiliza o acesso aos elementos de forma direta, quando especificados pelo nome, reduzido o tempo de codificação e aumentando o desempenho. Utilizando a Extensão DOM, isso somente ocorre utilizando uma expressão XPATH.

Para converter um documento XML em objeto em PHP utilizam-se dois métodos. A biblioteca SimpleXML disponibiliza o método simplexml_load_file() e a extensão DOM, o método load().

Abaixo, um exemplo de como acessar o elemento nome utilizando SimpleXML:

<? php $funcionarios = simplexml_load_file("dados.xml"); /* acessando o elemento filho funcionario de funcionarios */ $funcionario = $funcionarios->funcionario[0]; /* acessando o elemento filho nome de funcionario */ $nome = $funcionario->nome; ?>

Abaixo, um exemplo de como acessar o elemento nome utilizando a extensão DOM:

<?php $dom = new DOMDocument(); $dom->load('dados.xml'); $funcionarios = $dom->documentElement; foreach($funcionarios->childNodes as $node) { if ($node->nodeName == "funcionario") { foreach($node->childNodes as $child) { if ($child->nodeName == "nome") { $node = $child; break 2; } } } } ?>

25

Abaixo, um exemplo de como acessar os atributos do elemento funcionário utilizando SimpleXML :

<?php if ($node) { $nome = $node; } $funcionarios = simplexml_load_file('dados.xml'); foreach($funcionarios->funcionario[0]->attributes() AS $attribute) {

$att = dom_import_simplexml($attribute); echo $att->nodeName.": ";

echo $attribute."<br>"; } ?>

Abaixo, um exemplo de como acessar os atributos do elemento funcionário utilizando a extensão DOM:

<?php $dom = new DOMDocument(); $dom->load('dados.xml'); $funcionarios = $dom->documentElement; foreach($funcionarios->childNodes as $node) { if ($node->nodeName == "funcionario") { $attributes = $node->attributes; foreach($attributes as $attr) { echo $attr->nodeName.":"; echo $attr->nodeValue."<br>"; } } } ?>

Nota-se que para buscar valores de nós e atributos a biblioteca SimpleXML provê acesso mais rápido e simples quando comparado à biblioteca DOM em PHP.

Abaixo, um exemplo de como acessar elementos e atributos utilizando XPath através da extensão DOM:

<?php $dom = new DOMDocument(); $dom->load('dados.xml'); $domxpath = new DOMXPath($dom); $lista = $domxpath->query("/funcionarios/funcionario/nome"); $nomeFuncionario = $lista->item(0)->nodeValue; echo "Nome: $ nomeFuncionario "; ?>

O método query() é utilizado para recuperar dados de uma árvore usando expressões XPATH retornado sempre um objeto DOMNodelist.

3.3. Construção da estrutura PHP para gravação em um arquivo XML

26

O método save(), da classe DOMDocument(), recebe um parâmetro que informa a URI na qual será gravada a alteração.

Para gravar um novo elemento no arquivo, é necessário que ele seja criado em um objeto DOMElement e inseri-lo em um outro do mesmo tipo através do método appendChild(). O método setAtributte(), recebe o nome e o valor do atributo e o insere no elemento.

Abaixo, um exemplo de como inserir um nó celular na lista de contatos do primeiro funcionário:

<?php $dom = new DOMDocument(); $dom->load('dados.xml'); $domxpath = new DOMXPath($dom); $items = $domxpath->query("/funcionarios/funcionario[1]/contatos"); $contatos = $items->item(0); try { $celular = new DOMElement("celular", "87654321"); $cel = $contatos->appendChild($celular); $cel->setAttribute("ddd", "31"); $dom->saveXML(); } catch (DOMException $e) { var_dump($e); } $dom->formatOutput = TRUE; print $dom->save('dados.xml'); ?>

A remoção de um elemento no arquivo é feita através do método removeChild() que recebe como parâmetro um objeto DOMElement indicando qual elemento será removido. Abaixo, um exemplo para remover o elemento celular da lista de contatos do primeiro funcionário:

<?php $dom = new DOMDocument(); $dom->load('dados.xml'); $domxpath = new DOMXPath($dom); $items = $domxpath->query("/funcionarios/funcionario[1]/contatos"); $contatos = $items->item(0); $celular = $contatos->getElementsByTagName("celular")->item(0); echo $celular->nodeValue; $contatos->removeChild($celular); $dom->saveXML(); $dom->formatOutput = TRUE;

27

print $dom->save('dados.xml'); $domxpath = new DOMXPath($dom); $items = $domxpath->query("/funcionarios/funcionario[1]/contatos"); $contatos = $items->item(0); if ($contatos->hasChildNodes()) { $children = $contatos->childNodes; foreach($children as $node) { echo $node->nodeValue."<br>"; } } ?>

28

4. Conclusão

Com XML é possível armazenar dados e recuperá-los, garantir a integridade do documento e ainda formatá-lo. Porém, é necessário ficar atento às limitações que a meta-linguagem possui.

O PHP, em sua versão de número 4, continha muitas deficiências para tratamento de XML. Seus idealizadores se reorganizaram e reescreveram as extensões para tratamento de XML e proporcionaram maior funcionalidade e flexibilidade. Então, em sua versão cinco, possui uma grande estrutura para tratar documentos em XML.

Web Services são serviços criados, principalmente para integração de sistemas heterogêneos. Tem como base a utilização de XML para acesso e gravação de dados provenientes destes sistemas de maneira distribuída.

Neste trabalho estão demonstradas formas de criação e tratamento de arquivos XML, além de como utilizar o conteúdo desses documentos através de uma linguagem de programação para web. Com isso, concluímos que, a linguagem PHP possibilita o acesso fácil e rápido a documentos XML através uma estrutura com extensões que possibilitam a criação de serviços web para integração de sistemas.

29

5. Bibliografia

W3SCHOOLS. Introduction to XML. Disponível em: <http://www.w3schools.com/xml/xml_whatis.asp>. Acesso em: 24 de março de 2009.

W3SCHOOLS. XPath Tutorial. Disponível em: <http://www.w3schools.com/xpath/default.asp>. Acesso em: 24 de março de 2009.

W3C. Document Object Model (DOM). Disponível em: < http://www.w3.org/DOM/>. Acesso em: 24 de março de 2009.

W3C. Web Services Activity.Disponível em: <http://www.w3.org/Style/XSL/>. Acesso em: 27 de março de 2009.

W3C. The Extensible Stylesheet Language Family (XSL). Disponível em: <http://www.w3.org/2002/ws/>. Acesso em: 27 de março de 2009.

WIKIPEDIA.XML Disponível em: <http://www.wikipedia.com/xml>. Acesso em: 27 de março de 2009.

PHP.NET. MANUAL PHP. Disponível em: < http://www.php.net/manual/pt_BR/>. Acesso em: 04 de Abril de 2009.

RAY, Erik T. Learning XML. 2ª Edição. Local de publicação: O'Reilly & Associates, Setembro de 2003. 416 páginas.

RICHARDS, Robert. Pro PHP XML and Web Services. 1ª Edição. Local de publicação: Nova York, Estados Unidos da América: Apress, fevereiro de 2006. 936 páginas.

SKONNARD, Aaron. Essential XML Quick Reference. 1ª Edição. Local de publicação: Boston, Estados Unidos da América: Pearson Education, fevereiro de 2003. 432 páginas.

30