Tutorial - Básico Sobre Xml

O XML é uma linguagem de marcação como o HTML. Sua diferença é utilizar uma linguagem própria. Ao invés de colocarmos <table border=0 cellspacing=1>, podemos criar um "tag" chamado <tabela>, que terá estas propriedades.

Ao invés de chamarmos de tag, vamos chamar de nós (node). Comparando ao HTML, o nó <tr> seria um nó filho do <table>. Podemos dizer o mesmo de <td> em relação a <tr>. Isto será muito importante adiante. Aqui vão algumas regras de XML:

- Sempre coloque o tag de xml no início do arquivo xml:

<?xml version="1.0"?>

- Sempre feche os nós em ordem :

<a><b></b></a>.

- Há diferença entre nomes em maiúsculas e minúsculas.

<teste><TESTE></TESTE></teste>

Ele diferencia os dois nós. Também não podemos alterar a formatação do nome, pois ele não o reconhecerá :

<teste></Teste>

(acusará erro de nó não fechado)

- Os nós não podem ser puramente numéricos, com espaço ou com alfanuméricos. E també, pessoalmente, não aconselho a usar , verão o porque.

- Todo arquivo XML deverá ter um nó mãe.

- Todos os nós devem ser fechados. Caso um nó seja "único", como o <br>, ele deverá ter a barra no fim, <br/>.

- Todos os atributos dentro do nó (como o border no table) devem ter seu valor entre aspas : <teste valor="25">

Aqui está o nosso primeiro arquivo teste, vamos chamá-lo de edicao.xml:

Arquivo edicao.xml

<?xml version="1.0"?>
<edicao>
<artigo>
<artigo_id>1</artigo_id>
<titulo>Primeiro arquivo de XML</titulo>
</artigo>
<artigo>
<artigo_id>2</artigo_id>
<titulo>Bla Bla Bla</titulo>
</artigo>
</edicao>

Perceberam a semelhança dele a uma estrutura de banco de dados? Imagine num banco de dados a tabela edição, onde chamaremos os artigos cadastrados para um Recordset chamado de artigo, onde virão as colunas artigo_id e titulo. Qualquer semelhança não é mera coincidência. O SQL Server 2000 já gera automaticamente um arquivo XML se solicitado.

Agora que já temos oção do que é o xml, vamos pensar, para que diabos eu vou querer usar isso? Vamos a algumas opções:

1)Diferentemente de banco de dados, onde precisamos de programas para nos conectar e ver ou alterar seu conteúdo, temos um arquivo com toda a "tabela", ou até com todo o banco de dados. Podemos descê-lo facilmente da internet e visualizá-lo nos navegadores (criem este arquivo edicao.xml e vejam-no no browser, mesmo que não tenhamos deixado ele tão bonito quanto aparece, os browsers nos ajudam

2)Somente montamos nossos bancos de dados pelos mesmos programas (tudo para gastarmos mais!). Para montar um XML, só temos que ler alguns livros ou tutoriais e já temos tudo! E visualizamos de uma maneira bem mais clara do que um banco de dados.

3)Se vamos fazer algo que tenha pouco conteúdo, ou estamos enviando para o usuário uma pequena parte de nosso banco de dados, ao invés de enviarmos o HTML pronto, podemos enviar o arquivo XML , de pouquíssimos kB, e deixar com que o usuário possa até mexer em sua visualização (como por simples scripts, alterar o tamanho da fonte, ou enviar todas as páginas de uma paginação de uma vez, agilizando a visualização).

4)Em aplicações maiores, como um site de comércio eletrônico com o banco de dados SQL Server tendo que enviar as compras do dia para um banco de dados Oracle interno da empresa, temos que fazer complexas programações para converter os formatos. SE ambos os bancos de dados já suportam XML, porque não somente gerar um ou mais arquivos XML e atualizá-los no outro banco? Programação complexa substituída por umas dez linhas de código? Ótimo!!!

Acho que agora já estão com água na boca de poder fazer isso. Alguns já devem estar perguntando?

