XML

22/08/2012 © 2006 SUN Microsystems, Traducción de

Roberto Solis Robles, Derechos Reservados

1

XML

Instructor: Dr. Roberto Solís Robles

2

Contenido

XML

DTD

Schema

XML Parsing

SAX API

DOM API

XSLT

3

¿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

http://www.w3.org/TR/REC-xml



4

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

5

XML describe estructura y

semántica

<?xml version=”1.0” ?> <!DOCTYPE comedor SYSTEM “comedor.dtd”> <comedor> <fabricante>Gala</fabricante> <mesa tipo="redonda" madera="arce"> <precio>5500</precio> </mesa> <silla madera="arce"> <cantidad>2</cantidad> <calidad>excelente</calidad> <cojin incluido="sí"> <color>azul</color> </cojin> <precio>3200</precio> </silla> </comedor>

6

HTML describe formato

<html> <head><title>Comedor</title></head> <body> <h1>Comedor</h1> Fabricante: Ipiña Altzariak <ul> <li>Mesa redonda de madera de arce</li> <li>Dos sillas de madera de arce, de

excelente calidad, con un cojín azul cada una.</li> <li>3 sillas de madera de roble.</li> </ul> </body> </html>

7

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

8

Usos XML

Sitios web

Permite separar contenido y presentación

Comunicación <-> intercambio datos

Servicios web

Como configuración de programas

Deployment descriptors en servidores J2EE

Ant make system

9

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

10

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>

11

Comentarios en XML

Los comentarios no se procesan.

Tienen la siguiente sintaxis:



12

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>

13

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" />

14

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>

15

Referencias a entidades

Las referencias a entidades sirven para

insertar un determinado contenido definido

previamente.

<!ENTITY Empresa “Universidad Autonoma de Zacatecas”>

<pie>Creado por &Empresa;</pie>

16

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.

⼱

17

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>]]>

Ejemplo

Generar un documento XML para la siguiente

tabla:



18

ID_PROVEE

DOR

NOMBRE CALLE CIUDAD ESTADO CODPOSTAL

101 Nescafe Nazar 25 Toluca México 06470

49 Illy Moreno 32 México DF 01000

150 ACME 25 E Marc Urbana IL 61801

TABLA PROVEEDORES

Practica

Generar un documento XML para la siguiente

tabla:



19

NOM_CAFE ID_PROVEEDOR PRECIO VENTAS TOTAL

COLOMBIANO 101 85.70 0 0

FRANCES 49 98.75 0 0

ESPRESSO 150 120.40 0 0

DECAF 101 100.00 0 0

VERACRUZ 49 120.00 0 0

TABLA CAFES

20

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

21

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>

22

Document Type Definitions

(cont)

<?xml version="1.0"?> <!DOCTYPE lab_group SYSTEM “labgroups.dtd"> <lab_group> <student_name dni=“05200111"> Humberto Banuelos </student_name> <student_name dni=“06200210"> Sandra Monreal </student_name> <student_name dni=“05200056" tutor=“88450331"> Rosario Marin </student_name> </lab_group>

Ejemplo

Generar un DTD para representar la

organización de los documentos XML que

representen tablas como la siguiente:



23

ID_PROVEE

DOR





TABLA PROVEEDORES

Practica

Generar un DTD para representar la

organización de los documentos XML que




24



FRANCES 49 98.75 0 0

ESPRESSO 150 120.40 0 0

DECAF 101 100.00 0 0

VERACRUZ 49 120.00 0 0

TABLA CAFES

25

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.

26

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 name="emph"/> <xsd:element ="name"/> </xsd:sequence> <xsd:attribute name="timestamp" type="xsd:date“ use="required"/> </xsd:complexType> </xsd:element>

27

Ejemplo Schema (cont)

Documento XML:


<text timestamp="08:45:00.000">

The deadline of <name>ISO3 assigment</name> is <emph>November 21th 2003</emph>.

</text>

Ejemplo

Generar un esquema XML para representar

la organización de los documentos XML que




28

ID_PROVEE

DOR





TABLA PROVEEDORES

Practica

Generar un esquema XML para representar

la organización de los documentos XML que




29



FRANCES 49 98.75 0 0

ESPRESSO 150 120.40 0 0

DECAF 101 100.00 0 0

VERACRUZ 49 120.00 0 0

TABLA CAFES

30

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)

31

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

...

32

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://espcom.reduaz.mx/dtds/saludo.dtd”>

También se puede insertar el DTD entero en ese punto, en lugar de referenciar al fichero.

33

