Introducción
XML (Lenguaje de Marcas eXtensible), forma parte de SGML (Lenguaje
de Marcas Generalizado eStandar). Aún así, no es necesario saber nada
de SGML para utilizar XML. El lenguaje XML define una estructura de
documentos que pueden ser leídos por personas y por ordenadores.
El camino más sencillo para comprender XML es pensar en cómo se utilizan
los documentos HTML. Estos documentos están estructurados y funcionan
con etiquetas y atributos. Las etiquetas van encerradas entre
símbolos de mayor y menor (<b>) y deben cerrarse de la misma forma
añadiendo un símbolo de barra invertida (</b>). Los documentos HTML
tienen una ortografía específica, es decir, unas reglas que definen la forma
correcta de estructurar un documento; por ejemplo, la etiqueta <BODY>
debe ir siempre después de </HEAD> o, sino existe ésta, de <HTML>.
Además,HTML contiene un diccionario cerrado de etiquetas que definen el
lenguaje y no podemos utilizar otras que no estén especificadas.
En cambio, XML no tiene un diccionario de etiquetas. Las etiquetas que
aparecen son las que nosotros mismos creamos. La única norma que tenemos
que seguir es que toda etiqueta de inicio (<coche >) debe tener una
etiqueta de fin (</coche>) .
El documento siguiente muestra un archivo XML bien formado:
<?xml version="1.0" ?>
<biblioteca>
<tema id="informática">
<libro>
<titulo>Manual Imprescindible de PHP 5</titulo>
<autor>Luis Miguel Cabezas Granado</autor>
</libro>
<libro>
<titulo>Delphi 7</titulo>
<autor>Marco Cantu</autor>
</libro>
<libro>
<titulo>Delphi 6 y Kylix</titulo>
<autor>Francisco Charte Ojeda</autor>
</libro>
</tema>
</biblioteca>
Como puede ver, la estructura del documento es muy similar a la de una
página Web. Está formado por etiquetas y atributos, cuya definición puede
inventarse sobre la marcha, es decir, las etiquetas < l i b r o > , < t i t u l o > o < s e c c i o n > podrían tener un nombre totalmente diferente, pero
no así en HTML, que está obligado a mantener el lenguaje definido.
Un documento XML está obligado a cumplir ciertas normas, que permiten
definir un texto bien formado:
• Debe tener un único elemento raíz. Sólo puede haber un par de etiquetas
que diferencien el inicio y el final del documento, como en
HTML, donde se utiliza <HTML> y </HTML>.
• Los elementos deben ser hereditarios. La estructura < A x B x / B > < /
A> se permite, pero no la siguiente < A x B x / A x / B > . En la primera
forma la etiqueta <A> envuelve a la etiqueta <B>, que es la forma correcta
de escribir un documento XML. HTML, sin embargo, permite la
segunda forma de componer un documento. <A HREF="index.php">
<Bx/Ax/B>.
• Todos los elementos tienen que tener una etiqueta de cierre. La pareja
<titulo></titulo es correcta. HTML permite etiquetas sin cerrar como
<B> o <LI>.
• Los elementos pueden tener entre las dos etiquetas cualquier tipo de
contenido, como <titulo>Manual imprescindible de PHP 5</titulo>.
• Los caracteres &, <, >, las comillas simples y las comillas dobles están
prohibidas como contenido y deben utilizarse símbolos de escape para
utilizarlas.
SAX, DOM y SimpleXML
Lo primero que tenemos que hacer antes de leer archivos XML es conocer
las tres formas existentes, con sus ventajas e inconvenientes:
• SAX: Es más ligero y fácil de aprender; trata los archivos XML como
un flujo de datos que se leen poco a poco.
• DOM: Lee el fichero completo y crea un objeto en memoria. Permite
crear archivos desde cero.
• SimpleXML: Es el más sencillo de utilizar. Los elementos se pueden
leer con un simple f o r e a c h .
SAX
Se utiliza para parsear elementos XML. Está basado en eventos, lo que significa
que el parse hace llamadas a determinadas funciones, dependiendo
de los elementos que examina.
Los eventos de SAX son proporcionados por PHP en forma de función. Al
parsear se reconocen piezas de XML, como etiquetas de inicio o fin, datos
o entidades externas y cada una de estas piezas hace una llamada a un
evento. El procedimiento para parsear un archivo XML con SAX debe seguir
los siguientes pasos:
• Determinar qué clase de eventos queremos manejar.
• Escribir una función que maneje cada evento. Es muy común escribir
una función para manejar los datos y las etiquetas de inicio y de fin.
• Crear el parse usando la función x m l _ p a r s e r _ c r e a t e () y hacer la
llamada con xml_parse () .
• Liberar la memoria usada con la función x m l _ p a r s e r _ f r e e ().
Hemos creado un objeto para leer archivos XML. En principio no hace gran
cosa; tan solo examina las etiquetas de inicio y fin y las imprime en pantalla,
pero con esto bastará para aprender la peculiar estructura de un parse SAX.
<?php
class xml
{
function construct($fichero_xml)
{
$this->fichero_xml = $fichero_xml;
$this->xml_parser=xml_parser_create();
//Puesto que el parse lo creamos desde un objeto debemos
registrar la incidencia con xml_set_object
xml_set_obj ect($this~ >xml_parser,$this) ;
//Funciones de callback para manejar XML mediante SAX
xml_set_element_handler($this->xml_parser,"elemento_
inicio","elemento_fin");
if (!($fp = fopen($this->fichero_xml,"r")))
{
die ("Error de Entrada y Salida");
}
while ($datos = fread($fp,filesize($this->fichero_xml)))
{
if (!xml_parse($this->xml_parser,$datos,
feof($fp)))
{
die ("Fallo en el XML");
xml_error_string(xml_get_error_
code($this->xml_parser));
}
xml_parser_free($this->xml_parser);
}
function elemento_inicio ($parser,$nombre,$atributos)
echo "$nombre<br>";
function elemento_fin ( $parser,$nombre)
echo "/$nombre<br>";
}
$biblioteca = new xml("biblioteca.xml");
?>
Si guarda la clase en un archivo llamado c l a s e _ x m l . php podrá usarla
en sus proyectos tan sólo con instanciar el objeto. Si comienza por el constructor,
verá que el parámetro que recibe es el archivo que quiere parsear.
Debe crear el parse con la funciónxml_parse_create () y después
registrarlo en PHP como un objeto mediante la función x m l _ s e t _ obj
e c t () . Si crea un parse fuera de la estructura de un objeto no hará falta
hacer la llamada a la función anterior.
La función x m l _ s e t _ h a n d l e r () indica al parse que los eventos encargados
de encontrar las etiquetas de inicio y de fin serán manejadas con las
funciones que se pasan como parámetro. En este c a s o e l e m e n t o _ i n i c i o
( ) se ejecutará cada vez que se encuentre una etiqueta de inicio y
elemento_f in {) cuando se encuentre la etiqueta de cierre.
La última parte del constructor lee el archivo pasado como argumento y
analiza los datos a través de la función xml_parse ( ) , que inicia la secuencia
de análisis. Si ejecuta una instancia de la clase, comprobará que el
navegador muestra todas las etiquetas de inicio y de fin con una rigurosa
herencia. La figura 14.2 muestra las etiquetas leídas del archivo XML.
Para poder ver los datos tiene que añadir una nueva función que maneje
ese evento. La funciónxml_set_character_data__handler () permite
manejar el evento que se dispara cada vez que se encuentra un dato entre
dos etiquetas. Esta función tendrá que añadirla al constructor después del
método que maneja los eventos de etiquetas:
xml_set_character_data_handler($this->xml_parser,"datos");
Además de esto, tendrá que incluir una nueva función, que se encargará
de mostrar los datos:
function datos($parser,$valor)
{
echo " $v9lor<br>";
}
Nota:
Los eventos añadidos deben ¡levar Jos argumentos necesarios para
recuperar los datos. Cada vez que cree un par se del tipo SAX las
funciones tienen que tener los parámetros que indicamos en nuestra
clase de ejemplo.
Después de comprobar el funcionamiento de la clase, puede modificarla
para que haga algo realmente útil, como mostrar ordenadamente los datos
del fichero. Las funciones de la clase pueden quedar de esta forma:
function elemento_inicio ($parser,$nombre,$atributos)
{
switch($nombre) {
case "TEMA":
$tema = $atri.butos [" ID" ] •
echo "Tema $t.ema<br>" ;
break;
case "TITULO":
echo "<b>";
break;
case "AUTOR":
echo " - " ;
break;
}
}
function elemento_fin ($parser,$nombre)
{
switch($nombre) {
case "TITULO":
echo "</b>";
break;
case "AUTOR":
echo " <br>";
break;
}
}
function datos($parser,$valor)
{
echo " $valor" ;
}
En este caso, el parser irá analizando las etiquetas que nos interesan y realizará
una acción determinada. Por ejemplo, cuando se comprueba la existencia de una etiqueta TITULO escribimos en HTML la etiqueta de negrita <B>, para resaltar este dato.
Elaborando un poco más la clase obtendrá un objeto de gran utilidad, que
podrá recuperar información de bases de datos o archivos de configuración.
DOM
Esta API define un completo camino para crear, definir y parsear archivos
XML. DOM es una recomendación del consorcio World Wide Web.
La idea básica consiste en que todos los archivos XML pueden verse
como un conjunto de nodos que forman parte de un árbol. Empezando
desde el elemento raíz, del que todos los elementos nacen como hijos,
cualquier programa debería ser capaz de crear una estructura lógica
del documento.
La API puede utilizarse para leer archivos en memoria, modificarlos y
volver a escribir el archivo con los nuevos datos.
DOM está escrito en metodología orientada a objetos, y todos los nodos
son instancias de diferentes objetos.
Usar DOM para leer archivos
El siguiente código muestra un archivo XML muy simple:
<?xml version="l.0" ?>
<tema id="informática">
<titulo>Manual Imprescindible de PHP 5</titulo>
</tema>
Si parseamos este documento con DOM, la etiqueta t i t u l o será considerada
un nodo y además un hijo del nodo raíz, que en este caso es tema.
Esta parte queda más o menos clara debido a la jerarquía de etiquetas que
tiene XML. La controversia llega con el texto que hay en el nodo tema,
que no se considera como una parte, sino como un nodo independiente
cuyo valor es el texto Manual I m p r e s c i n d i b l e de PHP 5. Este nodo
permite recuperar el valor con el método nodeValue.
Vamos a ver los pasos necesarios para leer el archivo b i b l i o t e c a . xml,
ya que difiere bastante la metodología con respecto a SAX.
Todo es un objeto
PHP 5 implementa una clase DOM para representar los archivos XML, llamada
domDocument. Como ya sabe, para instanciar la clase sólo tiene que
hacer uso del operador de objetos:
$biblioteca = new domDocument;
La extensión DOM sigue las especificaciones de XML y trata los espacios
en blanco como contenido. Esto significa que si entre dos etiquetas existe
un espacio, el contenido será tratado como un objeto de texto. Para evitar
fallos de este tipo puede ejecutar el siguiente método:
preserveWhiteSpace = f a l s e;
Lo siguiente que tendrá que hacer es leer el archivo b i b l i o t e c a .xml
con el método l o a d () del objeto $ b i b l i o t e c a . Si el contenido XML se
almacena en una variable, puede utilizar el método loadXML ( ):
$biblioteca->load("biblioteca.xml");
A partir de aquí, ya puede recuperar el contenido del fichero, atendiendo
a sus preferencias. En SAX, tenía que leer el documento completo e
ir preguntando etiqueta por etiqueta para averiguar todos los autores
que estaban dados de alta en el archivo XML. En DOM puede recuperar
esta información usando getElementsByTagname () , que devuelve
un conjunto de objetos que coinciden con la etiqueta que pase como
parámetro.
<?php
//Instanciamos el objeto
$biblioteca = new domdocument;
//Anulamos la posibilidad de que un espacio en blanco sea un
obj eto
$biblioteca->preserveWhiteSpace = false;
//Leemos el archivo XML
$biblioteca->load("biblioteca.xml");
//Buscamos todas las etiquetas libro
$libros = $biblioteca->getElementsByTagname("libro") ;
//Imprimimos todos los libros
foreach ($libros as $libro) {
echo $libro->firstChild->nodeVaiue . "<br>";
}
?>
La variable $ l i b r o s es en realidad un objeto de la clase domnodelist,
y guarda una relación de nodos, cuya etiqueta es l i b r o , es decir, hemos
seleccionado todos los libros del archivo. Con un bucle f o r e a c h podemos
sacar todos los valores. Antes vimos que el texto asociado a un nodo
es un nodo hijo con un valor determinado, por eso debe llamar al método
f i r s t C h i l d .
El hijo de la etiqueta l i b r o es el texto asociado y su valor lo podemos
recibir llamando a nodeValue.
El resultado es la lista de libros:
Manual Imprescindible de PHP 5
Delphi 7
Delphi 6 y Kylix
Atributos
Para recuperar los atributos de los nodos está el método g e t A t t r i b u -
te (), al que tiene que pasar como argumento el nombre del atributo. El
archivo b i b l i o t e c a . xml tiene una única etiqueta con el atributo id,
pero nos sirve para mostrar cómo funciona el método:
<?php
$biblioteca = new domdocument ,-
$biblioteca->preserveWhiteSpace = false;
$biblioteca->load("biblioteca.xml");
$temas = $biblioteca->getElementsByTagname("tema");
foreach ($temas as $tema) {
echo $tema->getAttribute("id");
}
?>
El resultado es el nombre del tema o temas que estén almacenados.
Búsquedas múltiples
Nuestro objetivo final es mostrar todos los títulos, con sus autores, ordenados
por temática. Conociendo ya los métodos principales para recorrer
los objetos DOM, es sencillo pensar en un código que implemente lo que
pedimos:
<?php
$biblioteca = new domdocument;
Sbiblioteca->preserveWhiteSpace = false;
$biblioteca->load("biblioteca.xml");
$biblioteca->documentElement;
$temas = $biblioteca->getElementsByTagname("tema");•
foreach ($temas as $tema) {
echo "Tema: " . $tema->getAttribute("id") . "<br>";
$libros = $tema->getElementsByTagname("libro");
foreach ($libros as $libro) {
echo "<b>" . $libro->firstChild->nodeValue . "</b> - " ;
$autores = $libro->getElementsByTagname("autor");
foreach ($autores as $autor) {
echo $autor->firstChild->nodeValue . "<br>";
}
}
}
?>
Aunque es un poco más complejo, el fundamento básico es ir utilizando
bucles para leer los hijos de un nodo determinado hasta recuperar todos
los datos necesarios.
Escribir archivos XML con DOM
DOM permite hacer más cosas que la simple impresión de los datos en
pantalla. Se puede utilizar para crear nuevos documentos con el nivel de
jerarquía que quiera. Para hacer esto debe apoyarse en la creación de objetos
de la clase domElement () .
Vamos a crear un script para crear el siguiente archivo XML:
<?xml version="1.0"?>
<biblioteca>
<tema>Texto</tema>
< / b i b l i o t e c a>
Para crearlo necesita instanciar una serie de objetos que empieza por la
creación de un documento DOM, mediante la utilización del objeto domdocument
() .
<?php
$biblioteca = new doradocument("1.0");
$raiz = new domelement("biblioteca") ;
$raiz = $biblioteca->appendChild($raiz);
$tema = new domelement("tema","Texto");
$tema = $raiz->appendChild($tema);
$biblioteca->save("biblioteca.xml");
?>
La variable $ r a i z es el objeto que contendrá todo el documento. Para crear
las etiquetas tiene que utilizar el método appendChild ( ) . El objeto que
llama al método contendrá como hijo al elemento que se pasa como parámetro.
Si se fija en el ejemplo, $tema es un nuevo elemento que tendrá la etiqueta
tema.
Para que $tema sea un hijo de la raíz, debe hacer que el objeto padre,
$ r a i z , llame al método appendChild () con el parámetro $tema.
Para grabar el resultado final, el objeto DOM tiene que llamar al método
s a v e ( ) . El fichero b i b l i o t e c a . xml lo puede crear con el código siguiente:
<?php
$biblioteca = new domdocument("1.0");
$raiz = new domelement("biblioteca");
$raiz = $biblioteca->appendChild($raiz);
$tema = new domelement("tema");
$tema = $raiz->appendChild($tema);
$tema->setAttribute("id","informática");
$libro = new domelement("libro") ;
$libro = $tema->appendChild($libro);
$titulo = new domelement("titulo","Manual Imprescindible de PHP 5" •
$titulo = $libro->appendChild($titulo);
$autor = new domelement("autor", "Luis Miguel Cabezas Granado");
$autor = $libro->appendChild($autor) ;
$libro = new domelement("libro");
$libro = $tema->appendChild($libro);
$titulo = new domelement("titulo","Delphi 7 ") ;
$titulo = $libro->appendChild($titulo);
$autor = new domelement("autor","Marco Cantu");
$autor = $libro->appendChild($autor);
$libro = new domelement("libro");
$libro = $tema->appendChild($libro);
$titulo = new domelement("titulo","Delphi 6 y Kylix");
$titulo = $libro->appendChild($titulo);
$autor = new domelement("autor", "Francisco Charte Ojeda");
$autor = $libro->appendChild($autor);
$biblioteca->save("biblioteca.xml");
?>
El conjunto de líneas de código anterior crea un archivo completo XML.
Quizá sea mejor dividir el texto en funciones recursivas que permitan teclear
menos a la hora de crear los documentos, pero eso ya es trabajo para el
lector. El método s e t A t t r i b u t e () añade un atributo al objeto que hace
la llamada; el primer argumento será el nombre del atributo y el segundo
su valor. La llamada a domelement () puede tener uno o dos valores. Si
lleva un atributo significará que el nombre de la etiqueta será ese parámetro.
Si se llama con dos parámetros, el primero será el nombre de la etiqueta
y el segundo un objeto de texto que se añadirá como texto hijo del nodo.
Modificar archivos XML
La verdadera potencia de DOM reside en el poder de gestionar los archivos
para añadir, modificar o eliminar nodos. La mayoría de los algoritmos
que realizan alguna de estas operaciones se basan en la búsqueda de los
nodos para, posteriormente, añadir hijos nuevos o eliminar los encontrados.
Para añadir nuevos elementos se hace como cuando creamos el fichero
b i b l i o t e c a . xml, con el método appendChiId ( ) . Antes de añadir
nuevos nodos tiene que localizar el lugar exacto donde quiere añadir las
etiquetas. El ejemplo siguiente muestra cómo añadir un nuevo nodo tema:
<?php
$biblioteca = new domdocument("1.0");
$biblioteca->load("biblioteca.xml");
$raiz = $biblioteca->documentElement;
$tema_nuevo = new domelement("tema");
$tema_nuevo = $raiz->appendChild($tema_nuevo);
$tema_nuevo->setAttribute ("id" , " ficción" ) ;
$biblioteca->save("biblioteca2.xml");
?>
Los pasos son los que ya ha aprendido. Cargue el documento y cree un
objeto, llamado $ r a i z , que se convierta en la etiqueta raíz, mediante el
método documentElement. Cree un nuevo elemento del tipo tema y añádalo,
para después insertar el atributo que se necesita. Por último, guarde
el archivo en el fichero b i b l i o t e c a 2 .xml.
SimpleXML
Probablemente, el punto más fuerte de PHP 4 fue la incorporación de herramientas
para el soporte de XML. PHP 5 le da una vuelta más a la tuerca implementando nuevas herramientas de lectura, elaboración y modificación
de archivos XML basado en la librería l i b x m l 2 y una nueva API
llamada SimpleXML.
Si XML es un lenguaje bien construido y legible por personas y ordenadores,
los programas para manipular estos archivos deberían ser también
sencillos de utilizar. SimpleXML nace con esta premisa permitiendo leer
un fichero completo con una sola instrucción e, inmediatamente después,
poder leer los datos como conjunto de variables PHP.
El conjunto de funciones que pertenece a la API SimpleXML es nuevo en
PHP 5. Mantiene una absoluta flexibilidad a favor de la simplicidad y bajo
nivel de memoria usado. SimpleXML utiliza el menor número de líneas
de código para leer o escribir datos en un fichero XML.
El ejemplo siguiente muestra cómo podemos parsear el archivo
b i b l i o t e c a , xml:
<?php
$biblioteca = simplexTnl_load_fiie("biblioteca.xml");
foreach ($biblioteca->tema as $tema) {
echo "Tema es " . $tema["id"] . "<br>";
foreach ($tema-?libro as $libro) {
echo "<b> " . $libro->titulo . "</b> - ";
echo $libro->autor . "<br>";
}
}
?>
Lo primero que llama la atención es que en apenas 10 líneas de código, se
ha conseguido extraer todos los datos necesarios, a diferencia de SAX o
DOM.
La función simplexml__load_f i le () crea un objeto con el archivo XML
que pase como argumento.
A partir de aquí puede acceder a todos los datos, así como acceder a las
variables de los objetos:
echo $biblioteca->tema->libro [0] ->titulo;
echo $biblioteca->tema->libro[1]->titulo;
Para extraer el contenido que necesita lo más sencillo es crear una estructura
de bucles f o r e a c h para ir sacando los datos ordenados.
El nombre SimpleXML es totalmente descriptivo, aunque no hay que confundir
la palabra simple con básico. La prueba de su potencia está en que
los desarrolladores de PEAR van a utilizar SimpleXML para desarrollar
su librería de SOAP.
Resumen
XML se ha convertido en un estándar para el intercambio de información
en Internet. Numerosas aplicaciones están construidas con algún tipo de
tecnología que implementa XML, como XML-RPC, RSS o SOAP.
En este capítulo ha aprendido a leer y escribir documentos de tres formas
posibles. La más completa sin duda es DOM, que permite, además de leer
archivos, escribir y modificarlos a nuestro antojo. El problema es que puede
resultar algo complicado de entender al principio y quizá no merezca
la pena en aplicaciones sencillas.
En el capítulo siguiente conocerá la verdadera aplicación práctica. Basándonos
en SimpleXML y en DOM crearemos algunas clases para leer archivos
de noticias o ejecutar funciones definidas en un ordenador remoto. |