Mas no banco de dados eu posso definir os formatos dos campos ? Também posso fazer isso no XML?

Posso colocar estilo neste XML para o usuário?

Posso misturar tudo, XML, HTML, CSS e Javascript?

Vamos por partes, mas sim, você pode fazer tudo isso. Vamos primeiramente ver como aplicar estilos (webdesigners, fiquem tranquilos, não será isso que fará vocês terem que esquecer XML)

Como todo programador que já uma tabela no banco de dados, sabe que temos que dizer qual o formato de cada campo. O XML também permite que faça isso.

Existem dois principais formatos para fazer isso: o DTD e o Schema. O DTD é o formato feito pelo w3c, o mesmo que regulariza o HTML. Ele apresenta certas limitações, a que mais senti foi não ter a mesma forma de XML. Um DTD de exemplo, para nosso arquivo edição, está abaixo.

edicao.xml (com DTD)

<?xml version="1.0"?>
<!DOCTYPE edicao[
<!ELEMENT edicao (artigo+)>
<!ELEMENT artigo (artigo_id, titulo)>
<!ELEMENT artigo_id (#PCDATA)>
<!ELEMENT titulo (#PCDATA)>
]>
<edicao>
<artigo>
<artigo_id>1</artigo_id>
<titulo>Primeiro arquivo de XML</titulo>
</artigo>
<artigo>
<artigo_id>2</artigo_id>
<titulo>Bla Bla Bla</titulo>
</artigo>
</edicao>

Eu não o utilizo, por isso não o explicarei neste tutorial. Quem se interessar mais pelo formato, veja no próprio site www.w3c.com.

Aprofundei meus estudos em Schema por trabalhar principalmente em servidores Microsoft. As versões de interpretadores de XML da Microsoft dão suporte a muitas operações muito úteis. Comecei utilizando DTD, mas ao não conseguir (provavelmente por não saber mesmo, não encontrei uma informaçào boa e clara em lugar nenhum) sobre ordenação de valores XML, passei para os Schemas.

Schemas nada mais é do que uma definição por um padrão XML previamente estabelecido sobre o conteúdo do arquivo. Pode estar no próprio arquivo XML ou em um separado. Para usarmos a definição, utilizamos o chamado namespace, que é um chamado de padrão universal. Para chamar o schema, utilizaremos xmlns="x-schema:schema_edicao.xml", que é o arquivo que tem o schema.

No schema, utilizaremos o namespace xmlns:dt="urn:schemas-microsoft-com:datatypes", que nos fornece uma gama de tipos de elementos. Sofri muito para entender os namespaces diferentes para cada ocasião, vamos vendo isso conforme o andar do tutorial. Temos um tipo de namespace para cada utilização que queremos, como verão.

Para definir um nó, usaremos o tag ElementType. Ele tem os atributos name, com o nome do nó, e dt:type, onde colocaremos o tipo do nó. Os tipos fornecidos por este namespace são : boolean, char, date( só a data), dateTime (data e hora), float, int, string, number e time. Creio que os nomes dizem por si. Existem muitos outros, mas estes são os principais. Para ver outros, veja no site da Microsoft as especificações dos datatypes.

Também podemos ter os atributos:

-content: define o que o elemento pode ter. Seus possíveis valores são : empty (não terá valor), textOnly(só pode ter texto), eltOnly(somente elementos especificados) e mixed (qualquer um)

-order : define a ordem. Pode ter os valores : one (somente permite que o n;ó tenha UM único filho, mesmo que possa ter mais de um possivel, é como a clausula ou, terá um ou outro, mas somente um), seq (os elementos terão que aparecer na ordem específica) ou many (em qualquer ordem)

-model: se tiver o valor open, ele pode ter nós filhos além dos declarados, se closed, somente os declarados.

Além do ElementType, temos o tag element, para definir os nós filhos do elemento. Terá o nome, claro,e pode ter outros dois atributos:

-minOccurs: se for 0, o elemento especificado não é obrigatório, se for 1, tem que aparecer no mínimo uma vez

-maxOccurs: se for 1, o elemento deve aparecer no máximo uma vez,se for *, quantas vezes quiser.

Também temos que declarar os atributos de cada nó, com o tag AttributeType. Seus atributos são:

-name

-default : seu valor padrão

-dt:type : seu tipo de dado, os mesmos possíveis dos elementos.

-dt:values: com os possíveis valores do atributo (opcional)

-required: se com o valor yes, obrigatório (opcional)

Para o associarmos ao nó, o colocamos no tag ElementType com o tag attribute, que pode ter os seguintes atributos (esta palavra está começando a ficar repetitiva!):

-default : seu valor padrão

-type : os mesmo que os elementos

-required :exatamente o mesmo que o AttributeType

Meio confuso, né? Só com a prática isso fica bem entendido. Vamos fazer um schema para nosso exemplo então. Temos o nó edicao, que terá o nó artigo. Este, por sua vez, terá seus filhos artigo_id, que queremos que seja sempre um número, e titulo, que pode ser qualquer coisa. Não nos importamos com a ordem, não é necessário que exista um artigo, mas pdoem haver inúmeros. Só deveremos ter um id e um titulo para cada artigo, e estes deverào ser obrigatórios.

Então, ficaria assim *utilizarei o tag description para comentar, mais uma vantagem do schema):

schema_edicao.xml

<Schema name="valida"
xmlns="urn:schemas-microsoft-com:xml-data"
xmlns:dt="urn:schemas-microsoft-com:datatypes">
<ElementType name="artigo_id" dt:type="int" />
<ElementType name="titulo" dt:type="string" />
<ElementType name="artigo">
<description>
Nó com o id e titulo do artigo
</description>
<element type="artigo_id" minOccurs="1" maxOccurs="1"/>
<element type="titulo" minOccurs="1" maxOccurs="1"/>
</ElementType>
<ElementType name="edicao">
<description>
Nó mãe com todos os artigos da edição
</description>
<element type="artigo" minOccurs="1" maxOccurs="1"/>
</ElementType>
</Schema>

E no arquivo edicao.xml, colocaremos o nó edicao assim : <edicao xmlns="x-schema:schema_edicao.xml">.

Podemos usar mais de um schema por arquivo, mas lembre-se que os schemas de um nó se propagam por todos os seus filhos. Se colocassemos o schema no próprio arquivo, colocaríamos #nome ao invés de linkar ao arquivo.

Agora, vamos ver como colocaremos estilos no xml.

Esta parte vai atender a bastante gente, creio eu, a maior parte que está querendo saber como mostrar os arquivos XML num browser de uma forma mais amigável.

Não sei se alguém já percebeu que, pelo CSS (style), podemos criar tags. Ao inves de criarmos uma classe, como .titulo, podiamos colocar titulo{font-family.....}, que isto seria um tag a ser utilizado no HTML com todas as propriedades especificadas no style.

Mas não é esta a maneira certa de se transformar XML. Devemos usar XSL (não misturar com a extensão do Excel!). Como este é um dos maiores assuntos a ser abordado, deveria estar atualizando com continuações depois, fiquem ligados.

Assim como CSS, colocamos no próprio arquivo ou em um separado. Seus comandos mais básicos são:

- template : com ele, decidimos qual o nó a ser transformado. Seu atributo é match, onde colocamos o nó, com seu caminho. Em todas as instruções em xsl, teremos que colocar o caminho do nó, similarmente ao que fazemos com arquivos. Os principais símbolos para os caminhos são:

/ para um filho do nó

// seleciona todos os descendentes do nó

Ex : edicao//artigo (seleciona todos os artigos em edicao)

* para qualquer elemento

Ex : edicao//*

. é para o nó atual

Ex:./artigo_id (se já estivéssemos tratanto o nó artigo)

.. assim como no DOS sobe um nível (um nó acima)

Ex: ../artigo (se estivéssemos analisando o artigo_id ou o titulo)

@palavra é para se referenciar a um atributo

| é o OR do SQL, a função ou.

Ex : edicao/artigo/titulo | edicao/artigo/artigo_id

[funcao] serve para filtrarmos informação, exatamente como um Where do SQL (estamos chegando em algo que já começa a apetecer os programadores, não?)

As sintaxes dentro das funções são simples, lembrando ASP e PErl, e o melhor, suportando as duas! Veja alguns exemplos (creio que o resto concluirão tranquilamente)

- and ou $and$ ou && : função e

- not() ou $not$ :função de negação

-= ou $eq$ : igualdade

-!= ou $ne$ : diferente

-<= ou $le$ : menor ou igual a

-> ou $gt$ : maior que

E, no fim desta introdução, temos o tag value-of , com o atributo select, onde estará o nó a ser impresso. Veja o exemplo abaixo:

edicao.xsl

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl"
xmlns="http://www.w3.org/TR/REC-html40">
<xsl:template match="/">
<html>
<body>
<table border="0">
<tr>
<td>
<xsl:value-of select="edicao/artigo/artigo_id"/>
</td>
</tr>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>

Coloquem em seus edicao.xml, logo após a primeira linha, onde colocamos a definicao de xml, a seguinte linha :

<?xml-stylesheet type="text/xsl" href="edicao.xsl"?>

Não é exatamente igual ao CSS tradicional? Pois é. Então vamos continuar notando algumas coisas.

- Os namespaces no xsl:stylesheet. O primeiro é obrigatório quase sempre, para dar as informações necessárias para a interpretação dos elementos. O segundo foi usado para já trazer definições sobre datatypes, que usaremos depois. Poderiamos colocar outros namespaces, como vamos ver depois.

- Vocês fizeram um teste? Devem ter percebido que somente uma linha apareceu na tela, a primeira. Isso é porque não colocamos nenhuma instrução de loop no exemplo. Isso é o próximo ítem que vamos ver, a dita programação de XSL.

Antes que me esqueça de colocar (como já estava), uma pequena explicação de como colocar e criar templates sem ser um loop pelo arquivo ou por um nó:

Utilizamos para isso o tag <xsl:apply-templates>, onde teríamos os atributos:

-order-by: já explicado (quase sempre são as mesmas funções, isto facilita bastante)

-select : idem

Vamos então as estruturas de controle. Para quem não sabe o que é isso (como eu não sabia, acabei de roubar a frase de um livro), são as funções de condicionais e loop.

1)<xsl:for-each> : É a instrução que precisávamos para consertar o XSL que fizemos no último exemplo. Tem o mesmo atributo select que vários outros comandos XSL, mas também tem o atributo order-by, este muito valioso. Ele nos permite ordenar por um nó (alguém teve um deja-vú com o ORDER BY do SQL?). Para termos a ordenação decrescente, é só colocar um sinal de menos na frente do ná. Veja como ficaria então o exemplo:

