2.2 Parsing de documentos XML

Transcripción

1 2.2 Parsing de documentos XML

2 Introducción (1) Un documento XML se apoya en dos ideas [Obligatoria] Tiene que estar bien formado, y en consecuencia, estar construido en base a las normas de XML (los tags se abren y cierran, los tags se anidan de manera jerárquica, los atributos tienen que ir entrecomillados, etc.) [Opcional] El conjunto de elementos y atributos, y sus restricciones, pueden estar descritas formalmente en algún tipo de esquema (esquema XML, DTD, etc.) de manera que se pueda comprobar que el documento es válido Consecuencias Es posible construir parsers genéricos que comprueban que el documento (1) está bien formado, y si se desea, (2) es válido Existen parsers para los lenguajes más usuales En un lenguaje orientado a objetos, un parser XML es una librería de clases

3 Tipos de parsers Parsers tipo DOM Parsers tipo streaming Introducción (2) Parsers tipo DOM (Document Object Model) Construyen un árbol en memoria equivalente al documento XML (pueden hacerlo, dado que la sintaxis de XML sigue un modelo jerárquico) Ventajas Sencillos de utilizar: para acceder a la información del documento, basta recorrer el árbol Suelen permitir modificar/crear un árbol y generar XML a partir de él Desventajas Consumo de memoria alto en aplicaciones servidoras que reciben muchas peticiones que involucran parsear/generar documentos XML grandes (normalmente las aplicaciones servidoras sirven cada petición en un thread)

4 Introducción (y 3) Parsers tipo streaming No construyen un árbol en memoria, sino que procesan secuencialmente el documento en bloques Ventajas Mínimo consumo de memoria Especialmente útiles en las situaciones en las que los parsers de tipo DOM son prohibitivos Desventajas No todos tienen soporte para generar XML Más difíciles de usar que los parsers de tipo DOM

5 Caso de estudio: parsers Java (1) SAX (Simple API for XML) Parser tipo streaming Forma parte de Java SE (Standard Edition) API: familia de paquetes org.xml.sax Es un pequeño framework basado en eventos El programador proporciona uno o varios objetos callback a los que el parser llamará cada vez que ocurra un evento de interés (apertura de un tag, cierre de un tag, un error, etc.) Dentro de los parsers de tipo streaming es de tipo push El parser envía eventos al código escrito por el desarrollador No tiene soporte para generación de XML Disponible también para otros lenguajes

