6.1 APIs para XML - IIS Windows...

© 2002 Borja Sotomayor 1

6.1 APIs para XML

APIs para XML (I)

! Uno de los usos más habituales de XML (y menos esperado) es como formato de intercambio de datos.

! En este caso los documentos XML nunca llegan a ‘visualizarse’, sino que son producidos y consumidos por aplicaciones informáticas.

! Es necesario poder acceder facilmente al documento XML desde el software.


APIs para XML (II)! Disponemos de dos APIs (Application Program

Interface) practicamente estándares con las que podemos acceder facilmente a un documento XML.! DOM " Document Object Model (W3C)! SAX " Simple API for XML

! Estas APIs nos permiten abstraernos de los detalles sintácticos de XML.

! Trabajamos a nivel de ‘elementos’, ‘atributos’, etc.! Existen implementaciones de DOM y SAX en los

lenguajes más populares (C++, Java, C#, Perl, etc.)

APIs para XML (III)! DOM " API orientada a objetos

! Una vez que se ha leido el documento, crea una copia en memoria a la que podemos acceder a través de una jerarquía de clases (“Documento”, “Elemento”, “Atributo”, etc.)

! SAX " API orientada a eventos! Conforme se va leyendo el documento se pueden

capturar ciertos eventos (“Comienzo de documento”, “Comienzo de elemento”, etc) y realizar un tratamiento sobre ellos.


APIs para XML (IV)

Sólo permite leer el documento.Permite modificar el documento.

No podemos acceder directamente a cualquier parte del documento. Hay que esperar a que sea leida.

Podemos acceder directamente a cualquier parte del documento (una vez que se ha cargado)

Tenemos acceso a cualquier parte del documento en cuanto es leida.

No podemos acceder al documento hasta que éste se ha cargado por completo en memoria.

Procesa el documento XML sobre la marcha. Ideal para flujos continuos de datos.

SAXAlmacena una copia del documento XML en memoria. No es recomendable para ficheros grandes.

DOM


6.2 DOM – Introducción

Introducción (I)! DOM " Document Object Model.

! Jerarquía de clases que nos permite interactuar con el documento XML desde un programa.

! Creado y mantenido por el W3C.! Está definido en IDL, por lo que (en teoría)

puede implementarse en cualquier lenguaje orientado a objetos (es language-neutral). Existen implementaciones para JavaScript, Java, C#, etc.


Introducción (II)! Hay varias versiones del DOM.

! DOM 1 (1998)! Funcionalidad básica para XML y HTML

! DOM 2 (2000)! DOM 1 + soporte para hojas de estilos, eventos

y XML Namespaces.! Soporte para XHTML.

! DOM 3 (en desarrollo)! Soporte para más tecnologías XML (XML

Schema, XPath, y otras)

Introducción (III)! A partir de DOM 2, se dividió en varios módulos:

! DOM Core " Funcionalidad básica para XML. Maneja conceptos como ‘elemento hijo’, ‘elemento padre’, ‘elemento hermano’, etc.

! DOM HTML " Incluye funcionalidad específica para HTML (y XHTML).

! DOM Events " Soporte para eventos.! DOM Views " Soporte para “vistas” (similares a las de

una base de datos)! DOM Style " Permite interactuar con hojas de estilo.! DOM Traversal and Range " Añade iteradores al DOM.


Introducción (IV)! Para acceder a un documento XML, el

DOM Core suele ser suficiente. Los demás módulos, de hecho, son opcionales.

Representación Interna (I)! El DOM almacena el documento XML en

memoria utilizando una representación jerarquica (muy similar a la de Xpath)

! El documento es un arbol con diferentes tipos de nodos.! DOM tiene en cuenta más tipos de nodos que

XPath.

! Este hecho se ve reflejado en la jerarquía de clases del DOM.

«interface»Node

«interface»Text

«interface»Comment

«interface»CDATASection

«interface»DOMImplementation

«interface»NodeList

«interface»NamedNodeMap

«interface»CharacterData

«interface»Attr

«interface»Element

«interface»DocumentType

«interface»Notation

«interface»Entity

«interface»EntityReference

«interface»ProcessingInstruction

«interface»DocumentFragment

«interface»Document

«exception»DOMException

<biblioteca>

<libro titulo=“El Juego de Ender”>

<copia edicion=“1987” />

<comentario>¡Me gustó mucho!</comentario>

</libro>

<libro titulo=“La Fundación”>

<copia edicion=“1999” />

</libro>

</biblioteca>



: Document

: Element

: Element : Element

: Text

: Element

: Element : Comment

: Attr

: Attr : Element : Attr

: Attr

“Esta es mi…"biblioteca

libro

copia comentario

“¡Me gustó…"

libro

copia

RAIZ

titulo

: Text

“El Juego…"

titulo

: Text

“La fundac…"

edicion edicion

: Text

“1987”

: Text

“1999”


Representación Interna (II)! Al igual que XPath, esta representación

jerarquica es un tanto peculiar:! El elemento raíz del documento (<biblioteca>) no

es la raíz del árbol, ya que puede haber más cosas al mismo nivel que el elemento raíz (por ejemplo, un comentario).

! A pesar de que los atributos se representan como nodos, no son estrictamente ‘hijos’ del elemento al que pertenecen (podría decirse que son ‘nodos asociados’).


6.3 DOM - Document

Introducción (I)! El interfaz Document es, junto con el

interfaz Node, uno de los más importantes del DOM.! Representa todo el documento XML.! Es, a su vez, un nodo (Node).! Es el nodo raiz del arbol DOM.! Sólo pueden instanciarse clases que

implementen este interfaz (no podemos, por ejemplo, instanciar un elemento, un comentario, etc.)


Introducción (II)! ¿Cómo cargamos un fichero XML del

disco duro a la memoria con el DOM?! El DOM no especifica cómo hacer esto.

Depende de cada implementación concreta. El DOM da por supuesto que el documento ya está cargado en memoria.! A partir del DOM 3 este aspecto se

estandarizará.

Acceso al Documento (I)! getElementsByTagName(nombre_etiqueta)

Devuelve un objeto NodeList con todos loselementos cuyo nombre sea nombre_etiqueta

! getElementByID(ID)

Si en el DTD hemos definido algún atributode tipo ID, este método devuelve el objetoElement correspondiente al elemento quetenga el valor ID en dicho atributo. (DOM2)

! documentElement

Atributo de sólo lectura que contiene una referencia al objeto Element correspondiente al elemento raiz del documento.


Acceso al Documento (II)! También podemos utilizar todas las

propiedades y métodos heredados de Node (firstChild, appendChild,...)

! En DOM 2 tenemos, además, el método getElementsByTagNameNS, que nos permite obtener elementos especificando su namespace (XML Namespaces).

Creación de Nodos (I)! El objeto Document es el único directamente

instanciable. A través de él podremos crear todos los tipos de nodos.! createElement(nombre_etiqueta)

Crea un objeto Element (nodo elemento) vacío cuyo nombre será nombre_etiqueta

! createAttribute(nombre_atributo)

Crea un objeto Attr (nodo atributo) sin valor y con nombre nombre_atributo.

! createTextNode(texto)

Crea un objeto Text (nodo texto) cuyo texto será texto! createComment(texto)

Crea un objeto Comment (nodo comentario) cuyo contenido será texto


Creación de Nodos (II)! createCDATASection(texto)

Crea un objeto CDATASection (nodo CDATA) cuyo contenido será texto

! createProcessingInstruction(nombre, attrs)

Crea un objeto ProcessingInstruction (nodo instrucción de proceso). El nombre de la instrucción será nombre y los atributos se especifican todos en el parametro attrs.

! createEntityReference(nombre_entidad)

Crea un objeto EntityReference (nodo referencia a entidad) que referencia a la entidad nombre_entidad.

! createDocumentFragment()

Crea un objeto DocumentFragment vacío.

Otros! doctype: El objeto DocumentType

correspondiente al DTD del documento.! implementation: El objeto DOMImplementation ligado al documento.

! importNode(...): Para copiar subarboles enteros entre documentos (DOM 2)

! Más constructores (DOM 2):! createElementNS(...)

! createAttributeNS(...)


6.4 DOM - Node

Introducción! El interfaz Node es, junto con el interfaz

Document, uno de los más importantes del DOM.! Todos los tipos de nodo derivan de este interfaz.! Incluye las operaciones básicas de navegación por

el arbol DOM (“primer nodo”, “siguiente nodo”, “último nodo”, etc.)

! Incluye las operaciones básicas de escritura de nodos (“añadir nodo a mis hijos”, “eliminar éste nodo hijo”, etc.)


Propiedades Básicas (I)! nodeName: Nombre del nodo (depende del

tipo del nodo).! Element " Nombre del elemento! Attr " Nombre del atributo

! nodeValue: Valor del nodo (depende del tipo del nodo). No es equivalente al ‘valor del nodo’ en XPath y XSLT.! Element " null! Attr " Valor del atributo! Text " Texto del nodo.

Propiedades Básicas (II)! nodeType: Tipo del nodo.

! 1 " Element! 2 " Attr! 3 " Text! 4 " CDATASection! 5 " EntityReference! 6 " Entity! 7 " ProcessingInstruction! 8 " Comment! 9 " Document! 10 " DocumentType! 11 " DocumentFragment! 12 " Notation


Propiedades de Navegación! parentNode " El nodo padre.! childNodes " Un NodeList con todos los nodo

hijos.! firstChild " El primer nodo hijo.! lastChild " El último nodo hijo.! previousSibling " El ‘nodo anterior’

(literalmente ‘el hermano anterior’)! nextSibling " El ‘siguiente nodo’ (‘el hermano

siguiente’)! ownerDocument " El objeto Document al que