edicao.xsl

<?xml version="1.0" encoding="UTF-8"?>

<xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl"

xmlns="http://www.w3.org/TR/REC-html40">

<xsl:template match="/">

<html>

<body>

<table border="0">

<xsl:for-each select="edicao/artigo" order-by="-artigo_id">

<tr>

<td>

<xsl:value-of select="artigo_id"/>

</td>

<td>

<xsl:value-of select="titulo"/>

</td>

</tr>

</xsl:for-each>

</table>

</body>

</html>

</xsl:template>

</xsl:stylesheet>

2)<xsl:if> : É o condicional se. Podemos colocar como atributos:

- expr: onde colocaríamos o noem de uma função criada na linguagem de script (nunca utilizei, pra falar a verdade)

-language: o nome da linguagem de script

-test: só utilizo esta, colocamos uma função de teste para ser verificada, como

<xsl:if test="titulo[.=Paulo]">. Só atento ao seguinte : se não for colocar dentro dos colchetes o nome do nó, coloque o ponto, e não coloque aspas em nenhum lugar, senão o XML acusará erro.

3)<xsl:when> : Também um condicional, mas este usado para várias opções. Ele é normalmente usado em conjunto com os tags : xsl:choose e xsl:otherwise, como mostro nas linhas abaixo.