Proceso de validación

documento XML

¿Well

Formed?

Documento

XML

DTDError: Documento

XML no válido

Error: Documento

XML mal formado

Procesamiento de

la información

¿Valid?

¿DTD?

(opcional) si

no

si

si

no

no

34

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.

35

Ejemplo XML Namespaces

<?xml version="1.0"?> <!DOCTYPE mensaje SYSTEM "mensaje.dtd"> <mensaje> <remite> <dir:direccion xmlns:dir=“http://espcom.reduaz.mx/espcom”> <dir:calle>Avda. Lopez Velarde 801</dir:calle> <dir:ciudad cp=“98000”>Zacatecas</dir:ciudad> </dir:direccion> <nombre>Roberto Solis Robles</nombre> <email>[email protected]</email> </remite>  </mensaje>

36

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)

37

Herramientas de XML

Editores XML Cooktop, http://www.xmlcooktop.com/

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 escrito en C por James Clark (www.jclark.com)

Lark, escrito en Java (www.textuality.com/Lark/)

Apache Jakarta Xerces (http://xerces.apache.org/)

XML Validators Verifican que XML es válido

Validome XML Validator (http://www.validome.org/xml/)

http://www.xmlcooktop.com/

http://www.xmlspy.com/

http://www.jclark.com/

http://www.textuality.com/Lark/

http://xerces.apache.org/

http://www.validome.org/xml/

38

¿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..

XML define datos portables al igual que Java define código portable

39

XML Parsing

Documento

XML

XML DTD

XML Schema

Parser XMLAplicación

XML

40

XML Parsing (cont)

SAX Define una interface dirigida por eventos (event-

driven) para el procesamiento de un documento XML

Definida por David Megginson y lista correo XML-DEV 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

http://www.megginson.com/SAX

http://www.w3.org/DOM

41

Simple API for XML: SAX

Define una interface común implementada por muchos Parsers XML

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

http://www.megginson.com/SAX/Java/index.html

42

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

43

¿Cómo funciona SAX? XML Document

<?xml version=“1.0”?>

<addressbook>

</addressbook>

<person>

</person>

<name>Diego Ipiña</name>

<email>[email protected]</email>

<person>

</person>

<name>Asier Perallos</name>

<email>[email protected]</email>

SAX Objects

Parser startDocument

Parser startElement

Parser startElement & characters


Parser endElement

Parser startElement



Parser endElement

Parser endElement & endDocument

44

SAX2/Java Parsers y Drivers

Sun's JAXP (Java API for XML Processing) http://java.sun.com/xml/

The Apache XML Project's Xerces Java Parser http://xerces.apache.org/xerces2-j/

SAXON XSLT processor http://saxon.sourceforge.net/

Oracle XML Developer's Kit for Java http://www.oracle.com/technology/tech/xml/xdkhome.html

ParserAdapter http://www.megginson.com/SAX/Java/index.html

http://java.sun.com/xml/

http://xerces.apache.org/xerces2-j/



http://saxon.sourceforge.net/

http://www.oracle.com/technology/tech/xml/xdkhome.html

http://www.megginson.com/SAX/Java/index.html

45

Java JAXP Define la clase SAXParserFactory para crear una instancia de un

objeto SAXParser (independiente de la implementación del parser SAX)

factory = SAXParserFactory.newInstance(); SAXParser saxParser = factory.newSAXParser();

La clase SAXParser define el método parse(String uri, DefaultHandler dh) para arrancar el procesamiento

Una vez creado el objeto SAXParser al atributo encargado de leer el XML (XMLReader) deben asociarsele 4 manejadores (handlers): EntityResolver – maneja entidades externas

DTDHandler – maneja eventos de DTD

ContentHandler – maneja contenido de un documento

ErrorHandler – maneja errores

46

Arquitectura Java JAXP

47

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)

48

ErrorHandler

void error(SAXParseException exception) Recibe notificación de error recuperable.

void fatalError(SAXParseException exception) Recibe notificación de error fatal.

void warning (SAXParseException exception) Recibe notificación de advertencia.

49

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

50

DefaultHandler Manejador de contenido que define una serie de

métodos que son invocados cuando el 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 de los 4 manejadores de SAX2: EntityResolver

DTDHanler

ErrorHandler

ContentHandler

Heredamos de esta clase y superponemos los métodos que deseamos

Ejemplo Parseo SAX Se desea hacer un programa que realice lo

siguiente: Al iniciar el documento imprimir “*Inicio del documento”

Al terminar el documento imprimir “*Final del documento”

Al iniciar un elemento imprimir “Inicio del elemento XXXX”

Al terminar un elemento imprimir “Final del elemento XXXX”

Al encontrar caracteres dentro de una etiqueta imprimir el mensaje “Datos de caracter, longitud =XX”

Conforme se encuentra cada componente se desea mostrar la posicion en el árbol jerárquico mostrando un – por cada nivel en el que se encuentre (se podria usar un contador que se incremente cada vez que encontremos el inicio de un elemento y se decremente al final)



51

Práctica Parseo SAX

Se desea del archivo recipes.xml obtener la

suma de todos los ingredientes flour (harina)

que se requieren en todas las recetas

Desarrolle un programa en Java que use

SAX para obtener esa suma y la muestre



52

53

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-2-Core/java-binding.html

http://www.w3.org/DOM/

http://www.w3.org/TR/DOM-Level-2-Core/java-binding.html









SDPL 2003 Notes 3: XML Processor Interfaces 54

DOM en JAXP

XML Reader

(SAX Parser)

XML

Error Handler

DTD Handler

Entity Resolver

Document Builder

(Content Handler)

DOM Document

55

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: costo en tiempo y memoria que

conlleva construir el árbol

56

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

57

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

58

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>

NOTA: Si bien en este ejemplo, las etiquetas

están en mayúscula, lo cual es válido, se

sugiere siempre se usen minúsculas para

nombrar etiquetas/tags.

59

Documento XML como un

árbol de nodos (cont)

60

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();

61

Clase DocumentBuilder

Método parse() analiza el fichero entrada y

devuelve el documento generado durante el

análisis

Document doc = parser.parse(fich);

62

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

63

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

64

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

65

Ejemplo DOM I

<?xml version="1.0" encoding=“UTF-8"?> <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>

66

Ejemplo DOM II

Root

Películas

...Película

titulo=’Lo que el

viento se llevó’codigo=1

actores=’Clark Gable, Vivien

Leigh, Leslie Howard’diirector=’Victor Fleming’

Película

titulo=’Malena’codigo=5

actores=’Monica Bellucci,

Giuseppe Sulfaro’

diirector=’Giuseppe

Tornatore’

67

Ejemplo DOM III import org.w3c.dom.*; import java.io.*; import javax.xml.parsers.*; public class EjemploDOM { public static void main(String[] args) { File arch = new File(args[0]); Document doc=null; DocumentBuilderFactory fact = DocumentBuilderFactory.newInstance(); // Crear nueva instancia de DOMBuilder a través de factory try { DocumentBuilder parser = fact.newDocumentBuilder(); doc = parser.parse(arch); } catch (Throwable t) { t.printStackTrace(); } EjemploDOM.tratarNodo(doc); } }

68

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; } }

69

Ejemplo DOM V case Node.DOCUMENT_NODE: System.out.println("<xml version=\"1.0\">"); Document doc = (Document)nodo; tratarNodo(doc.getDocumentElement()); break;

70

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(); for (int i=0; i<hijos.getLength(); i++) { tratarNodo(hijos.item(i)); } break; case Node.ATTRIBUTE_NODE: System.out.print(" " + nodo.getNodeName() +

"=\"" + nodo.getNodeValue() +"\""); break;

71

Ejemplo DOM VII case Node.TEXT_NODE: String texto = nodo.getNodeValue().trim(); if (!texto.equals("")) { System.out.println(texto); } break; case Node.CDATA_SECTION_NODE: System.out.println(nodo.getNodeValue()); break;

Práctica DOM

Del archivo proveedores.xml se desea

imprimir solo los nombres de los

proveedores.

Desarrolle un programa en Java que haga

este trabajo usando DOM



72

73

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.

74

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

http://www.w3.org/TR/xslt

75

Operaciones entre árboles en

XSL

76

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

77

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)