pertenece este nodo.! hasChildNodes() " Devuelve true si este nodo

tiene hijos.

Modificación de Hijos (I)! appendChild(nodo)

Inserta un nodo al final de la lista de hijos del nodo sobre el que invocamos appendChild. Si nodo ya tiene padre, primero se rompe el vínculo con su padre actual.

! removeChild(nodo)

Elimina un nodo de la lista de hijos. Evidentemente, el nodo que pasamos debe estar en la lista de hijos.


Modificación de Hijos (II)! insertBefore(nodo_nuevo, nodo_ref)

Inserta un nuevo nodo antes de un nodo de la lista de hijos (nodo_ref).

! replaceChild(nodo_nuevo, nodo_viejo)

Reemplaza un nodo de la lista de hijos (nodo_ref) con uno nuevo (nodo_nuevo).

Atributos! A pesar de que Element dispone de unos

métodos para modificar atributos, en Nodetambién disponemos de una propiedad attributes, cuyo tipo es NamedNodeMap y que nos permite acceder a los atributos de un elemento.

! También tenemos un método hasAttributes()que devuelve true si el nodo tiene atributos.

! Suele utilizarse con atributos muy complicados (muchos atributos, valores que combinan texto con referencias a entidades, etc.)


Otros! cloneNode(...) " Para crear copias de