edicao.xsl

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl"
xmlns="http://www.w3.org/TR/REC-html40">
<xsl:template match="/">
<html>
<body>
<table border="0">
<xsl:for-each select="edicao/artigo" order-by="-artigo_id">
<tr>
<td>
<xsl:value-of select="artigo_id"/>
</td>
<td>

<xsl:choose>
<xsl:when test="titulo[.='Oi']">
Oi pra você também
</xsl:when>
<xsl:choose>
<xsl:when test="titulo[.='Tchau']">
Tchau pra você também
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="titulo"/>
</xsl:otherwise>
</xsl:choose>

</td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>

4)<xsl:script> : O que deveria ser o mais usado, mas pra falar a verdade nunca vi usarem (acho que, como eu, ninguém conseguiu fazê-lo funcionar direito). Mas vou tentar explicar como era para ser. No tag stylesheet, coloque também language="Linguagem que Usará". No ponto que quer que o script rode, coloque <xsl:eval>Chamada da função()</xsl:eval>.

Para colocar a função você teria que colocá-la assim:

<xsl:script language="Linguagem que Usará"> <![CDATA[

aqui colocaria sua função

]]>

</xsl:script>

E pelo que entendi, se você tem uma função de dHTML, ou seja, no OnClick, OnLoad, ou algo assim, teria que a colocar assim:

