Xml

919 views
660 views

Published on

XML es un lenguaje de marcas desarrollado por el World Wide Web.

Published in: Software
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
919
On SlideShare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
4
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Xml

  1. 1. Tecnología XML
  2. 2. Contenidos XML DTD Schema XML Parsing SAX API DOM API XSLT 2
  3. 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 3
  4. 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. 4
  5. 5. XML describe estructura ysemántica<?xml version="1.0" encoding="ISO-8859-1"?><!DOCTYPE comedor SYSTEM "comedor.dtd"><comedor> <fabricante>Muebles Carcoma</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
  6. 6. HTML describe formato<html> <head><title>Comedor</title></head> <body> <h1>Comedor</h1> <p>Fabricante: Muebles Carcoma</p> <ul> <li><b>Mesa redonda de madera de arce</b></li> <li><b>Silla de madera de haya</b></li> <li><b>Librería de madera de roble</b></li> </ul> </body></html> 6
  7. 7. Ventajas XML Una de las mayores utilidades de XML es poder etiquetar los datos con su significado (self- describing data). Permite estructurar la información. Obtenemos una mayor eficiencia y optimización en el tratamiento automático de la información. XML es la base de la nueva generación de aplicaciones web Siendo muy utilizado para el intercambio de datos. 7
  8. 8. Usos XML Sitios web Permite separar contenido y presentación Comunicación Intercambio de datos entre servicios web Configuración de aplicaciones Descriptores de despliegue en servidores J2EE Herramienta Apache ANT Frameworks de desarrollo 8
  9. 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 9
  10. 10. Instrucciones deprocesamiento Las PI son instrucciones para el procesador del documento XML. Siempre hay al menos una PI, que pertenece al prólogo del documento: <?xml version="1.0" encoding="ISO 8859- <?xml version="1.0" encoding="ISO-8859-1"?> ="ISO- <saludo> Hola, mundo! </saludo> 10
  11. 11. Comentarios en XML Los comentarios no se procesan. Tienen la siguiente sintaxis: <!-- Esto es un comentario --> 11
  12. 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> 12
  13. 13. Elementos vs. Atributos Demasiados atributos hacen que los documentos XML sean difíciles de leer. No es correcto estructurar un documento mediante atributos: <CLIENTE NIF="44777333" NOMBRE="Jose García“ FECHA="Octubre 15, 2008“ CODIGO=“008“ ARTICULO="Tomates“ PRECIO="1.25" /> 13
  14. 14. Elementos vs. Atributos (cont)<CLIENTE NIF="44777333"> <NOMBRE>José García</NOMBRE> <FECHA>Octubre 15, 2008</FECHA> <PEDIDO> <ARTICULO CODIGO="008"> <DESCRIPCION>Tomates</DESCRIPCION> <PRECIO>1.25</PRECIO> </ARTICULO> </PEDIDO></CLIENTE> 14
  15. 15. Referencias a entidades Las referencias a entidades sirven para insertar un determinado contenido definido previamente. En la DTD: <!ENTITY Empresa "Muebles Carcoma"> En el documento XML: <pie>Creado por &Empresa;</pie> 15
  16. 16. Códigos de escape Existen 5 referencias a entidades predefinidas: &amp; es el carácter & &lt; es el carácter < &gt; es el carácter > &apos; es el carácter &quot; es el caracter " &perc; es el caracter % 16
  17. 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[ ![CDATA[<saludo>Hola, mundo!</saludo>]]> ![CDATA[ <![CDATA[< ![CDATA[<abc>(123)<def>(456)<ghi>(789)]]> ![CDATA[< 17
  18. 18. 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) Esquemas XML 18
  19. 19. Document Type Definitions(DTDs) Especifican la estructura y sintaxis de un documento XML. gruposlab.dtd <!ELEMENT grupo (estudiante)*> <!ELEMENT estudiante (#PCDATA)> <!ATTLIST estudiante dni CDATA #REQUIRED tutor CDATA #IMPLIED> 19
  20. 20. Document Type Definitions(cont)<?xml version="1.0" encoding="ISO-8859-1"?> "gruposlab.dtd gruposlab.dtd"><!DOCTYPE mensaje SYSTEM "gruposlab.dtd"><grupo> <estudiante dni="44777333"> José García </estudiante> <estudiante dni="44888444"> Juan González </estudiante> <estudiante dni="44999555" tutor="33666222"> Antonio Martínez </estudiante></grupo> 20
  21. 21. 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
  22. 22. Ejemplo Schema DTD :<!ELEMENT factura (cliente, pedido)*><!ELEMENT cliente (#PCDATA)><!ELEMENT pedido (#PCDATA)><!ATTLIST factura numero CDATA #REQUIRED><!ATTLIST factura fecha CDATA #REQUIRED> XML Schema:<xsd:element name="factura"> <xsd:complexType mixed="true"> <xsd:sequence> <xsd:element name="cliente" type="xsd:string"/> <xsd:element name="pedido" type="xsd:string"/> </xsd:sequence> <xsd:attribute name="numero" type="xsd:decimal" use="required"/> <xsd:attribute name="fecha" type="xsd:date" use="required"/> </xsd:complexType></xsd:element> 22
  23. 23. Ejemplo Schema (cont) Documento XML:<?xml version="1.0"?><factura numero="110" fecha="2008-10-20"> <cliente>44555777</cliente> <pedido>33308</pedido></factura> 23
  24. 24. XML Schema (I) Definir un esquema:<?xml version="1.0" encoding="UTF-8"?><xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">…</xsd:schema> Elemento simple:<xsd:element name="nombre" type="xsd:string" /> Atributo:<xsd:atribute name="edad" type="xsd:decimal" /><xsd:atribute name="codigo" type="xsd:decimal" use="required" /> use="required" Grupo de atributos:<xsd:attributeGroup name="Articulo"> <xsd:attribute name="cantidad" type="xsd:decimal" /> <xsd:attribute name="descripcion" type="xsd:string" /> <xsd:attribute name="precio" type="xsd:decimal" /></xsd:attributeGroup> 24
  25. 25. XML Schema (II) Elemento complejo:<xsd:element name="amigo"> name="amigo"> <xsd:complexType> <xsd:sequence> <xsd:element name="apellidos" type="xsd:string" /> <xsd:element name="nombre" type="xsd:string" /> </xsd:sequence> </xsd:complexType></xsd:element xsd:element></xsd:element><xsd:complexType name="Persona"> name="Persona"> <xsd:sequence> <xsd:element name="apellidos" type="xsd:string" /> <xsd:element name="nombre" type="xsd:string" /> </xsd:sequence></xsd:complexType xsd:complexType></xsd:complexType> name="amigo" type="Persona"<xsd:element name="amigo" type="Persona" /> 25
  26. 26. XML Schema (III) Podemos restringir el número de ocurrencias en la secuencia de elementos que forman un tipo complejo usando: minOccurs Define el mínimo de ocurrencias para un elemento: <xsd:element name="cliente" type="xsd:string" minOccurs="1" /> minOccurs="1" maxOccurs Define el máximo de ocurrencias para un elemento: <xsd:element name="cliente" type="xsd:string" maxOccurs="5" /> maxOccurs="5" <xsd:element name="cliente" type="xsd:string" minOccurs="1" maxOccurs="unbounded /> unbounded" unbounded 26
  27. 27. XML Schema (IV) Tipos de datos: xsd:boolean Tipo lógico (true o false). xsd:date Fecha en formato “aaaa-mm-dd”. xsd:decimal Valor numérico (de cualquier tipo). xsd:string Cadena de caracteres. xsd:time Hora en formato “hh:mm:ss.sss”. xsd:short , xsd:integer , xsd:long Tipos de datos enteros compatibles con JAVA. xsd:float , xsd:double Tipos de datos flotantes compatibles con JAVA. 27
  28. 28. XML Schema (V) Tipos de datos propios: <xsd:simpleType name="Cuenta"> <xsd:restriction base="xsd:string"> <xsd:pattern value=“d{4}-d{4}-d{2}-d{10}” /> </xsd:restriction> </xsd:simpleType> Simbolos para crear patrones: . cualquier carácter. d cualquier dígito. D cualquier carácter que no sea dígito. s cualquier espacio en blanco. S cualquier carácter que no sea espacio en blanco. [0-9] conjunto de valores de 0-9. [A-Za-z] conjunto de valores de A-Z o de a-z. 28
  29. 29. XML Schema (VI) x* cero o más ocurrencias de x, donde x puede ser cualquier carácter o patrón. x? cero o una ocurrencia. x+ una o más ocurrencias. x{4} cuatro x seguidas, donde x puede ser cualquier carácter o patrón. x{4,} al menos cuatro seguidas. x{4,9} entre cuatro y nueve seguidas. Especificar la precisión y la escala: <xsd:precision value="6" /> value= El contenido del elemento debe tener como mucho 6 dígitos, contando la parte entera y la decimal. <xsd:scale value="3" /> value= El contenido debe tener como máximo 3 dígitos decimales. 29
  30. 30. XML Schema (VII) Especificar un intervalo de valores: <xsd:maxInclusive value="3500" /> value="3500" El valor debe ser menor o igual a 3500. <xsd:maxExclusive value="3500" /> value="3500" El valor debe ser menor a 3500. <xsd:minInclusive value="3500" /> value="3500" El valor debe ser mayor o igual a 3500. <xsd:minExclusive value="3500" /> value="3500" El valor debe ser mayor a 3500. Especificar la longitud del contenido: <xsd:length value="15" /> value="15" El contenido del elemento debe tener exactamente 15 caracteres. <xsd:maxLength value="15" /> value="15" El contenido debe tener máximo 15 caracteres. <xsd:minLength value="15" /> value="15" 30 El contenido debe tener mínimo 15 caracteres.
  31. 31. XML Schema (VIII) Predefinir el contenido de un elemento: <xsd:element name="Empresa" type="xsd:string" fixed="Gua S.A" /> fixed="Gua S.A" =" Si el elemento está presente en el docuemento, debe ser el mismo que el que indica el atributo fixed. Y si el atributo no está presente, el procesador ofrecerá el valor. <xsd:element name="Empresa" type="xsd:string" default="Gua S.A" /> default="Gua S.A" =" Si el elemento no aparece en el documento, el procesador se encargará de ofrecer el valor contenido en el atributo default. default y fixed son mutuamente exclusivos. Valor predefinido de un atributo: <xsd:atribute name="Genero" type="xsd:string" use="fixed" use="fixed fixed" value="Mujer" value="Mujer" /> <xsd:atribute name="Genero" type="xsd:string" use="default" default" use="default value="Mujer" value="Mujer" /> Sucede lo mismo que para los elementos. 31
  32. 32. XML Schema (IX)Indicar un conjunto de valores aceptables:<xsd:element name="Pais"> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:enumeration value="ES" /> <xsd:enumeration value="UK" /> <xsd:enumeration value="FR" /> </xsd:restriction> </xsd:simpleType></xsd:element>Hacer referencia a un esquema XML:<?xml version="1.0" ?><raiz xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.dominio.es/schemas/miXMLS chema.xsd" />Por ejemplo:<pedido xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" pedido xsi:noNamespaceSchemaLocation="pedido.xsd /> pedido.xsd" pedido.xsd 32
  33. 33. XML bien formado y/o XMLvá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 estar bien formados, siguen las reglas de una gramática (definida en un DTD o XML Schema). 33
  34. 34. Reglas para que undocumento 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. 34
  35. 35. Reglas para que undocumento sea válido Para que un documento sea válido debe declarar el DTD o XML Schema contra el cual debe validarse. Para validar contra DTD 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.rae.es/dtds/saludo.dtd"> También se puede insertar el DTD entero en ese punto, en lugar de referenciar al fichero. Para validar contra XML Schema se hace incluyendo la referencia en el documento XML:<saludo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.rae.es/schemas/ saludo.xsd" /> 35
  36. 36. Lenguajes basados en XML Chemical Markup Language (CML) Mathematical Markup Language (MathML) Channel Definition Format (CDF) Synchronized Multimedia Integration Language (SMIL) eXtensible HyperText Markup Language (XHTML) Scalable Vector Graphics (SVG) Web Services (SOAP y WSDL) Voice Markup Language (VoiceML) Wireless Markup Language (WML) Geography Markup Language (GML) 36
  37. 37. Herramientas de XML Editores XML Spy, www.xmlspy.com XML Copy Editor, xml-copy-editor.sourceforge.net Vex, vex.sourceforge.net XML Parsers (Parseadores) Lee un documento XML. Verifica que XML está bien formado. Verifican que XML es válido. Expat, escrito en C, expat.sourceforge.net Lark, escrito en Java, www.textuality.com/Lark Xerces, proyecto de apache, xerces.apache.org XML Validators (Validadores) Verifican que XML es válido XML.coms Validator basado en Lark (xml.com) 37
  38. 38. Ejercicios (I) Ejercicio propuesto: Definir un documento cartelera.xml que soporte la información referente a la cartelera de uno o varios cines. Crear un XML Schema para poder validarlo. La información soportada debe ser la siguiente: Cine Nombre, dirección y población Película Título, director y actores Sesión Hora 38
  39. 39. Ejercicios (II) Ejercicio propuesto: Definir un documento clinica.xml que soporte la información referente a las citas que debe atender cada médico. Crear un XML Schema para poder validarlo. La información soportada debe ser la siguiente: Clínica Fecha Doctor Nombre y especialidad Paciente Cita, NSS y nombre. 39
  40. 40. ¿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… JAXP API de Java para procesamiento XML. XML define datos portables al igual que Java define código portable. 40
  41. 41. XML Parsing Documento XML Aplicación Parser XML XML XML DTD XML Schema Parsing: Proceso de analizar una secuencia de símbolos a fin de determinar su estructura gramatical con respecto a una gramática formal dada. Un parseador (parser) es una aplicación o herramienta que lleva a cabo esta tarea. El parseo transforma una entrada de texto en una estructura de datos (usualmente un árbol) que es apropiada para ser procesada. 41
  42. 42. XML Parsing (cont) SAX Define un interfaz dirigido por eventos (event-driven) para el procesamiento de un documento XML. Definido por David Megginson: 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 42
  43. 43. Simple API for XML: SAX Analizador o parser SAX: Detecta cuándo empieza y termina un elemento, el documento o un conjunto de caracteres, etc.. (genera eventos). Gestiona espacios de nombres. Comprueba que el documento está bien formado. Las aplicaciones necesitan implementar un manejador/es para 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
  44. 44. ¿Cómo funciona SAX? XML Document SAX Objects<?xml version=“1.0”?> Parser startDocument<addressbook> Parser startElement <person> <name>Jose Garcia</name> Parser startElement & characters <email>joseg@empresa.es</email> Parser startElement & characters </person> Parser endElement <person> Parser startElement <name>Juan Gonzalez</name> Parser startElement & characters <email>juang@empresa.es</email> Parser startElement & characters </person> Parser endElement</addressbook> Parser endElement & endDocument 44
  45. 45. JAXP SAX La clase SAXParserFactory que permite crear una instancia de un objeto SAXParser. SAXParserFactory factory = SAXParserFactory.newInstance(); SAXParser saxParser = factory.newSAXParser(); El objeto SAXParser tiene un método parse(archivo, manejador) que inicia el procesamiento. Es necesario crear un objeto DefaultHandler, denominado manejador de contenido, el cual dispone de una serie de métodos que son invocados cuando analizador detecta determinados eventos al leer documento. 45
  46. 46. DefaultHandlervoid startDocument() Recibe notificación de comienzo de documento.void endDocument() Recibe notificación de final de documento.void startElement(String uri, String localName, String name, Attributes attributes) Recibe notificación de comienzo de elemento.void endElement(String uri, String localName, String name) Recibe notificación de final de elemento.void characters(char[] ch, int start, int length) Recibe notificación de caracteres encontrados dentro de un elemento.void error(SAXParserException e) Recibe notificación de error recuperable. 46
  47. 47. Ejemplo SAX Parsing I <?xml version="1.0" encoding="ISO-8859-1"?> <libro> <capitulo> <numero>Uno</numero> <titulo>Introducción</titulo> </capitulo> <capitulo> <numero>Dos</numero> <titulo>Servlets</titulo> </capitulo> <capitulo> <numero>Tres</numero> <titulo>JSP</titulo> </capitulo> </libro> 47
  48. 48. Ejemplo SAX Parsing IIimport java.io.File;import java.io.IOException;import javax.xml.parsers.ParserConfigurationException;import javax.xml.parsers.SAXParser;import javax.xml.parsers.SAXParserFactory;import org.xml.sax.Attributes;import org.xml.sax.SAXException;import org.xml.sax.helpers.DefaultHandler;public class ParserSAX extends DefaultHandler { // Constantes de validación contra XMLSchema private final String JAXP_SCHEMA_LANGUAGE = "http://java.sun.com/xml/jaxp/properties/schemaLanguage"; private final String W3C_XML_SCHEMA = "http://www.w3.org/2001/XMLSchema"; protected boolean pNumero; protected boolean pTitulo; protected StringBuilder cNumero; protected StringBuilder cTitulo; .. Constructor y métodos startElement, characters, endElement ..} 48
  49. 49. Ejemplo SAX Parsing III Constructor.. public ParserSAX(File archivo) { SAXParserFactory factory = SAXParserFactory.newInstance(); try { SAXParser parser = factory.newSAXParser(); parser.parse(archivo, this); } catch (ParserConfigurationException e) { System.out.println(e.getMessage()); } catch (SAXException e) { System.out.println(e.getMessage()); } catch (IOException e) { System.out.println(e.getMessage()); } } 49
  50. 50. Ejemplo SAX Parsing IV Método startElement.. public void startElement(String uri, String localName, String name, Attributes attributes) { if (name.equalsIgnoreCase("capitulo")) { cNumero = null; cTitulo = null; } else if (name.equalsIgnoreCase("numero")) { pNumero = true; cNumero = new StringBuilder(); } else if (name.equalsIgnoreCase("titulo")) { pTitulo = true; cTitulo = new StringBuilder(); } } 50
  51. 51. Ejemplo SAX Parsing V Método characters.. public void characters(char[] ch, int start, int length) { if (pNumero) cNumero.append(ch, start, length); if (pTitulo) cTitulo.append(ch, start, length); } 51
  52. 52. Ejemplo SAX Parsing VI Método endElement.. public void endElement(String uri, String localName, String name) { if (name.equalsIgnoreCase("capitulo")) { System.out.println(name); if (cNumero != null) System.out.println(cNumero.toString()); if (cTitulo != null) System.out.println(cTitulo.toString()); } else if (name.equalsIgnoreCase("numero")) { pNumero = false; } else if (name.equalsIgnoreCase("titulo")) { pTitulo = false; } 52 }
  53. 53. Ejemplo SAX Parsing VIIAplicación..public class Principal { public static void main(String[] args) { File archivo = new File("libro.xml"); System.out.println("Parser SAX"); System.out.println("----------"); new ParserSAX(archivo); }} 53
  54. 54. Validación SAX contra DTD// Obtener referencia al SAXFactorySAXParserFactory factory = SAXParserFactory.newInstance();// Habilitar validaciónfactory.setValidating(true);// Crear una nueva instancia del parseadorSAXParser parser = factory.newSAXParser();// Parsear el documento contenido en el archivoparser.parse(archivo, this); // Método para controlar un error SAX public void error(SAXParseException e) { System.out.println(e.getMessage()); } 54
  55. 55. Validación SAX contraXMLSchema// Obtener referencia al SAXFactorySAXParserFactory factory = SAXParserFactory.newInstance();// Habilitar validación y espacio de nombresfactory.setValidating(true);factory.setNamespaceAware(true);// Crear una nueva instancia del parseadorSAXParser parser = factory.newSAXParser();// Configurar parametros de validación contra XMLSchemaparser.setProperty(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);// Parsear el documento contenido en el archivoparser.parse(archivo, this); // Método para controlar un error SAX public void error(SAXParseException e) throws SAXException { throw new SAXException("XML no válido."); } 55
  56. 56. Ejercicios Ejercicio propuesto: realizar una aplicación que analice (realizar parseo) del documento cartelera.xml utilizando SAX Parsing. Aplicar el XML Schema creado para poder validar el documento cartelera.xml. Crear el conjunto de clases y colecciones de objetos necesarias para procesar la información del documento. La aplicación debe recorrer las diferentes colecciones de objetos generadas y mostrar los atributos de los elementos contenidos en ellas. 56
  57. 57. W3C Document Object Model(DOM) Los 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. Los atributos de un elemento también son contemplados como subnodos. El documento se carga totalmente en memoria como una estructura en árbol. Ventaja: es fácil acceder a datos en función de la jerarquía de los elementos, así como modificar el contenido de los documentos e incluso crearlos desde cero. Desventaja: el coste en tiempo y memoria que conlleva 57 construir el árbol.
  58. 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> 58
  59. 59. Documento XML como unárbol de nodos (cont) 59
  60. 60. W3C XML DOM Objects Document – El objeto documento. ProcessingInstruction – Una instrucción de procesamiento. Element – un elemento XML. Attribute – un attributo. Text – texto contenido en un elemento o atributo. CDATAsection – sección CDATA. EntityReference – Referencia a una entidad. Comment – Contenido de un comentario de XML. DocumentType – Referencia al elemento DOCTYPE. DocumentFragment – Referencia a un fragmento del documento. Notation – Contenedor de una anotación. 60
  61. 61. JAXP DOMPara conseguir una instancia del analizador DOM através de JAXP usamos las clases DocumentBuildery DocumentBuilderFactory:DocumentBuilderFactory fact = DocumentBuilderFactory.newInstance();// Construir nueva instanciaDocumentBuilder parser = fact.newDocumentBuilder();El método parse(…) analiza el fichero entrada ydevuelve un objeto Document que representa aldocumento parseado.Document documento = parser.parse(archivo); 61
  62. 62. Objetos relacionados conNodos Node Representa un nodo en el árbol de un documento. NodeList Representa una lista de objetos nodo. NamedNodeMap Permite la interacción y el acceso por nombre a una colección de atributos. 62
  63. 63. Métodos del objectoDocument Attr createAttribute(String name) Crea un atributo con el nombre dado. Element createElement(String tagName) Crea un elemento con el nombre de etiqueta 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 el id. NodeList getElementsByTagName(String tagName) Devuelve una lista de elementos identificados por el nombre de etiqueta dado. 63
  64. 64. Métodos del interfaz Node NamedNodeMap getAttributes() Devuelve lista de atributos en un nodo. Node getFirstChild() Devuelve el primer hijo de este nodo. Node getLastChild() 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
  65. 65. Métodos del interfaz NodeListy 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
  66. 66. Ejemplo DOM I<?xml version="1.0" encoding="ISO-8859-1"?><peliculas> <pelicula codigo="01"> <titulo>Matrix</titulo> <director>Hermanos Wachowski</director> <actores>Keanu Reeves, Laurence Fishburne</actores> </pelicula> <pelicula codigo="02"> <titulo>El club de la lucha</titulo> <director>David Fincher</director> <actores>Brad Pitt, Edward Norton</actores> </pelicula> <pelicula codigo="03"> <titulo>Trainspotting</titulo> <director>Danny Boyle</director> <actores>Ewan McGregor</actores> </pelicula></peliculas> 66
  67. 67. Ejemplo DOM II root peliculascodigo pelicula …. pelicula codigo titulo director actores titulo director actores 67
  68. 68. Ejemplo DOM IIIimport java.io.File;import java.io.IOException;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.parsers.ParserConfigurationException;import org.w3c.dom.Document;import org.w3c.dom.NamedNodeMap;import org.w3c.dom.Node;import org.w3c.dom.NodeList;import org.xml.sax.SAXException;public class ParserDOM { .. Constructor y método tratarNodos ..} 68
  69. 69. Ejemplo DOM IV Constructor.. public ParserDOM(File archivo) { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); try { DocumentBuilder parser = factory.newDocumentBuilder(); Document doc = parser.parse(archivo); tratarNodo(doc); } catch (ParserConfigurationException e) { System.out.println(e.getMessage()); } catch (SAXException e) { System.out.println(e.getMessage()); } catch (IOException e) { System.out.println(e.getMessage()); } } 69
  70. 70. Método tratarNodo..public 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.COMMENT_NODE: ... break; }} 70
  71. 71. Ejemplo DOM VI case Node.DOCUMENT_NODE: Document doc = (Document)nodo; tratarNodo(doc.getDocumentElement()); break; case Node.ELEMENT_NODE: System.out.println(nodo.getNodeName().toUpperCase()); // Tratar nodos atributo con recursividad NamedNodeMap ats = nodo.getAttributes(); for (int i = 0; i < ats.getLength(); i++) { tratarNodo(ats.item(i)); } // Tratar nodos hijo con recursividad NodeList hijos = nodo.getChildNodes(); for (int i = 0; i < hijos.getLength(); i++) { tratarNodo(hijos.item(i)); } break; 71
  72. 72. Ejemplo DOM VII case Node.ATTRIBUTE_NODE: System.out.println(nodo.getNodeName() + " = " + nodo.getNodeValue() + ""); break; case Node.TEXT_NODE: if (nodo.getParentNode().getNodeName().equals("titulo") || nodo.getParentNode().getNodeName().equals("director") || nodo.getParentNode().getNodeName().equals("actores")) System.out.println(nodo.getNodeValue()); break; case Node.CDATA_SECTION_NODE: System.out.println("CDATA: " + nodo.getNodeValue()); break; case Node.COMMENT_NODE: System.out.println("COMENTARIO: " + nodo.getNodeValue()); break; 72
  73. 73. Ejercicios Ejercicio propuesto: realizar una aplicación que analice (realizar parseo) del documento clinica.xml utilizando DOM Parsing. Aplicar el XML Schema creado para poder validar el documento clinica.xml. Crear el conjunto de clases y colecciones de objetos necesarias para procesar la información del documento. La aplicación debe recorrer las diferentes colecciones de objetos generadas y mostrar los atributos de los elementos contenidos en ellas. 73
  74. 74. Validación DOM contra DTDDocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();// Habilitar validacióndbf.setValidating(true);DocumentBuilder db = dbf.newDocumentBuilder();// Establecer la clase manejadora de erroresdb.setErrorHandler(new ParserErrorHandler());Document d = db.parse(new File(ruta)); 74
  75. 75. Validación DOM contraXMLSchemafinal String JAXP_SCHEMA_LANGUAGE = "http://java.sun.com/xml/jaxp/properties/schemaLanguage";final String W3C_XML_SCHEMA = "http://www.w3.org/2001/XMLSchema";DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();// Habilitar validación y espacios de nombresfactory.setValidating(true);factory.setNamespaceAware(true);// Configurar parametros de validación contra XMLSchemafactory.setAttribute(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);DocumentBuilder parser = factory.newDocumentBuilder();// Establecer la clase manejadora de erroresparser.setErrorHandler(new ParseErrorHandler()); 75Document doc = parser.parse(new File(ruta));
  76. 76. Validación DOMimport org.xml.sax.ErrorHandler;import org.xml.sax.SAXParseException;public class ParserErrorHandler implements ErrorHandler { @Override public void fatalError(SAXParseException exception) throws SAXException { System.out.println(e.getMessage()); } @Override public void warning(SAXParseException exception) throws SAXException { System.out.println(e.getMessage()); } @Override public void error(SAXParseException exception) throws SAXException { System.out.println(e.getMessage()); } 76}
  77. 77. XML Namespaces (I) Permiten que un mismo documento XML tenga etiquetas de diferentes vocabularios. Si a cada uno de estos vocabularios se le da un espacio de nombres, se resuelve la ambigüedad existente entre elementos o atributos que se llamen igual. Los nombres de elementos dentro de un espacio de nombres deben ser únicos. 77
  78. 78. XML Namespaces (II)<?xml version="1.0" encoding="ISO-8859-1"?><fac:factura xmlns:fac="http://www.dominio.es/Factura" xmlns:fac= xmlns:cli= xmlns:cli="http://www.dominio.es/Cliente" xmlns:ped= xmlns:ped="http://www.dominio.es/Pedido" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsi xsi:schemaLocation=" xsi:schemaLocation http://www.dominio.es/Factura http://www.dominio.es/schemas/factura.xsd"> <fecha>2008-11-03</fecha> <cli:cliente> id>208</id> >208</id <id>208</id> <nombre>Jose García</nombre> <telefono>696999666</telefono> </cli:cliente> <ped:pedido> id>56</id> >56</id <id>56</id> <articulo>Tornillo</articulo> <precio>1.35</precio> </ped:pedido></fac:factura>Con el uso de espacios de nombres distintos, se evita la ambigüedadexistente entre las etiquetas “id” pertenecientes tanto a cliente como a 78pedido.
  79. 79. XML Namespaces (III)<?xml version="1.0" encoding="ISO-8859-1"?><xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" " " targetNamespace=" ="http://www.dominio.es/Cliente"> targetNamespace=" " <xsd:element name="cliente"> <xsd:complexType> <xsd:sequence> <xsd:element name="id" type="xsd:string“ /> <xsd:element name="nombre" type="xsd:string" /> <xsd:element name="telefono" type="xsd:string" /> </xsd:sequence> </xsd:complexType> </xsd:element></xsd:schema> 79
  80. 80. XML Namespaces (IV)<?xml version="1.0" encoding="ISO-8859-1"?><xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" " " targetNamespace=" ="http://www.dominio.es/Pedido"> targetNamespace=" " <xsd:element name=“pedido"> <xsd:complexType> <xsd:sequence> <xsd:element name="id" type="xsd:string“ /> <xsd:element name="articulo" type="xsd:string" /> <xsd:element name="precio" type="xsd:string" /> </xsd:sequence> </xsd:complexType> </xsd:element></xsd:schema> 80
  81. 81. XML Namespaces (V)<?xml version="1.0" encoding="ISO-8859-1"?><xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" " " targetNamespace=" targetNamespace=" ="http://www.dominio.es/Factura"" xmlns:cli=" ="http://www.dominio.es/Cliente" xmlns:cli=" " xmlns:ped=" ="http://www.dominio.es/Pedido"> xmlns:ped=" " namespace=" <xsd:import namespace=" ="http://www.dominio.es/Cliente" " schemaLocation=" schemaLocation=" ="http://www.dominio.es/schemas/cliente.xsd" /> " <xsd:import namespace=" namespace=" ="http://www.dominio.es/Pedido"" schemaLocation=" schemaLocation=" ="http://www.dominio.es/schemas/pedido.xsd" /> " <xsd:element name="factura"> <xsd:complexType> <xsd:sequence> <xsd:element name="fecha" type="xsd:string" /> <xsd:element ref="cli:cliente" /> ref="cli:cliente" ="cli:cliente <xsd:element ref="ped:pedido" /> ref="ped:pedido" ="ped:pedido </xsd:sequence> </xsd:complexType> </xsd:element></xsd:schema> 81
  82. 82. Ejercicios Ejercicio propuesto: realizar una aplicación que analice el documento de ejemplo taller.xml utilizando cualquiera de las APIs de parseo (SAX o DOM). Crear los XMLSchemas necesarios para poder validar el documento usando espacios de nombre (Namespaces). El parseador debe validar el documento contra su XMLSchema referenciado. Crear el conjunto de clases y colecciones de objetos necesarias para procesar la información del documento. La aplicación debe recorrer las diferentes colecciones de objetos generadas y mostrar los atributos de los elementos contenidos en ellas. 82
  83. 83. Serialización en XML (I) Para serializar objetos en un fichero XML y poderlos recuperar posteriormente, el paquete java.beans proporciona las clases XMLEncoder y XMLDecoder. Este tipo de serialización solo puede ser usada con objetos de tipo POJO (Plain Old Java Object). Se denomina a un objeto de tipo POJO, cuando la clase a la que pertenece: Siempre cuenta con el constructor por defecto. Solo hereda de Object o de cualquiera de las clases nativas de J2SE. 83
  84. 84. public class Persona { private String nombre = new String(); private int edad = 0; // Siempre debe tener constructor por defecto public Persona() {} public Persona(String nombre, int edad) { this.nombre = nombre; this.edad = edad; } public String getNombre() { return nombre; } public void setNombre(String nombre) { this.nombre = nombre; } public int getEdad() { return edad; } public void setEdad(int edad) { this.edad = edad; } 84}
  85. 85. Serialización en XML (III) Clase XMLEncoder Constructor: XMLEncoder(OutputStream os) El objeto OutputStream que hay que proporcionar al constructor será un objeto FileOutputStream asociado a un fichero. Métodos: void writeObject(Object objeto) Realiza la escritura de un objeto serializado en disco. void close() Cierra la conexión con el fichero y libera los recursos utilizados por esta. 85
  86. 86. Serialización en XML (IV) String ruta = "objetos.xml"; FileOutputStream fos = new FileOutputStream(ruta); XMLEncoder xe = new XMLEncoder(fos); xe.writeObject(new Persona("jose", 30)); xe.writeObject(new Persona("juan", 40)); xe.writeObject(new Persona("antonio", 20)); xe.close(); 86
  87. 87. Serialización en XML (V) Clase XMLDecoder Constructor: XMLDecoder(InputStream is) El objeto InputStream que hay que proporcionar al constructor será un objeto FileInputStream asociado a un fichero. Métodos: Object readObject() Realiza la lectura de un objeto serializado en disco. Se deberá realizar un casting al tipo original para evitar que se produzca una excepción ClassNotFoundException. 87
  88. 88. Serialización en XML (VI) String ruta = "objetos.xml"; FileInputStream fis = new FileInputStream(ruta); XMLDecoder xd = new XMLDecoder(fis); try { while (true) { Persona persona = (Persona)xd.readObject(); System.out.println(persona); } } catch (ArrayIndexOutOfBoundsException e) { } finally { xd.close(); } 88
  89. 89. XSL (eXtensible StylesheetLanguage) XSL es una familia de lenguajes basados en el estándar XML que permite describir cómo la información contenida en un documento XML debe ser transformada o formateada para su presentación. Esta familia está formada por: XPath, es una sintaxis para acceder o referirse a porciones de un documento XML. XSLT (XSL - Transformaciones), que permite convertir documentos XML de una sintaxis a otra (por ejemplo, de un XML a otro o a un documento HTML). 89
  90. 90. XPath (I) XPath es un lenguaje declarativo, que sirve para “navegar” dentro de un documento XML, seleccionando elementos, atributos, etc. Como ya sabemos, la estructura de un documento XML se compone de nodos, estos nodos pueden ser elementos o atributos. Los elementos pueden ser hijos/padres de otros atributos, etc. Se basa básicamente en expresiones (expresiones XPath) similares a las expresiones regulares, pero diseñadas para la estructura jerárquica de XML. 90
  91. 91. XPath (II) – Expresiones /factura/cliente/nombre Seleccionaría el elemento nombre que está dentro del elemento cliente y este a su vez dentro de factura. //nombre Se seleccionan TODOS los elementos nombre. /empresa/factura//nombre Se seleccionan TODOS los elementos nombre contenidos dentro del elemento factura. //@fecha Se seleccionan TODOS los atributos fecha. /empresa/factura/albaran/@fecha Se selecciona el atributo fecha del elemento albaran. /empresa/factura/albaran[3] Se selecciona el tercer elemento albaran dentro de factura. //coche[@color="ROJO"] Se seleccionan todos los elementos coche que tengan su atributo color igual a ROJO. count(/taller/coche//averia/@fecha) Devuelve el número de atributos fecha de elementos averia dentro del 91 elemento coche, hijo de taller.
  92. 92. XPath (III)<?xml version="1.0" encoding="UTF-8"?><factura> <albaran numero="1"> <fecha>2008-11-03</fecha> <importe>2500</importe> </albaran> <albaran numero="2"> <fecha>2008-11-05</fecha> <importe>1250</importe> </albaran> <albaran numero="3"> <fecha>2008-11-07</fecha> <importe>5000</importe> </albaran></factura> 92
  93. 93. XPath (IV)J2SE 5.0 nos provee de una API para trabajar conexpresiones XPath.Se encuentra en el paquete javax.xml.xpath.Creación de una expresión XPath: XPathFactory factory = XPathFactory.newInstance(); XPath xpath = factory.newXPath(); Le pasamos la expresión como parametro String al método compile() del objeto XPath. Y si es correcta, devuelve un objeto XPathExpression:XPathExpression expr = xpath.compile("//albaran[@numero>2]/fecha[1]"); Si la expresión no era correcta se lanza una TransformerException. 93
  94. 94. XPath (V) También es necesario crear un objeto Document para pasarlo al objeto XPathExpression:DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();Document doc = factory.newDocumentBuilder().parse("factura.xml"); Ahora para evaluar la expresión en un documento XML, llamamos al método evaluate() de XPathExpression: String result = expr.evaluate(doc, XPathConstants.STRING); El primer parámetro es el objeto Document, y el segundo es una constante que indica que tipo de dato esperamos recibir como resultado. Por último, mostramos el resultado: System.out.println(result); 94
  95. 95. Ejercicios Ejercicio propuesto: realizar una aplicación que recupere información del documento taller.xml utilizando XPath. El usuario podrá solicitar por consola la siguiente información: Nombre, dirección o teléfono de un cliente, introduciendo su id o dni. Los nombres y categoría profesional de los mecanicos que repararon una avería, introduciendo la fecha en que se solucionó la avería y el número de reparación. La denominación y cantidad de las piezas empleadas para realizar una reparación, introduciendo el número de ésta. 95
  96. 96. eXtensible Style LanguageTransformations XSLT (I) Con la diversidad de lenguajes de presentación que hay (WML, HTML, XHTML) existen dos alternativas para desarrollar las aplicaciones: Desarrollar diferentes 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. 96
  97. 97. eXtensible Style LanguageTransformations XSLT (II) 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 está detrás. 97
  98. 98. eXtensible Style LanguageTransformations XSLT (III) 98
  99. 99. eXtensible Style LanguageTransformations XSLT (IV) Para crear una transformación se necesita: Un documento XML a transformar: estudiantes.xml Una hoja de estilo (.xsl) que especifique la transformación: estudiantes.xsl 99
  100. 100. eXtensible Style LanguageTransformations XSLT (V)<?xml version="1.0"?><curso> <nombre id="xj_2910">Programando XML en Java</nombre> <profesor id="lt">Linus Torvalds</profesor> <estudiante id="bg"> <nombre>Bill Gates</nombre> <p1>30</p1> <p2>70</p2> <practica>80</practica> <final>85</final> </estudiante> <estudiante id="sj"> <nombre>Steve Jobs</nombre> <p1>80</p1> <p2>90</p2> <practica>100</practica> <final>40</final> </estudiante></curso> 100
  101. 101. eXtensible Style LanguageTransformations XSLT (VI)<?xml version="1.0"?><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:template match="curso"> match="curso curso"> <HTML> <HEAD><TITLE>Lista de estudiantes</TITLE></HEAD> <BODY> <xsl:apply-templates select="estudiante"/> xsl:apply- select="estudiante"/> estudiante </BODY> </HTML> </xsl:template xsl:template> </xsl:template> <xsl:template match="estudiante"> match="estudiante estudiante"> <P><xsl:value-of select="nombre"/> <xsl:value- select="nombre"/></P> nombre"/> </xsl:template xsl:template> </xsl:template></xsl:stylesheet></xsl:stylesheet> xsl:stylesheet 101
  102. 102. eXtensible Style LanguageTransformations XSLT (VII) Resultado: <HTML> <HEAD> <TITLE>Lista de estudiantes</TITLE> </HEAD> <BODY> <P>Bill Gates</P> <P>Steve Jobs</P> </BODY> </HTML> 102
  103. 103. eXtensible Style LanguageTransformations XSLT (VIII) Formas de uso de XSLT: Visualizar directamente en un navegador el documento XML que tiene asociada una hoja XSLT. <?xml-stylesheet type="text/xsl" href="estudiantes.xsl"?> Ejecutar un 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 una aplicación en el servidor y enviar a los clientes sólo el resultado de la transformación. 103
  104. 104. XSLT (IX)Elementos en un documento XSLT: xsl:stylesheet elemento raiz: <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> xsl:template es usado para crear plantillas: Cada plantilla define la transformación que se debe realizar en el fragmento del documento XML asociado a este elemento. El atributo match asocia la plantilla a un elemento XML seleccionado usando una expresión Xpath. "/" – expresión perteneciente al nodo raiz del documento XML. xsl:apply- xsl:apply-templates Aplica las plantillas definidas para todos los hijos de un nodo seleccionado. 104
  105. 105. XSLT (X) xsl:value- xsl:value-of permite recuperar el valor de un nodo. El atributo select define la expresión XPath usada para la selección del nodo. <xsl:template match="curso"> <xsl:value-of select="estudiante"/> </xsl:template> Si queremos seleccionar varios podemos hacer: <xsl:template match="curso"> <xsl:apply-templates select="estudiante"/> </xsl:template> <xsl:template match="estudiante"> <xsl:value-of select="."/> </xsl:template> xsl:for- O usar xsl:for-each <xsl:template match=“curso"> <xsl:for-each select="estudiante"> <xsl:value-of select="."/> </xsl:for-each> </xsl:template> 105
  106. 106. XSLT (XI) xsl:choose permite realizar distintos procesamientos en función de los datos: Se compone de elementos xsl:when Un elemento opcional xsl:otherwise <xsl:choose> <xsl:when test="expresión" test="expresión"> ... alguna salida ... </xsl:when> <xsl:otherwise> ... alguna salida .... </xsl:otherwise> </xsl:choose> xsl:if permite procesar o no un elemento en función de una condición: La condición se define en su atributo test. <xsl:if test="expresión" test="expresión"> ... salida ... </xsl:if> 106
  107. 107. Expresiones Xpath para el atributo match o select: Seleccionar el nodo raiz: <xsl:template match="/"> ... </xsl:template> Seleccionar un elemento: <xsl:template match=“estudiante"> ... </xsl:template> Seleccionar hijos de un elemento: <xsl:template match="curso/estudiante"> ... </xsl:template> <xsl:template match="curso/*/nombre"> ... </xsl:template> Seleccionar descendientes de un elemento: <xsl:template match="curso//nombre"> ... 107 </xsl:template>
  108. 108. XSLT (XIII) Seleccionar atributo id: <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()"/> 108
  109. 109. XSLT (XIV) Evaluando si una condición es cierta: Si el elemento estudiante tiene un hijo nombre: <xsl:template match="estudiante[nombre]"> Cualquier elemento que tiene un elemento nombre: <xsl:template match="*[nombre]"> Elemento estudiante tiene un sub-elemento p1 o p2: <xsl:template match="estudiante[p1 | p2]"> 109
  110. 110. XSLT (XV)<?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="curso"> <xsl:apply-templates select=“estudiante"/> </xsl:template> <xsl:template match="estudiante"> <xsl:variable name="avg"> name="avg"> avg <xsl:value-of select="(p1 + p2 + practica + final) div 4"/> </xsl:variable xsl:variable> </xsl:variable> <xsl:if test="$avg > 65"> test="$avg nombre="<xsl:value-of select="nombre"/>" media="<xsl:value-of select="$avg"/>" </xsl:if xsl:if> </xsl:if> </xsl:template> 110</xsl:stylesheet>
  111. 111. XSLT (XVI) Resultado transformación: nombre="Bill Gates" media="66,25" nombre="Steve Jobs" media="77,5" 111
  112. 112. XSLT (XVII) Java JAXP provee las clases TransformerFactory y Transformer para la aplicación de XSL a un documento XML. Se encuentran en el paquete javax.xml.transform. Creación de un objeto transformador XSL: TransformerFactory factory = TransformerFactory.newInstance(); StreamSource source = new StreamSource("estudiantes.xsl"); Transformer transformer = factory.newTransformer(source); 112
  113. 113. XSLT (XVIII) Ahora para realizar la transformación del documento XML, invocamos al método transform() del objeto transformador: transformer.transform(source, result); Al que hay que pasarle 2 parametros: Un objeto StreamSource que referencia al documento XML que se quiere transformar. Un objeto StreamResult que representa el documento de salida, resultado de la transformación. StreamSource source = new StreamSource("estudiantes.xml"); StreamResult result = new StreamResult("estudiantes.html"); 113
  114. 114. Ejercicios Ejercicio propuesto: realizar una aplicación que transforme la información del documento taller.xml a formato HTML. 114

×