1
Download Procesamiento XML - Universidad | Deusto
Document related concepts
no text concepts found
Transcript
Tecnología XML
Dr. Diego Lz. de Ipiña Gz. de Artaza
dipina@eside.deusto.es
http://paginaspersonales.deusto.es/dipina
Contenidos
XML
XML Parsing
DTD
Schema
SAX API
DOM API
XSLT
2
¿Qué es XML?
eXtensible Mark-up Language.
Es un metalenguaje que permite diseñar
otros lenguajes (WML, MathML, XHTML,..).
Cualquiera puede desarrollar su propio
lenguaje de etiquetas adecuado al tipo de
aplicación que más le convenga.
En realidad hay muchas tecnologías basadas
en XML (XPath, XLink, XPointer, XSL, ...).
XML 1.0 Specification
http://www.w3.org/TR/REC-xml
3
HTML y XML
SGML (Standard Generalized Markup
Language)
HTML es una aplicación de SGML
XML es subconjunto más fácil de usar
de SGML
XHTML es una aplicación de XML
4
XML describe estructura y
semántica
<?xml version=”1.0”>
<!DOCTYPE comedor SYSTEM “comedor.dtd”>
<comedor>
<fabricante>Ipiña Altzariak</fabricante>
<mesa tipo="redonda" madera="arce">
<precio>€400</precio>
</mesa>
<silla madera="arce">
<cantidad>2</cantidad>
<calidad>excelente</calidad>
<cojin incluido="sí">
<color>azul</color>
</cojin>
<precio>€200</precio>
</silla>
</comedor>
5
HTML describe formato
<html>
<head><title>Comedor</title></head>
<body>
<h1>Comedor</h1>
<p>Fabricante: Ipiña Altzariak</p>
<ul>
<li><b>Mesa redonda de madera de arce</b></li>
<li><b>Dos sillas de madera de arce</b>, de
excelente calidad, con un cojín azul cada una.</li>
<li><b>3 sillas de madera de roble</b>.</li>
</ul>
</body>
</html>
6
Ventajas XML
Una de las mayores utilidades de XML es
poder etiquetar los datos con su significado
(self-describing data).
Permite la estructuración de la información.
Ello lleva el tratamiento automático de la
información a límites insospechados.
XML es la base de la nueva generación de
aplicaciones web intercambio de datos
7
Usos XML
Sitios web
Comunicación <-> intercambio datos
Permite separar contenido y presentación
Servicios web
Como configuración de programas
Deployment descriptos en servidores J2EE
Ant make system
8
Componentes documento XML
Los documentos XML constan de:
Instrucciones de procesamiento
(processing instructions – PI)
Declaraciones de tipo de documento
Comentarios
Elementos
Referencias a entidades
Secciones CDATA
9
Instrucciones de
procesamiento
Las PI son instruccciones para el
procesador del documento XML.
Siempre hay al menos una PI, que
pertenece al prólogo del documento:
<?xml version="1.0"?>
<saludo>
Hola, mundo!
</saludo>
10
Comentarios en XML
Los comentarios no se procesan.
Tienen la siguiente sintaxis:
<!-- Esto es un comentario -->
11
Elementos y atributos en XML
Los elementos son los que aportan estructura
semántica al documento.
Se delimitan por etiquetas de apertura, cierre y
etiquetas sin elementos interiores (etiquetas vacías).
Las etiquetas de apertura y las vacías suelen venir
acompañadas de atributos, que parametrizan el
elemento.
El valor de los atributos siempre se encierra entre
comillas, dobles o simples.
<saludo tipo=“coloquial”>Hola</saludo>
12
Elementos vs. Atributos
Demasiados atributos hacen que los
documentos XML se puedan leer difícilmente.
No se puede indicar estructura de documento
mediante atributos
<CUSTOMER LAST_NAME="Smith“
FIRST_NAME="Sam" DATE="October
15, 2001" PURCHASE="Tomatoes"
PRICE=“€1.25" NUMBER="8" />
13
Elementos vs. Atributos (cont)
<CUSTOMER>
<NAME>
<LAST_NAME>Smith</LAST_NAME>
<FIRST_NAME>Sam</FIRST_NAME>
</NAME>
<DATE>October 15, 2001</DATE>
<ORDERS>
<ITEM>
<PRODUCT>Tomatoes</PRODUCT>
<NUMBER>8</NUMBER>
<PRICE>$1.25</PRICE>
</ITEM>
</ORDERS>
</CUSTOMER>
14
Referencias a entidades
Las referencias a entidades sirven para
insertar un determinado contenido
definido previamente.
<!ENTITY Empresa “Universidad de Deusto”>
<pie>Creado por &Empresa;</pie>
15
Códigos de escape
Existen 5 referencias a entidades predefinidas:
& el carácter &
< el carácter <
> el carácter >
' el carácter `
" el caracter “
Se incluyen los caracteres del juego ISO 10646.
‘
⼱
16
Secciones CDATA
Las secciones CDATA (character data)
contienen texto que no debe ser
procesado.
Se tratan como una secuencia de
caracteres sin estructura.
<![CDATA[<saludo>Hola, mundo!</saludo>]]>
17
Gramáticas en XML
La gramática que restringe los
elementos válidos dentro de un nuevo
derivado de XML puede expresarse en
forma de:
DTD (Document Type Definitions) o
Esquemas XML
18
Document Type Definitions
(DTDs)
Especifican la estructura y sintaxis de un documento
XML
Labgroups.dtd
<!ELEMENT lab_group
(student_name)*>
<!ELEMENT student_name (#PCDATA)>
<!ATTLIST student_name
dni ID #REQUIRED
tutor IDREF #IMPLIED>
19
Document Type Definitions
(cont)
<?xml version="1.0"?>
<!DOCTYPE mensaje SYSTEM “labgroups.dtd">
<lab_group>
<student_name dni=“44670523">
Josu Artaza
</student_name>
<student_name dni=“44543211">
Nuria Buruaga
</student_name>
<student_name dni=“23554521" tutor=“33456211">
Inga Dorsman
</student_name>
</lab_group>
20
XML Schemas
Los DTD no son muy
potentes para definir
gramáticas.
Otra forma de hacerlo es con
Esquemas XML basados en
el propio XML y que soporta
más tipos de datos.
21
Ejemplo Schema
DTD :
<!ELEMENT text (#PCDATA | emph | name)*>
<!ATTLIST text timestamp NMTOKEN #REQUIRED>
XML Schema:
<xsd:element name="text">
<xsd:complexType mixed="true">
<xsd:sequence>
<xsd:element ref="emph"/>
<xsd:element ref="name"/>
</xsd:sequence>
<xsd:attribute name="timestamp" type="xsd:date"
use="required"/>
</xsd:complexType>
</xsd:element>
22
Ejemplo Schema (cont)
XML Document:
<?xml version="1.0"?>
<text timestamp="08:45:00.000">The
deadline of <name>ISO3
assigment</name> is
<emph>November 21th 2003</emph>.
</text>
23
XML bien formado y/o XML
válido
Hay dos tipos de documentos XML:
Bien formados: son aquellos que
cumplen las reglas sintácticas de XML
Válidos: son aquellos que, además de
ser bien formados, siguen las reglas de una
gramática (definida en un DTD o XML
Schema)
24
Reglas para que un
documento esté bien formado
Para que un documento esté bien formado:
Debe tener un prólogo
Debe tener una etiqueta raíz
Las etiquetas se hallan correctamente anidadas
Se usan caracteres válidos y bien aplicados
Los valores de los atributos vienen encerrados
entre comillas
...
25
Reglas para que un
documento sea válido
Para que un documento sea válido debe
declarar el DTD o XML Schema contra el
cual debe validarse.
Se hace mediante DOCTYPE, pudiendo
ser los DTD públicos o de sistema.
<!DOCTYPE saludo SYSTEM “saludo.dtd”>
<!DOCTYPE saludo PUBLIC “-//Saludos//DTD Lenguaje de
saludos//ES” “http://www.deusto.es/dtds/saludo.dtd”>
También se puede insertar el DTD entero
en ese punto, en lugar de referenciar al
fichero.
26
Proceso de validación
documento XML
Documento
XML
(opcional)
¿Well
Formed?
no
si
¿DTD?
no
Procesamiento de
la información
si
si
DTD
Error: Documento
XML mal formado
¿Valid?
no
Error: Documento
XML no válido
27
XML Namespaces
El estándar XML también define los espacios
de nombres (XML Namespaces).
Permiten que un mismo documento XML
tenga etiquetas de diferentes lenguajes
(definidas en diferentes gramáticas DTD).
Así es posible mezclar más información en los
documentos, por ejemplo, añadir información
semántica a un documento XHTML.
28
Ejemplo XML Namespaces
<?xml version="1.0"?>
<!DOCTYPE mensaje SYSTEM "mensaje.dtd">
<mensaje>
<remite>
<dir:direccion
xmlns:dir=“http://www.deusto.es/direccion”>
<dir:calle>Avda. Universidades</dir:calle>
<dir:localidad
cp=“40007”>Bilbao</dir:localidad>
</dir:direccion>
<nombre>Diego Ipiña</nombre>
<email>dipina@eside.deusto.es</email>
</remite>
<!-- Resto del mensaje XML... -->
</mensaje>
29
Lenguajes basados en XML
Chemical Markup Language (CML)
Mathematical Markup Language (MathML)
Channel Definition Format (CDF)
Synchronized Multimedia Integration Language
(SMIL)
XHTML
Scalable Vector Graphics (SVG)
SOAP y WSDL
VoiceML
Wireless Markup Language (WML)
30
Herramientas de XML
Editores
http://www.xmlcooktop.com/ gratis
XML Spy, www.xmlspy.com
XML parsers
Lee un documento XML
Verifica que XML está bien formado
Verifican que XML es válido
expat, parser written in C by James Clark (www.jclark.com)
Lark, written in Java (www.textuality.com/Lark/)
Apache Jakarta Xerces (www.apache.org)
XML Validators
Verifican que XML es válido
XML.com's Validator based on Lark (xml.com)
31
¿Por qué usar XML?
Un documento XML puede ser
fácilmente procesado y sus datos
manipulados
Existen APIs para procesar esos
documentos en Java, C, C++, Perl.. (y
por supuesto Python)
XML define datos portables al igual que
Java define código portable
32
XML Parsing
Documento
XML
Parser XML
Aplicación
XML
XML DTD
XML Schema
33
XML Parsing (cont)
SAX
Define interfaz dirigido por eventos (event-driven)
para el procesamiento de un documento XML
Definido por David Megginson y lista correo XMLDEV : http://www.megginson.com/SAX
DOM
Provee una representación de un documento XML
en forma de un árbol
Carga todo el documento XML en memoria
http://www.w3.org/DOM
34
Simple API for XML: SAX
Define un interfaz común implementado por
muchos XML Parsers
Es el estándar de-facto para procesamiento
de XML basado en eventos
SAX no es un parseador de XML
SAX2 añade soporte para XML Namespaces
La especificación de SAX 2.0/Java está en:
http://www.megginson.com/SAX/Java/index.
html
35
Características de SAX
Analizador o parser SAX:
Detecta cuándo empieza y termina un elemento o el
documento, o un conjunto de caracteres, etc. (genera
eventos)
Gestiona los espacios de nombres
Comprueba que el documento está bien formado
Las aplicaciones necesitan implementar manejadores
de los eventos notificados
SAX lee secuencialmente de principio a fin, sin cargar
todo el documento en memoria
Ventaja: eficiencia en cuanto al tiempo y la
memoria empleados en el análisis
Desventaja: no disponemos de la estructura en
árbol de los documentos
36
¿Cómo funciona SAX?
XML Document
SAX Objects
<?xml version=“1.0”?>
Parser
startDocument
<addressbook>
Parser
startElement
<name>Diego Ipiña</name>
Parser
startElement & characters
<email>dipina@deusto.es</email>
Parser
startElement & characters
</person>
Parser
endElement
<person>
Parser
startElement
<name>Asier Perallos</name>
Parser
startElement & characters
<email>perallos@deusto.es</email>
Parser
startElement & characters
Parser
endElement
Parser
endElement & endDocument 37
<person>
</person>
</addressbook>
SAX2/Java Parsers y Drivers
Sun's JAXP
http://java.sun.com/xml/
The Apache XML Project's Xerces Java Parser
http://xml.apache.org/xerces-j/index.html
SAXON XSLT processor
http://users.iclway.co.uk/mhkay/saxon/
Oracle XML Developer's Kit for Java
http://technet.oracle.com/tech/xml/xdk_java.html
ParserAdapter
http://www.megginson.com/SAX/Java/index.html
38
Java JAXP
Define clase SAXParserFactory para crear una instancia de un
objeto SAXParser (independiente de implementación SAX parser)
factory = SAXParserFactory.newInstance();
SAXParser saxParser = factory.newSAXParser();
Objeto SAXParser define method parse() para arrancar
procesamiento
Es necesario registrar SAXHandlers con cada SAXParser
Los 4 SAX Handlers principales son:
EntityResolver – maneja entidades externas
DTDHandler – maneja eventos de DTD
ContentHandler – maneja contenido de un documento
ErrorHandler – maneja errores
39
Arquitectura Java JAXP
40
EntityResolver y DTDHandler
EntityResolver
InputSource resolveEntity(String
publicId, String systemId)
DTDHandler
void notationDecl(String name, String
publicId, String systemId)
void unparsedEntityDecl(String name,
String publicId, String systemId,
String notationName)
41
ErrorHandler
void error(SAXParserException
exception)
Recibe notificación de error recuperable.
void fatalError(SAXParserException
exception)
Recibe notificación de error fatal.
void warning (SAXParserException
exception)
Recibe notificación de advertencia.
42
ContentHandler
void characters(char[] ch, int start, int length)
Recibe notificación de caracteres encontrados dentro de un elemento.
void endDocument()
Recibe notificación de final de documento.
void endElement(String namespaceURI, String localName,
String qName)
Recibe notificación de final de elemento.
void processingInstruction(String target, String data)
Recibe notificación cada vez que se encuentra una instrucción de
procesamiento.
void setDocumentLocator(Locator locator)
Recibe objeto para determinar el origen de los eventos en el documento.
void startDocument()
Recibe notificación de comienzo de documento.
void startElement(String namespaceURI,
String localName, String qName, Attributes atts)
Recibe notificación de comienzo de elemento
43
DefaultHandler
Manejador de contenido que define una serie de
métodos que son invocados cuando analizador
detecta determinados eventos al leer documento
Clase de conveniencia que puede ser usada como
clase base para aplicaciones SAX2
Provee implementaciones por defecto de los métodos
callback de los 4 manejadores de SAX2:
EntityResolver
DTDHanler
ErrorHandler
ContentHandler
44
Ejemplo SAX Parsing I
<?xml version="1.0"?>
<CarteleraCine>
<Pelicula codigo='2' titulo='Los Otros'
director='Alejandro Amenabar'
actores='Nicole Kidman'>
<Sesion>16:00</Sesion>
<Sesion>19:00</Sesion>
<Sesion>22:00</Sesion>
</Pelicula>
<Pelicula codigo='5' titulo='Malena'
director='Giuseppe Tornatore'
actores='Monica Bellucci, Giuseppe Sulfaro'>
<Sesion>16:30</Sesion>
<Sesion>19:00</Sesion>
</Pelicula>
</CarteleraCine>
45
Ejemplo SAX Parsing II
import java.util.Vector;
// Imports de JAXP API
import javax.xml.parsers.SAXParserFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
// Imports de SAX API
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class SesionCineSAXParser extends DefaultHandler {
// Atributos en los que se cachea el estado de SesionesPelicula
// Vector con todas las sesiones por pelicula de este cine
private Vector sesionesPeliculas;
// Vector con los strings de horarios de todas las sesiones de una pelicula
private Vector sesionesStrPelicula;
// Metadata asociada a una película
private String codigo, titulo, director, actores;
// Contenido textual de una sesión
private String textoSesion;
// Flag que indica si estamos parseando el contenido de texto de una sesión
private boolean esTextoSesion = false;
...
46
Ejemplo SAX Parsing III
public SesionCineSAXParser(String url) {
// Obtener referencia al parser factory
SAXParserFactory factory =
SAXParserFactory.newInstance();
// factory.setNamespaceAware(true); // activar
namespaces
try {
// Crear una nueva instancia de un SAX parser
SAXParser saxParser = factory.newSAXParser();
// Parsear el documento apuntado por URL
saxParser.parse(url, this);
} catch (Throwable t) {
t.printStackTrace();
}
}
47
Ejemplo SAX Parsing IV
public void startElement(String namespaceURI, String lName,
String qName,Attributes attrs)
throws SAXException {
// lname --> contiene el nombre local (sin prefijo), o el string vacio
// si procesamiento de namespaces no se lleva a cabo.
// qname --> el nombre cualificado (con prefijo), o el string vacío si
namespaces no activo
if (qName.equals("CarteleraCine")) {
this.sesionesPeliculas = new Vector();
} else if (qName.equals("Pelicula")) {
// Por cada peli preparar vector con horarios de sesiones
this.sesionesStrPelicula = new Vector();
this.codigo = attrs.getValue("codigo");
this.titulo = attrs.getValue("titulo");
this.director = attrs.getValue("director");
this.actores = attrs.getValue("actores");
} else if (qName.equals("Sesion")) {
// Sólo recoger texto si dentro de sesión
this.esTextoSesion = true;
this.textoSesion = "";
}
}
48
Ejemplo SAX Parsing V
public void characters(char[] ch, int start, int
length) {
if (this.esTextoSesion == true) {
// Sólo si estamos dentro de un elemento sesión
// recogemos su contenido.
// Si el contenido es largo este método
callback puede ser
// invocado varias veces por el parser SAX
this.textoSesion += (new String(ch, start,
length)).trim();
}
}
49
Ejemplo SAX Parsing VI
public void endElement(String namespaceURI,
String sName, String qName)
throws SAXException {
if (qName.equals("Pelicula")) {
// Salvamos los detalles de una pelicula en un objeto
Pelicula pelicula = new Pelicula(this.codigo, this.titulo,
this.director,
this.actores);
// Añadimos nuevo objeto SesionesPelicula a vector
sesionesPeliculas
this.sesionesPeliculas.add(new SesionesPelicula(pelicula,
this.sesionesStrPelicula));
} else if (qName.equals("Sesion")) {
// Por cada sesión salvar el texto conteniendo horario sesión
this.esTextoSesion = false;
this.sesionesStrPelicula.add(this.textoSesion);
}
}
50
Ejemplo SAX Parsing VII
// Método para recuperar vector con
// objetos SesionesPelicula creados
// en parsing
public Vector getSesionesPeliculas() {
return this.sesionesPeliculas;
}
51
W3C Document Object Model
(DOM)
Documentos XML son tratados como un árbol
de nodos
Cada elemento es un “nodo”
Los elementos hijos y el texto contenido
dentro de un elemento son subnodos
W3C DOM Site: http://www.w3.org/DOM/
DOM Java Language Binding:
http://www.w3.org/TR/DOM-Level-2Core/java-binding.html
52
Características DOM
Documento se carga totalmente en memoria
en una estructura de árbol
Ventaja: fácil acceder a datos en función
de la jerarquía de elementos, así como
modificar el contenido de los documentos e
incluso crearlos desde cero.
Desventaja: coste en tiempo y memoria
que conlleva construir el árbol
53
W3C XML DOM Objects
Element – un elemento XML
Attribute – un attributo
Text – texto contenido en un elemento o atributo
CDATAsection – sección CDATA
EntityReference – Referencia a una entidad
Entity – Indicación de una entidad XML
ProcessingInstruction – Una instrucción de procesamiento
Comment – Contenido de un comentario de XML
Document – El objeto documento
DocumentType – Referencia al elemento DOCTYPE
DocumentFragment – Referencia a fragmento de documento
Notation – Contenedor de una anotación
54
Objetos relacionados con
Nodos
Node – un nodo en el árbol de un
documento
NodeList – una lista de objetos nodos
NamedNodeMap – permite interacción y
acceso por nombre a una colección de
atributos
55
Documento XML como un
árbol de nodos
<?xml version="1.0" encoding="UTF-8"?>
<DOCUMENT>
<GREETING>Hello from XML</GREETING>
<MESSAGE>Welcome to Programing XML in
Java</MESSAGE>
</DOCUMENT>
56
Documento XML como un
árbol de nodos (cont)
57
JAXP DOM
API JAXP de J2SE provee independencia del
analizador
Para conseguir una instancia de analizador DOM a
través de JAXP usamos DocumentBuilder y
DocumentBuilderFactory:
import javax.xml.parsers.*;
import org.w3c.dom.*;
DocumentBuilderFactory fact =
DocumentBuilderFactory.newInstance();
// Crear nueva instancia de DOMBuilder
DocumentBuilder parser =
fact.newDocumentBuilder();
58
Clase DocumentBuilder
Método parse() analiza el fichero
entrada
Método Document getDocument()
devuelve el documento generado
durante parsing
parser.parse(fich);
Document doc = parser.getDocument();
59
Métodos del objecto
Document
Attr createAttribute(String name)
Crea un atributo con el nombre dado
Element createElement(String tagName)
Crea un elemento con el nombre dado
Text createTextNode(String data)
Crea un nodo de texto
Element getDocumentElement()
Devuelve el elemento raíz el documento
Element getElementById(String elementId)
Devuelve el elemento identificado por elementId
NodeList getElementsByTagName(String tagname)
Devuelve una lista de elementos identificados por el nombre de
etiqueta dado
60
Métodos del interfaz Node
Node
NamedNodeMap getAttributes()
Devuelve lista de atributos en un nodo
Node getFirstChild()
Devuelve el primer hijo de este nodo
Node getFirstChild()
Devuelve el último hijo de este nodo
NodeList getChildNodes()
Devuelve todos los hijos de este nodo
Node getParentNode()
Devuelve nodo padre del nodo actual
short getNodeType()
Devuelve tipo de nodo actual
String getNodeName()
Devuelve nombre nodo
String getNodeValue()
Devuelve contenido nodo
61
Métodos del interfaz NodeList
y NamedNodeMap
NodeList
int getLength()
Devuelve número de nodos en lista
Node item(int index)
Devuelve el nodo identificado por index en una colección
NamedNodeMap
int getLength()
Devuelve número de nodos en lista
Node getNamedItem(String name)
Recupera un nodo dado su nombre
Node item(int index)
Devuelve el nodo identificado por index en una colección
62
Ejemplo DOM I
<?xml version="1.0" encoding="iso-8859-1"?>
<Peliculas>
<Pelicula codigo='1' titulo='Lo que el viento se
llevó'
director='Victor Fleming'
actores='Clark Gable, Vivien Leigh,
Leslie Howard'/>
<Pelicula codigo='2' titulo='Los Otros'
director='Alejandro Amenabar'
actores='Nicole Kidman'/>
<Pelicula codigo="5" titulo="Malena"
director="Giuseppe Tornatore"
actores="Monica Bellucci, Giuseppe
Sulfaro"/>
</Peliculas>
63
Ejemplo DOM II
Root
Películas
...
Película
codigo=1
diirector=’Victor Fleming’
titulo=’Lo que el
viento se llevó’
actores=’Clark Gable, Vivien
Leigh, Leslie Howard’
Película
codigo=5
diirector=’Giuseppe
Tornatore’
titulo=’Malena’
actores=’Monica Bellucci,
Giuseppe Sulfaro’
64
Ejemplo DOM III
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import java.io.IOException;
public class EjemploDOM {
public static void main(String[] args) {
...
DocumentBuilderFactory fact =
DocumentBuilderFactory.newInstance();
// Crear nueva instancia de DOMBuilder a través factoria
DocumentBuilder parser = fact.newDocumentBuilder();
parser.parse(fich);
Document doc = parser.getDocument();
EjemploDOM.tratarNodo(doc);
...
}
}
65
Ejemplo DOM IV
public static void tratarNodo(Node nodo) {
switch (nodo.getNodeType()) {
case Node.DOCUMENT_NODE:
break;
case Node.ELEMENT_NODE:
break;
case Node.ATTRIBUTE_NODE:
break;
case Node.TEXT_NODE:
break;
case Node.CDATA_SECTION_NODE:
break;
case Node.PROCESSING_INSTRUCTION_NODE:
break;
case Node.ENTITY_REFERENCE_NODE:
break;
case Node.DOCUMENT_TYPE_NODE:
break;
}
}
66
Ejemplo DOM V
case Node.DOCUMENT_NODE:
System.out.println("<xml version=\"1.0\">");
Document doc = (Document)nodo;
tratarNodo(doc.getDocumentElement());
break;
67
Ejemplo DOM VI
case Node.ELEMENT_NODE:
String nombre = nodo.getNodeName();
System.out.print("<" + nombre);
NamedNodeMap ats = nodo.getAttributes();
for (int i=0; i<ats.getLength(); i++) {
tratarNodo(ats.item(i));
}
System.out.println(">");
NodeList hijos = nodo.getChildNodes();
... // tratar los hijos recursivamente
break;
case Node.ATTRIBUTE_NODE:
System.out.print(" " + nodo.getNodeName() +
"=\"" + nodo.getNodeValue() +"\"");
68
Ejemplo DOM VII
case Node.TEXT_NODE:
String texto = nodo.getNodeValue().trim();
if (!texto.equals("")) {
System.out.println(ind + texto);
}
break;
case Node.CDATA_SECTION_NODE:
System.out.println(nodo.getNodeValue());
break;
NodeList peliNodes =
document.getElementsByTagName("Pelicula");
69
Extensible Style Language
Transformations (XSLT) I
Con la diversidad de lenguajes de
presentación que hay (WML, HTML, cHTML)
existen dos alternativas para desarrollar las
aplicaciones:
Desarrollar versiones de los procesos de
generación de presentación (JSP, ASP, CGI,..) para
cada lenguaje.
Desarrollar solo una versión que genere XML y
conversores de XML a los lenguajes de
presentación.
70
Extensible Style Language
Transformations (XSLT) II
Dos partes:
Transformation Language (XSLT)
Formatting Language (XSL Formatting Objects)
XSLT transforma un documento XML en otro
documento XML
XSLFO formatea y estiliza documentos en
varios modos
XSLT W3C Recommendation http://www.w3.org/TR/xslt
71
Operaciones entre árboles en
XSL
72
Ventajas y desventajas de
XSLT
Ventajas:
No asume un único formato de salida de documentos
Permite manipular de muy diversas maneras un documento
XML: reordenar elementos, filtrar, añadir, borrar, etc.
Permite acceder a todo el documento XML
XSLT es un lenguaje XML
Desventajas:
Su utilización es más compleja que un lenguaje de
programación convencional
Consume cierta memoria y capacidad de proceso DOM
detrás
73
Usando hojas de estilo XSLT
Para crear una transformación XSL
necesitamos:
El documento XML a transformar
(students.xml)
La hoja de estilo que especifica la
transformación (students.xsl)
74
Documento XML
(students.xml)
<?xml version="1.0"?>
<course>
<name id="csci_2962">Programming XML in Java</name>
<teacher id=“di">Diego Ipiña</teacher>
<student id=“ua">
<name>Usue Artaza</name>
<hw1>30</hw1>
<hw2>70</hw2>
<project>80</project>
<final>85</final>
</student>
<student id=“iu">
<name>Iñigo Urrutia</name>
<hw1>80</hw1>
<hw2>90</hw2>
<project>100</project>
<final>40</final>
</student>
</course>
75
Hoja de estilo XSLT
(students.xsl)
<?xml version="1.0"?>
<xsl:stylesheet version="1.0“
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="course">
<HTML>
<HEAD><TITLE>Name of students</TITLE></HEAD>
<BODY>
<xsl:apply-templates select="student"/>
</BODY>
</HTML>
</xsl:template>
<xsl:template match="student">
<P><xsl:value-of select="name"/></P>
</xsl:template>
</xsl:stylesheet>
76
Resultado de transformación
(students.html)
<HTML>
<HEAD> <TITLE>Name of students</TITLE>
</HEAD>
<BODY>
<P>Usue Artaza</P>
<P>Iñigo Urrutia</P>
</BODY>
</HTML>
77
Formas de uso de XSLT
Visualizar directamente en un navegador el
documento XML que tiene asociada una hoja XSLT.
Ejecutar el procesador XSLT independientemente del
navegador. Se le pasan las entradas necesarias
(fichero origen y hoja XSLT a utilizar) y genera la
salida en un fichero, con el que podemos hacer lo
que queramos.
Realizar las transformaciones dentro de un programa
en el servidor y enviar a los clientes sólo el resultado
de la transformación.
78
Aplicaciones usando XSLT
Cliente
Servidor
XML
Internet
XSLT
Arquitectura en 5 capas dónde el
servidor contiene conversores
XSLT para generar presentación
en distintos formatos.
JSP
Clases
Java
Base de
Datos
79
Ejemplos de Procesadores
XSLT existentes
Oracle XML parser for Java
http://technet.oracle.com/tech/xml/parser_java2/
Saxon
http://users.iclway.co.uk/mhkay/saxon/index.html
XT
http://www.jclark.com/xml/xt.html
Sablotron
http://www.gingerall.com/charliebin/get/webGA/act/sablotron.act
Microsoft XML Parser
http://msdn.microsoft.com/downloads/webtechnology/xml/msx
ml.asp
Xalan Java
http://xml.apache.org/xalan-j/index.html
Java JAXP
80
XSLT son documentos XML
bien formados
xsl:stylesheet – elemento raiz
xsl:template – cómo transformar un nodo
seleccionado
Se asocia con un fragmento del documento a través de una
expresión en XPath
Transforma XML entrante en otro fragmento de XML
match – Atributo para seleccionar nodo
"/" – nodo raiz del documento de entrada
Elemento xsl:apply-templates. Aplica los
templates definidos para los hijos de un nodo
seleccionado
81
Ejemplo XSLT
<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999
/XSL/Transform">
<xsl:template match="/">
<xsl:apply-templates/>
</xsl:template>
</xsl:stylesheet>
82
Elementos XSLT
xsl:value-of permite recuperar el valor de un nodo
Los nodos son seleccionados usando la sintáxis de la especificación XPath XML
Sólo selecciona el valor del primer estudiante que encuentre
<xsl:template match=“course">
<xsl:value-of select=“student"/>
</xsl:template>
Si queremos seleccionar varios podemos hacer:
<xsl:template match=“course">
<xsl:apply-templates select=“student"/>
</xsl:template>
<xsl:template match=“student">
<xsl:value-of select="."/>
</xsl:template>
O usar xsl:for-each
<xsl:template match=“course">
<xsl:for-each select=“student">
<xsl:value-of select="."/>
</xsl:for-each>
</xsl:template>
83
Elementos XSLT (cont)
Para realizar distintos procesamientos en
función de los datos se usa xsl:choose:
Se compone de elementos xsl:when
Un elemento opcional xsl:otherwise
Para procesar o no un elemento en función
de una condición se usa xsl:if:
Condición en atributo test
84
Ejemplo
<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<HTML>
<HEAD> <TITLE>Name of students</TITLE> </HEAD>
<BODY>
<xsl:apply-templates/>
</BODY>
</HTML>
</xsl:template>
<xsl:template match="course">
<xsl:apply-templates select="student"/>
</xsl:template>
<xsl:template match="student">
<xsl:for-each select="name"><P><xsl:value-of
select="."/></P></xsl:for-each>
</xsl:template>
</xsl:stylesheet>
85
Patrones XPath para el
atributo match o select
Seleccionar el nodo raiz:
<xsl:template match="/"> ... </xsl:template>
Seleccionar un elemento:
<xsl:template match="student"> ...</xsl:template>
Seleccionar hijos de un elemento:
<xsl:template match="course/student"> ...
</xsl:template>
<xsl:template match="course/*/name"> ...
</xsl:template>
Seleccionar descendientes de un elemento:
<xsl:template match="course//name"> ...
</xsl:template>
86
Patrones XPath para el
atributo match o select
Seleccionar atributo título:
<xsl:value-of select="./@id"/>
Seleccionar comentarios:
<xsl:template match="comment()"> ...
</xsl:template>
Seleccionar elementos de texto:
<xsl:template match="text()"> ...
</xsl:template>
Recuperar posición que ocupa un subelemento dentro de elemento padre
<xsl:value-of select="position()"/>
87
Evaluando condiciones con []
Evaluando si una condición es cierta:
Si el elemento estudiante tiene un hijo name
<xsl:template match="student[name]">
Cualquier elemento que tiene un elemento namE
<xsl:template match="*[name]">
Elemento student tiene un sub-elemento hw1 o
hw2 element
<xsl:template match="student[hw1 |
hw2]">
88
Ejemplo XSLT
Problema: Imprimir nombre de alumnos con nota media mayor de 65%
<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="text"/>
<xsl:template match="course">
<xsl:apply-templates select="student"/>
</xsl:template>
<xsl:template match="student">
<xsl:variable name="ave">
<xsl:value-of select="(hw1 + hw2 + project + final) div 4"/>
</xsl:variable>
<xsl:if test="$ave > 65">
Student name="<xsl:value-of select="name"/>" average="<xsl:valueof select="$ave"/>"
</xsl:if>
</xsl:template>
</xsl:stylesheet>
89
Resultado transformación
Salida (grades70.txt):
Student name=“Usue Artaza"
average="66,25"
Student name=“Iñigo Urrutia"
average="77,5"
90
Java JAXP
Provee clase Transformer para la
aplicación de XSL a un documento XML
Como siempre Java JAXP asegura que
el código fuente sea el mismo
independientemente del parser XSLT
subyacente
91
Usando Java JAXP
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import
javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
...
92
Usando Java JAXP (cont)
public String obtenerCarteleraHMTL() {
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
try {
// Usar JAXP DOM para generar Document con fichero xml
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(
"http://localhost:8080/cartelera/Cines.jsp?Funcion=TodaCartelera");
// Generar un objeto transformer para realizar transform XSL
TransformerFactory tFactory = TransformerFactory.newInstance();
StreamSource stylesource = new StreamSource(
"http://localhost:8080/cartelera/Cartelera.xsl");
Transformer transformer = tFactory.newTransformer(stylesource);
DOMSource source = new DOMSource(document);
ByteArrayOutputStream outputByteArray = new
ByteArrayOutputStream();
StreamResult result = new StreamResult(outputByteArray);
transformer.transform(source, result);
return outputByteArray.toString();
} catch (Exception e) {
e.printStackTrace();
}
93
}
Ejemplo XML + XSL XHTML
I
<?xml version="1.0" encoding="iso-8859-1"?>
<Cartelera>
<Cine codigo='1' nombre='Coliseo Java' direccion='Avda. Abaro'
poblacion='Portugalete'>
<Pelicula codigo='1' titulo='Lo que el viento se llevó'
director= 'Victor Fleming '
actores= 'Clark Gable, Vivien Leigh, Leslie
Howard '>
<Sesion>16:00</Sesion>
<Sesion>19:30</Sesion>
<Sesion>22:00</Sesion>
</Pelicula>
<Pelicula codigo='5' titulo='Malena'
director='Giuseppe Tornatore'
actores='Monica Bellucci, Giuseppe Sulfaro'>
<Sesion>16:30</Sesion>
<Sesion>19:00</Sesion>
</Pelicula>
</Cine>
…
</Cartelera>
94
Ejemplo XML + XSL XHTML
II
<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet xmlns:xsl=http://www.w3.org/1999/XSL/Transform
version="1.0">
<xsl:output method="html"/>
<xsl:template match="/">
<html>
<head>
<style type="text/css">
table {font-family: arial, 'sans serif';
margin-left: 15pt;}
th,td {font-size: 80%;}
th {background-color:#FAEBD7}
</style>
</head>
<body>
<table border="1">
<xsl:apply-templates/>
</table>
</body>
</html>
</xsl:template>
95
Ejemplo XML + XSL XHTML
III
<xsl:template match="Cartelera">
<xsl:for-each select="Cine">
<tr>
<th><xsl:text>Cine</xsl:text></th>
<th><xsl:text>Dirección</xsl:text></th>
<th><xsl:text>Población</xsl:text></th>
<th></th>
</tr>
<tr>
<td><xsl:value-of select="./@nombre"/></td>
<td><xsl:value-of select="./@direccion"/></td>
<td><xsl:value-of select="./@poblacion"/></td>
<td><xsl:text></xsl:text></td>
</tr>
<xsl:for-each select="Pelicula“>
<tr>
<th></th>
<th><xsl:text>Película</xsl:text></th>
<th><xsl:text>Director</xsl:text></th>
<th><xsl:text>Actores</xsl:text></th>
</tr>
<tr>
<td><xsl:text></xsl:text></td>
<td><xsl:value-of select="./@titulo"/></td>
<td><xsl:value-of select="./@director"/></td>
<td><xsl:value-of select="./@actores"/></td>
</tr>
96
Ejemplo XML + XSL XHTML
IV
<tr>
<th></th>
<th></th>
<th><xsl:text>Sesión</xsl:text></th>
<th><xsl:text>Hora</xsl:text></th>
</tr>
<xsl:for-each select="Sesion">
<tr>
<td><xsl:text></xsl:text></td>
<td><xsl:text></xsl:text></td>
<td><xsl:value-of
select="position()"/></td>
<td><xsl:value-of select="."/></td>
</tr>
</xsl:for-each>
</xsl:for-each>
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
97
Ejemplo XML + XSL XHTML
V
<html>
<body>
<table border="1">
<tr>
<th>Cine</th>
<th>Dirección</th>
<th>Población</th>
<th></th>
</tr>
<tr>
<td>Coliseo Java</td>
<td>Avda. Abaro</td>
<td>Portugalete</td>
<td></td>
</tr>
<tr>
<th></th>
<th>Película</th>
<th>Director</th>
<th>Actores</th>
</tr>
98
Ejemplo XML + XSL XHTML
VI
<tr>
<td></td>
<td>Lo que el viento se llevó</td>
<td>Santiago Segura</td>
<td>Bo Derek, Al Pacino, Robert Reford</td>
</tr>
<tr>
<th></th>
<th></th>
<th>Sesión</th>
<th>Hora</th>
</tr>
<tr>
<td></td>
<td></td>
<td>1</td>
<td>16:00</td>
</tr>
<tr>
...
</table>
<body>
</html>
99
Resultado procesamiento XSLT
100