<script LANGUAGE="Linguagem que Usará"><xsl:comment><![CDATA[

aqui colocaria a funcao

]]></xsl:comment></SCRIPT>

Créditos: Totalmente para Paulo Marinho, do Crieseuwebsite.com.

Parabéns pelo conteúdo Rafax.

XML parece ser uma linguagem muito fácil.

Acredito que já também, uma linguagem ultrapassada.

Mas que seja de "bomproveito."

Abraços!

Hiho!

uai, não sabia que xml tinha tantos comandos,

muito bom e facil =o

cya ^^

Com o tempo nois acostuma a mecher, e depois nada mais será problema

Rafax,

Creio que nesta altura do campeonato seria importante você trazer matérias, conteúdo relacionado ao SQL/SQLite.

O XML vai deixar de existir em otservs.

Assim a gente fica com matérias atualizadas e entendendo sobre o assunto.

Um abraço,

Under.

O xml eh difícil, no começo.

Tenho um amigo, que quer mexer com isso, e não sabe..

Jah recomendei o tutorial à ele.

Muito bom, apesar de ser longo e extenso, não tenho cabeça pra isso..

A única coisa que eu consigo fazer direito, e terminar eh Mappear..

Mas msm assim ta valendo.

Abraço.

@Under

Realmente cara, XML parece que é dos anos 70

@Topic

Muito Bom Cara!

Mas como o Under falou, XML, não vai ser usada mais em OTServ.

Enquanto isso não acontece, podemos tirar grande proveito deste tutorial!

Bom mas não podemos nos esquecer, que XML tem outras funções, não só em OTserv.

kra, não entendi quase nada do xml e ainda n sei fzer, algume me ajuda ae, me add no msn e me ajem lah plx

iraphael1@hotmail.com

Ja Sabia de Lagumas Partes Menos <!DOCTYPE> desse jeito:

<!DOCTYPE edicao[

<!ELEMENT edicao (artigo+)>

<!ELEMENT artigo (artigo_id, titulo)>

<!ELEMENT artigo_id (#PCDATA)>

<!ELEMENT titulo (#PCDATA)>

Muito bom realmente bem explicado so poderia ter sido um pouco mais basico

Por exemplo ngn que le pela primeira vez sabe o que é um "Nó" na linguagem XML

Bom tuto...

Porém pra mim é mtu complicado hehe

prefiro LUA

Tehh~~

Bom Tutorial...