78

Documento XML

(students.xml) <?xml version="1.0" encoding="iso-8859-1"?> <course> <name id=”is201”>POO Avanzada</name> <teacher id=”rsr">Roberto Solis Robles</teacher> <student id=”jm"> <name>Jorge Medina</name> <hw1>70</hw1> <hw2>75</hw2> <project>80</project> <final>85</final> </student> <student id=”eg"> <name>Edgar Gonzalez</name> <hw1>80</hw1> <hw2>90</hw2> <project>90</project> <final>70</final> </student> </course>

79

Hoja de estilo XSLT

(students.xsl) <?xml version="1.0" encoding="iso-8859-1"?> <xsl:stylesheet version="1.0"

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:template match="course"> <HTML> <HEAD><TITLE>Nombre estudiantes</TITLE></HEAD> <BODY> <xsl:apply-templates select="student"/> </BODY> </HTML> </xsl:template> <xsl:template match="student"> <xsl:value-of select="name"/> </xsl:template> </xsl:stylesheet>

80

Resultado de transformación (students.html)

<HTML>

<HEAD> <TITLE>Nombre de estudiantes</TITLE> </HEAD>

<BODY>

Jorge Medina

Edgar Gonzalez

</BODY>

</HTML>

81

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.

82

Aplicaciones usando XSLT