subarboles enteros.! normalize() " Fusiona nodos de texto

contiguos en todos los nodos descendientes.! XML Namespaces (DOM 2):

! namespaceURI! prefix! localName


6.5 DOM - Element

Introducción! El interfaz Element nos permite

interactuar con nodos elemento de la siguiente manera:! Acceso fácil a los atributos (sin tener que

manejar nodos Attr)! Acceso fácil a los elementos hijo.

! Puesto que Element deriva de Node, también podemos utilizar las operaciones más genericas (childNodes, attributes, etc.)


Propiedades y Métodos Básicos! tagName

El nombre del elemento (de la etiqueta)! getElementsByTagName(nombre_etiqueta)

Devuelve un objeto NodeList con todos loselementos (descendientes) cuyo nombre sea nombre_etiqueta

Acceso a Atributos (I)! getAttribute(nombre_atributo)

Devuelve el valor del atributo nombre_atributo! setAttribute(nombre, valor)

Modifica el valor del atributo nombre para que sea igual a valor

! removeAttribute(nombre_atributo)

Elimina el atributo nombre_atributo! hasAttribute(nombre_atributo)

Devuelve true si existe un atributo nombre_atributo en el elemento (DOM 2)


Acceso a Atributos (II)! getAttributeNode(nombre_atributo)