6 Caso de estudio: parsers Java (2) StAX (Streaming API for XML) Parser tipo streaming Forma parte de Java EE (Enterprise Edition) API: familia de paquetes javax.xml.stream Dentro de los parsers de tipo streaming es de tipo pull El desarrollador utiliza el API del parser para pedir los datos Tiene soporte para generación de XML DOM (Document Object Model) Parser tipo DOM El API está estandarizada por el W3C ( => disponible para varios lenguajes Forma parte de Java SE API: familia de paquetes org.w3c.dom Tiene soporte para generación de XML

7 Caso de estudio: parsers Java (3) DOM: tipos principales de nodos Paquete org.w3c.dom <<interface>> Document <<interface>> Comment <<interface>> Node <<interface>> CharacterData <<interface>> Element <<interface>> <<interface>> CDATASection 0..n <<interface>> NodeList <<interface>> Attr Representa un atributo de un elemento. Es un subtipo de Node, sin embargo, no es un nodo del árbol (los atributos de un elemento forman parte de su objeto Element)

8 Caso de estudio: parsers Java (4) DOM. Ejemplo: representación DOM de Movies.xml (apartado 2.1) (EBI) Document Element (movies) (EBI) Flechas verticales: hijos Flechas horizontales: hermanos EBI: Espacio en Blanco Ignorable (EBI) Comment (EBI) Element (movie) [La Maldición...] (EBI) Comment (EBI) Element (movie) [Amelie] (EBI) (EBI) Element (identifier) (EBI)... (EBI) Element (releasedate)... synopsis (EBI)...

9 Caso de estudio: parsers Java (5) JAXP (Java API for XML Processing) API: familia de paquetes javax.xml.parsers y javax.xml.transform Forma parte de Java SE El API Java de los parsers SAX y DOM viene definida por interfaces estándar JAXP proporciona, entre otras cosas, dos factorías abstractas (patrón Factory ), para poder crear instancias de parsers DOM y SAX Este mecanismo permite enchufar en Java SE cualquier parser SAX y DOM que implemente los interfaces Existen diversas implementaciones de parsers SAX y DOM que implementan los interfaces estándar Cualquier implementación de Java SE proporciona una implementación por defecto de los parsers SAX y DOM El código que escribe el desarrollador no depende del parser concreto que se utilice (porque trabaja contra los interfaces estándar de los parsers) NOTA: El API de StAX también viene definida por interfaces, y el propio API de StAX proporciona mecanismos para trabajar con un parser concreto

10 Caso de estudio: parsers Java (6) JDOM y DOM4J Alternativas famosas a DOM Open Source JDOM: DOM4J: Utilizan un modelo similar a DOM Tienen soporte para generación de XML Pensados para el lenguaje Java y más fáciles de usar que el API de DOM El API de DOM es demasiado tediosa de usar porque es de muy bajo nivel (no automatiza aspectos comunes) No está acoplada con el lenguaje Java (e.g. no utiliza java.util.list, sino que dispone de sus propias listas) Especialmente más fáciles que DOM cuando se trabaja con documentos orientados a datos, que es nuestro caso Utilizaremos JDOM

11 Caso de estudio: parsers Java (y 7) JAXB (Java Architecture for XML Binding) Forma parte de Java EE (Enterprise Edition) API: familia de paquetes javax.xml.bind Como siempre, un conjunto de interfaces Existen múltiples implementaciones, algunas Open Source Parsing y generación de XML automático A partir de un esquema XML, genera clases Java equivalentes a las estructuras definidas en el esquema A partir de un documento XML, crea automáticamente instancias de las clases generadas, que contienen los datos del documento A partir de instancias de las clases generadas, permite generar un documento XML Solución más sencilla que el uso de un parser de más bajo nivel, aunque quizás menos flexible cuando se utiliza un enfoque REST (apartado 3.3) En los apartados 3.4 y 3.5 (SOAP), indirectamente, utilizaremos una solución parecida a JAXB

12 JDOM (1) Tres paquetes principales para parsing/generación de XML org.jdom Clases que modelan los distintos tipos de nodos (parecido al API de DOM, pero más amigable ) de un árbol JDOM org.jdom.input Clases para construir un árbol JDOM en memoria a partir de un documento XML org.jdom.output Clases para generar un documento XML a partir de un árbol JDOM Internamente JDOM utiliza el API de SAX y/o DOM mediante JAXP

13 JDOM (2) Ilustraremos el API básica de JDOM tomando como ejemplo parte de la clase MovieXMLConversor Pertenece al subsistema Movies de los ejemplos de la asignatura (los proporcionaremos en clase de prácticas). Forma parte de los casos de estudio de los apartados 3.3 (REST) y 3.5 (SOAP) Dispone de métodos para convertir instancias de MovieInformationTO a XML, y viceversa. En particular, estudiaremos la implementación de dos métodos tomovieinformation(java.io.inputstream) : MovieInformationTO Recibe un documento XML que tiene la información de una película y crea un objeto MovieInformationTO con la misma información toxml(movieinformationto, java.io.outputstream) Recibe un objeto MovieInformationTO y genera un documento XML con la misma información

14 JDOM (3) MovieInformationTO - identifier : Long - title : String - runtime : short - releasedate : Calendar - directornames : List<String> - actornames : List<String> - genres : List<Genre> - synopsis : String El tipo Genre está declarado dentro de MovieInformationTO: public enum Genre { COM, DRA, HOR, ROM, SFI, THR}; + Constructor + Métodos get/set MovieXMLConversor + tomovieinformation(in : InputStream) : MovieInformationTO + toxml(movieinformation : MovieInformationTO, out : OutputStream) : void

15 JDOM (4) Ejemplo de un documento XML con la información de una película Elemento identifier es opcional <?xml version="1.0" encoding="utf-8"?> <!-- Amelie. --> <movie xmlns=" xmlns:xsi=" xsi:schemalocation=" Movies.xsd"> <title>amelie</title> <runtime>120</runtime> <releasedate day="19" month="10" year="2001"/> <director>jean-pierre Jeunet</director> <actor>audrey Tautou</actor>... <actor>dominique Pinon</actor> <genre>com</genre> <genre>rom</genre> <synopsis> Amelie no es una chica como las demás. Ha visto a su pez de colores deslizarse hacia las alcantarillas... </synopsis> </movie>

16 JDOM (5) Visión global de org.jdom: principales tipos de nodos y métodos Content 0..n Comment Attribute + métodos getxxxvalue() : XXX + getvalue() : String 0..n Element Document + Document(rootElement : Element) + getcontent() : List + getrootelement() : Element + Element(name : String [, ns : Namespace]) + addcontent(child : Content) : Element + addcontent(collection : Collection) : Element + getattribute(name : String [, ns : Namespace]) : Attribute + getattributevalue(name : String [, ns : Namespace]) : String + getchild(name : String [, ns : Namespace]) : Element + getchildren(name : String [, ns : Namespace]) : List + getchildnormalize(name : String [, ns : Namespace]) : String + getchildtrim(name : String [, ns : Namespace]) : String + getnormalize() : String + gettrim() : String + setattribute(name : String, value : String [, ns : Namespace]) + set(text : String)

17 JDOM (6) Representación JDOM del documento XML de ejemplo Document Comment Element (movie) (EBI) Element (title) (EBI)... (EBI) Element (releasedate)... synopsis (EBI) Flechas verticales: hijos EBI: Espacio en Blanco Ignorable

18 JDOM (7) Document Constructor Document(Element rootelement) Crea un documento con ese elemento raíz Método List getcontent() Devuelve la lista de hijos del documento Método Element getrootelement() Devuelve el elemento raíz del documento Ejemplo: Element movieelement = document.getrootelement(); Element Hay dos versiones de cada uno de los métodos que muestra el diagrama UML con la notación [, Namespace ns] Versión con parámetro name y ns: cuando es necesario especificar el espacio de nombres (aunque sea el espacio de nombres por defecto) para un elemento hijo o atributo Versión con parámetro name: cuando no hay que especificar espacio de nombres para un elemento hijo o atributo A no ser que se indique lo contrario, los nombres de los atributos no se cualifican (e.g. recuérdese que con los esquemas XML el valor de attributeformdefault es unqualified por defecto )

19 JDOM (8) Element (cont) Constructores Element(String name [, Namespace ns]) Crea un elemento con el nombre especificado Ejemplo movieelement = new Element("movie", Namespace.getNamespace(" Método Element addcontent(content child) Añade un hijo (por el final) Devuelve this Ejemplo movieelement.addcontent(titleelement); Método Element addcontent(collection collection) Añade una colección de hijos (por el final) Devuelve this Ejemplo Collection<Element> children =... movieelement.addcontent(children);

20 JDOM (9) Element (cont) Métodos Attribute getattribute(string name [, Namespace ns]) Devuelven el objeto Attribute correspondiente al nombre de atributo especificado La clase Attribute dispone de los métodos getdoublevalue, getintvalue, getfloatvalue, getlongvalue y getvalue para obtener el valor de atributo como un número (métodos getxxxvalue) o un String (método getvalue) Ejemplo: int day = releasedateelement.getattribute("day").getintvalue(); Métodos String getattributevalue(string name [, Namespace ns]) Devuelven directamente el valor de un atributo como un String a partir de su nombre Ejemplo String dayasstring = releasedateelement.getattribute("day");

21 JDOM (10) Element (cont) Métodos Element getchild(string name [, Namespace ns]) Devuelven un elemento hijo a partir de su nombre Ejemplo Element titleelement = movieelement.getchild("title", Namespace.getNamespace(" Métodos List getchildren(string name [, Namespace ns]) Devuelven la lista de elementos hijo con el nombre especificado Ejemplo List<Element> actorelements = movieelement.getchildren("actor", Namespace.getNamespace("

22 Element (cont) JDOM (11) Métodos String getchildnormalize(string name [, Namespace ns]) Devuelve el texto normalizado contenido en el elemento especificado Se asume que ese elemento sólo tiene texto o normalizado Elimina los espacios en blanco del principio y el final Cada espacio en blanco contenido en el texto se sustituye por un blanco NOTA: espacio en blanco un blanco, un tabulador, un salto de línea o una secuencia de cualquiera de los anteriores Útil para elementos que contienen descripciones Si el documento XML fue escrito con un editor, posiblemente el autor, por legibilidad, partió la descripción en varias líneas Cuando el XML se genera automáticamente (e.g. desde un cliente o un servidor), normalmente no se incluyen espacios en blancos innecesarios antes, en medio y después del texto Los métodos getchildnormalize nos abstraen de este problema Ejemplo String synopsis = movieelement.getchildnormalize("synopsis", Namespace.getNamespace(" sypnosis contendría el resumen de la película sin blancos innecesarios y sin saltos de línea También existe String getnormalize()

23 JDOM (12) Element (cont) Métodos String getchildtrim(string name [, Namespace ns]) Devuelve el texto, sin espacios en blanco al principio y al final, contenido en el elemento especificado Se asume que ese elemento sólo tiene texto Útil para elementos que contienen datos Si el documento XML fue escrito con un editor, quizás el autor incluyó blancos antes y después Cuando el XML se genera automáticamente (e.g. desde un cliente o un servidor), normalmente no se incluyen espacios en blancos innecesarios antes y después Los métodos getchildtrim nos abstraen de este problema Ejemplo short runtime = Short.valueOf( movieelement.getchildtrim("runtime", XML_NS)); También existe String gettrim()

24 JDOM (13) Element (cont) Métodos void setattribute(string name, String value [, Namespace ns]) Da valor a un atributo Si el atributo no existía, lo añade Si el atributo ya existía, lo reemplaza por el nuevo Ejemplo int day =... releasedateelement.setattribute("day", Integer.toString(day)); Método void set(string text) Establece el texto pasado como el contenido del elemento Ejemplo String title =... titleelement.set(title);

25 En org.jdom.input JDOM (14) SAXBuilder + SAXBuilder() + build(in : InputStream) : Document El método build parsea la entrada con un parser SAX y crea el objeto Document que contiene el árbol JDOM

26 JDOM (y 15) En org.jdom.output XMLOutputter + XMLOuputter(format : Format) + output(doc : Document, out : OutputStream) Format Constructor Lo invocaremos pasándole Format.getPrettyFormat() XMLOutputter outputter = new XMLOutputter(Format.getPrettyFormat()); Genera el XML en formato bonito y con codificación UTF-8 Método output Escribe el XML correspondiente al documento pasado

27 es.udc.ws.movies.xml.moviexmlconversor (1) package es.udc.ws.movies.xml; import java.io.inputstream; import java.io.outputstream; import java.util.arraylist; import java.util.calendar; import java.util.list; import org.jdom.dataconversionexception; import org.jdom.document; import org.jdom.element; import org.jdom.namespace; import org.jdom.input.saxbuilder; import org.jdom.output.format; import org.jdom.output.xmloutputter; import es.udc.ws.movies.model.genreoperations; import es.udc.ws.movies.model.movieinformationto; import es.udc.ws.util.exceptions.parsingexception;

28 es.udc.ws.movies.xml.moviexmlconversor (2) public class MovieXMLConversor { public final static Namespace XML_NS = Namespace.getNamespace(" private MovieXMLConversor() {} public final static MovieInformationTO tomovieinformation(inputstream in) throws ParsingException { } try { SAXBuilder builder = new SAXBuilder(); Document document = builder.build(in); Element movieelement = document.getrootelement(); return tomovieinformation(movieelement); } catch (Exception e) { throw new ParsingException("Error deserializing instance" + " of " + MovieInformationTO.class, e); }

29 es.udc.ws.movies.xml.moviexmlconversor (3) public final static void toxml(movieinformationto movieinformation, OutputStream out) throws ParsingException { } try { Element movieelement = toxml(movieinformation); Document document = new Document(movieElement); XMLOutputter outputter = new XMLOutputter(Format.getPrettyFormat()); outputter.output(document, out); } catch (Exception e) { throw new ParsingException("Error serializing instance " + " of " + MovieInformationTO.class, e); } // Otros métodos públicos...

30 es.udc.ws.movies.xml.moviexmlconversor (4) /* Helper methods for XML to Java conversion */ private final static MovieInformationTO tomovieinformation( Element movieelement) throws DataConversionException { Element identifierelement = movieelement.getchild("identifier", XML_NS); Long identifier = null; if (identifierelement!= null) { identifier = Long.valueOf(identifierElement.getTrim()); } String title = movieelement.getchildnormalize("title", XML_NS); short runtime = Short.valueOf( movieelement.getchildtrim("runtime", XML_NS)); Calendar releasedate = getreleasedate( movieelement.getchild("releasedate", XML_NS)); List<String> directornames = getlist( movieelement.getchildren("director", XML_NS)); List<String> actornames = getlist( movieelement.getchildren("actor", XML_NS));

31 es.udc.ws.movies.xml.moviexmlconversor (5) List<String> genres = getlist( movieelement.getchildren("genre", XML_NS)); String synopsis = movieelement.getchildnormalize("synopsis", XML_NS); MovieInformationTO movieinformation = new MovieInformationTO( identifier, title, runtime, releasedate, directornames,actornames, GenreOperations.toListOfGenres(genres), synopsis); return movieinformation; }

32 es.udc.ws.movies.xml.moviexmlconversor (6) private final static Calendar getreleasedate( Element releasedateelement) throws DataConversionException { int day = releasedateelement.getattribute("day").getintvalue(); int month = releasedateelement.getattribute("month").getintvalue(); int year = releasedateelement.getattribute("year").getintvalue(); Calendar releasedate = Calendar.getInstance(); releasedate.set(calendar.day_of_month, day); releasedate.set(calendar.month, Calendar.JANUARY + month - 1); releasedate.set(calendar.year, year); } return releasedate; private final static List<String> getlist( List<Element> elementlist) { List<String> textlist = new ArrayList<String>(); } for (Element c : elementlist) { textlist.add(c.getnormalize()); } return textlist;

33 es.udc.ws.movies.xml.moviexmlconversor (7) /* Helper methods for Java to XML conversion */ public final static Element toxml( MovieInformationTO movieinformation) { Element movieelement = new Element("movie", XML_NS); if (movieinformation.getidentifier()!= null) { Element identifierelement = new Element("identifier", XML_NS); identifierelement.set( movieinformation.getidentifier().tostring()); movieelement.addcontent(identifierelement); } Element titleelement = new Element("title", XML_NS); titleelement.set(movieinformation.gettitle()); movieelement.addcontent(titleelement); Element runtimeelement = new Element("runtime", XML_NS); runtimeelement.set( Short.toString(movieInformation.getRuntime())); movieelement.addcontent(runtimeelement);

34 es.udc.ws.movies.xml.moviexmlconversor (8) Element releasedateelement = getreleasedate(movieinformation.getreleasedate()); movieelement.addcontent(releasedateelement); List<Element> directorelements = getelementlist( "director", XML_NS, movieinformation.getdirectornames()); movieelement.addcontent(directorelements); List<Element> actorelements = getelementlist("actor", XML_NS, movieinformation.getactornames()); movieelement.addcontent(actorelements); List<Element> genreelements = getelementlist("genre", XML_NS, movieinformation.getgenres()); movieelement.addcontent(genreelements); Element synopsiselement = new Element("synopsis", XML_NS); synopsiselement.set(movieinformation.getsynopsis()); movieelement.addcontent(synopsiselement); return movieelement; }

35 es.udc.ws.movies.xml.moviexmlconversor (9) private final static Element getreleasedate(calendar releasedate) { } Element releasedateelement = new Element("releaseDate", XML_NS); int day = releasedate.get(calendar.day_of_month); int month = releasedate.get(calendar.month) Calendar.JANUARY + 1; int year = releasedate.get(calendar.year); releasedateelement.setattribute("day", Integer.toString(day)); releasedateelement.setattribute("month", Integer.toString(month)); releasedateelement.setattribute("year", Integer.toString(year)); return releasedateelement;

36 es.udc.ws.movies.xml.moviexmlconversor (y 10) private final static List<Element> getelementlist( String elementname, Namespace namespace, List textlist) { } List<Element> elementlist = new ArrayList<Element>(); for (Object t : textlist) { Element element = new Element(elementName, namespace); element.set(t.tostring()); elementlist.add(element); } return elementlist;

37 Comentarios (1) es.udc.ws.util.exceptions.parsingexception Los métodos públicos de la clase MovieXMLConversor devuelven esta excepción cuando hay algún problema durante el proceso de parsing Forma parte de subsistema de utilidades de los ejemplos de la asignatura Extiende a RuntimeException Representa un error grave Sólo es preciso capturarla en los lugares en los que explícitamente se quiere tratar En resto de sitios, la excepción fluye hacia arriba Como cualquier tipo de excepción (java.lang.throwable), permite especificar un mensaje y/o encapsular una excepción (la que produjo el problema) RuntimeException ParsingException Los constructores mostrados invocan a los constructores de la clase padre + ParsingException() + ParsingException(message : String) + ParsingException(message : String, cause : Throwable) + ParsingException(cause : Throwable)

38 Comentarios (y 2) Validación y esquemas XML JDOM no tiene soporte directo para validar con esquemas XML, aunque existe un workaround sencillo para poder hacerlo En cualquier caso, y como justificaremos en el apartado 3.3, no siempre queremos que los clientes y/o servidores validen los documentos XML que reciben, sino simplemente que comprueben que Los documentos estén bien formados Los elementos y atributos que se requieran estén presentes NOTA: obsérvese que MovieXMLConversor hace ambas cosas En consecuencia, los documentos XML que produce MovieXMLConversor tampoco generan una referencia al esquema XML Los documentos XML (Movie-1.xml, Movie-2.xml, etc.) presentes en Subsystems/Movies/Documents incluyen una referencia al esquema XML Al editarlos con un editor con soporte para XML (e.g. el editor que viene con Eclipse Web Tools Platform), el editor puede detectar el uso de elementos y atributos incorrectos