Internet

JSP

Clases

Java

Base de

Datos

Cliente Servidor

XML

Arquitectura en 5 capas dónde

el servidor contiene conversores

XSLT para generar presentación

en distintos formatos.

XSLT

83

Ejemplos de Procesadores

XSLT existentes Oracle XML parser for Java


Saxon http://saxon.sourceforge.net/

XT http://www.blnz.com/xt/index.html

Sablotron http://www.gingerall.org/sablotron.html

Microsoft XML Parser http://msdn.microsoft.com/en-us/xml/default.aspx

Xalan Java http://xml.apache.org/xalan-j/index.html

Java JAXP



http://saxon.sourceforge.net/

http://www.blnz.com/xt/index.html

http://www.gingerall.org/sablotron.html

http://msdn.microsoft.com/en-us/xml/default.aspx



http://xml.apache.org/xalan-j/index.html




84

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

85

Ejemplo XSLT


<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">

<xsl:apply-templates/>

</xsl:template>

</xsl:stylesheet>

86

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=“name"/> </xsl:template>

O usar xsl:for-each <xsl:template match=“course"> <xsl:for-each select=“student"> <xsl:value-of select=“name"/> </xsl:for-each> </xsl:template>

87

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

88

Ejemplo (students2.xsl) <?xml version="1.0"?> <xsl:stylesheet version="1.0"

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:template match="/"> <HTML> <HEAD> <TITLE>Nombre de estudiantes</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"><xsl:value-of

select="."/></xsl:for-each> </xsl:template> </xsl:stylesheet>

89

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>

90

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 sub-elemento dentro de elemento padre <xsl:value-of select="position()"/>

91

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

<xsl:template match="student[hw1 | hw2]">

92

Ejemplo XSLT (students3.xsl)

Problema: Imprimir nombre de alumnos con calificación promedio mayor a 65

<?xml version="1.0" encoding="iso-8859-1" ?> <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="prom"> <xsl:value-of select="(hw1 + hw2 + project + final) div 4"/> </xsl:variable> <xsl:if test="$prom > 65"> Nombre del estudiante ="<xsl:value-of select="name"/>" promedio

="<xsl:value-of select="$prom"/>" </xsl:if> </xsl:template> </xsl:stylesheet>

93

Resultado transformación

Salida :

Nombre del estudiante =”Jorge Medina" promedio ="77.5"

Nombre del estudiante =”Edgar Gonzalez" promedio ="82.5"

94

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

SDPL 2003 Notes 3: XML Processor Interfaces 95

XSLT

JAXP: Uso de Transformers

.newTransformer(…)

.transform(.,.)

96

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; import java.io.*; public class TransformadorXSLT { public static void main(String[] args) { if (args.length<2) { System.out.println("Uso: java TransformadorXSLT ArchXML”+ “ ArchXSL"); System.exit(1); } File archXML = new File(args[0]); File archXSL = new File(args[1]);

97

Usando Java JAXP (cont) DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); try { // Usar JAXP DOM para generar Document con fichero xml DocumentBuilder builder = factory.newDocumentBuilder(); Document document = builder.parse(archXML); // Generar un objeto transformer para realizar transform XSL TransformerFactory tFactory = TransformerFactory.newInstance(); StreamSource stylesource = new StreamSource(archXSL); Transformer transformer = tFactory.newTransformer(stylesource); DOMSource source = new DOMSource(document); ByteArrayOutputStream outputByteArray = new ByteArrayOutputStream(); StreamResult result = new StreamResult(outputByteArray); transformer.transform(source, result); System.out.println(outputByteArray); } catch (Exception e) { e.printStackTrace(); } } }

Practica XSLT

Crear un archivo XSLT para a partir del

archivo students.xml genere una salida en

HTML como la siguiente:



98

Nombre HW1 HW2 Proy Final Prom

Jorge

Medina

70 75 80 85 77.5

Edgar

Gonzalez

80 90 90 70 82.5

Documents

XML