Devuelve el nodo atributo cuyo nombre sea nombre_atributo

! setAttributeNode(nodo_atributo)

Añade un nodo atributo al elemento. Si ya existe un atributo con el mismo nombre, lo reemplaza.

! removeAttributeNode(nodo_atributo)

Elimina el nodo atributo nodo_atributo

Otros! Métodos para XML Namespaces:

! getAttributeNS(...)! setAttributeNS(...)! removeAttributeNS(...)! getAttributeNodeNS(...)! setAttributeNodeNS(...)! getElementsByTagNameNS(...)! hasAttributeNS(...)


6.6 DOM - Attr

Introducción! Contiene información básica sobre

atributos.! No es muy habitual utilizar

directamente un objeto Attr ya que el dato más importante (el valor del atributo) puede ser accedido desde el objeto Element.! Cuando se utiliza, suele ser para utilizar las

funciones genéricas de Node y poder tratar ciertos casos especiales de atributos.


Propiedades! name: Nombre del atributo.! value: Valor del atributo.! specified: Es true si el atributo

estaba ‘especificado’ en el documento XML original (si aparecía ahí con algún valor). False si el atributo fue creado en el DOM.

! ownerElement: Nodo Element al que pertenece este atributo.


6.7 DOM – Otros Interfaces

Introducción! Aparte de los interfaces vistos, el DOM

tambien tiene los siguientes:! NodeList " Lista de nodos! NamedNodeMap " Lista de nodos accesible por

nombre! Interfaces de Texto " CharacterData, Text, Comment, CDATASection

! Otros " DocumentType, DocumentFragment, Notation, Entity, EntityReference, ProcessingInstruction, DOMImplementation, DOMException.


NodeList! Representa una lista de nodos.! Cuando una operación devuelve una lista de

nodos, y no es necesario acceder por nombre (basta con un índice numérico) se utiliza esta estructura. Por ejemplo: GetElementsByTagName(), GetElementById(), childNodes,...

! Muy sencillo de utilizar. Tiene una propiedad y un método:! length: Número de nodos que contiene el NodeList.! item(índice):Devuelve el Node que se encuentra en la

posición índice de la lista (se numera desde 0)

NamedNodeMap! Representa una lista de nodos.! Cuando una operación devuelve una

lista de nodos, y es necesario acceder por nombre se utiliza esta estructura.! Atributos (attributes en Node)! Entidades (DTDs)! Notaciones (DTDs)

! Nos permite acceder al Nodedirectamente a través de su nombre, no utilizando un índice numérico.


Interfaces de Texto! Los interfaces de texto (Text, Comment, CDATASection) tienen como interfaz padre a CharacterData.! Ninguno de los interfaces derivados añaden nada

nuevo con respecto a CharacterData (excepto Text que añade un método). Basta con saber como funciona CharacterData.

! Los dos atributos más destacables son:! data: El texto que contiene el nodo.! length: El tamaño del texto.

Otros (I)! DocumentType: Representa parcialmente el

DTD del documento.! DocumentFragment: Representa un fragmento

del documento (una colección de subarboles)! Entity: Representa una entidad.! EntityReference: Representa una referencia

a una entidad.! Notation: Representa una notación.


Otros (II)! ProcessingInstruction: Representa una

instrucción de proceso.! DOMImplementation: Encapsula información

sobre la implementación del DOM. Por ejemplo, nos permite averiguar si la implementación del DOM que estamos utilizando soporta Eventos o no.

! DOMException: No es un interfaz. Es la excepción que se lanza cuando se produce un error. Existen unos códigos de error predefinidos.

6.1 APIs para XML - IIS Windows...

Documents

Transcript of 6.1 APIs para XML - IIS Windows...