XML e PHP para integração de sistemas

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
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
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 ‘ ’, 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
$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
$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
$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
$celular = $contatos->getElementsByTagName("celular")->item(0);
echo $celular->nodeValue;
$contatos->removeChild($celular);
$dom->saveXML();
$dom->formatOutput = TRUE;
27

print $dom->save('dados.xml');
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

XML e PHP para integração de sistemas

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a XML e PHP para integração de sistemas

Semelhante a XML e PHP para integração de sistemas (20)

XML e PHP para integração de sistemas