El siguiente artículo le dará una idea de lo que es XML y el uso de Java y XML.
¿Qué es XML?
XML es un lenguaje de marcado basado en texto que se está convirtiendo rápidamente en el estándar para el intercambio de datos en la Web. Aquí los datos se identifican mediante etiquetas (identificadores encerrados entre paréntesis angulares, como esto: <…>). Colectivamente, las etiquetas se conocen como «markup».
Las etiquetas XML dicen lo que significan los datos, en lugar de cómo mostrarlos. Pone una etiqueta en un dato que lo identifica (por ejemplo:
Al igual que en los nombres de campo de una estructura de datos, en las etiquetas XML se puede utilizar cualquier nombre que tenga sentido para una aplicación determinada. Para que varias aplicaciones utilicen los mismos datos XML, debe haber una uniformidad en los nombres utilizados.
He aquí un ejemplo de algunos datos XML:
Esta es una muestra XMl.
Las etiquetas de este ejemplo identifican la información personal en su conjunto, el nombre, el apellido, la dirección y el mensaje. Para cada etiqueta hay
Es esta capacidad de una etiqueta de contener otras la que da a XML su capacidad de representar estructuras jerárquicas de datos
Etiquetas y atributos
Las etiquetas también pueden contener atributos, información adicional incluida como parte de la propia etiqueta, dentro de los corchetes del ángulo de la etiqueta. El siguiente ejemplo muestra una estructura de información personal que utiliza atributos para los campos «nombre», «apellido» y «dirección»:
El nombre del atributo va seguido de un signo igual y del valor del atributo, y los atributos múltiples están separados por espacios.
Etiquetas vacías
A veces, puede haber datos que pueden ser opcionales. El usuario puede no suministrar los datos. Por ejemplo,
Una etiqueta vacía sin datos puede representarse de la siguiente manera:
La etiqueta vacía le ahorra tener que codificar
Comentarios en los archivos XML
Los comentarios XML tienen el siguiente aspecto:
El Prologo XML
Para completar la introducción de este viajero al XML, tened en cuenta que un archivo XML siempre empieza con un prólogo. El prólogo mínimo contiene una declaración que identifica el documento como un documento XML:
La declaración también puede contener información adicional:
versión
Identifica la versión del lenguaje de marcado XML utilizado en los datos. Este atributo no es opcional.
Codificación
Identifica el conjunto de caracteres utilizados para codificar los datos. «ISO-8859-1» es «Latin-1» el juego de caracteres de Europa Occidental y del idioma inglés. (El valor por defecto es Unicode comprimido: UTF-8.)
autónomo
Indica si este documento hace referencia o no a una entidad externa o a una especificación de tipo de datos externos (véase más adelante). Si no hay referencias externas, entonces «sí» es apropiado
¿Por qué es importante el XML?
Hay un número de razones para la creciente aceptación de XML. Esta sección enumera algunas de las más destacadas.
Jerarquizada
Por último, los documentos XML se benefician de su estructura jerárquica. Las estructuras jerárquicas de los documentos son, en general, más rápidas de acceder porque se puede perforar hasta la parte que se necesita, como pasar por una tabla de contenidos. También son más fáciles de reordenar, porque cada pieza está delimitada.
Estilismo
Cuando la visualización es importante, la hoja de estilo estándar, XSL dicta cómo representar los datos. Más importante aún, ya que XML es inherentemente libre de estilos, puedes usar una hoja de estilos completamente diferente para producir resultados en postscript, TEX, PDF, o algún formato nuevo.
Identificación de datos
El XML dice qué tipo de datos están presentes, no cómo mostrarlos. Debido a que las etiquetas de marcado identifican la información y dividen los datos en partes, un programa de búsqueda puede buscar información específica. En resumen, debido a que las diferentes partes de la información han sido identificadas, pueden ser utilizadas de diferentes maneras por diferentes aplicaciones.
Texto simple
Dado que XML no es un formato binario, puede crear y editar archivos con cualquier cosa, desde un editor de texto estándar hasta un entorno de desarrollo visual. En el otro extremo del espectro, una interfaz XML de una base de datos permite almacenar también grandes cantidades de datos XML de forma eficiente. Por lo tanto, XML proporciona escalabilidad para cualquier cosa, desde pequeños archivos de configuración hasta un repositorio de datos de toda la empresa.
Reutilización en línea
Uno de los aspectos más agradables de los documentos XML es que pueden estar compuestos de entidades separadas. A diferencia del HTML, las entidades XML pueden incluirse «en línea» en un documento.
Fácilmente procesable
Como ya se ha mencionado, la notación regular y consistente facilita la construcción de un programa para procesar datos XML. En XML, la etiqueta
terminador, o de lo contrario se definirá como una etiqueta
. Esa restricción es una parte crítica de las limitaciones que hacen que un documento XML esté bien formado.¿Cómo se puede utilizar el XML?
Existen varias formas básicas de utilizar el XML:
– Programación basada en documentos, donde los documentos XML son contenedores que construyen interfaces y aplicaciones a partir de componentes existentes
– Archivo – la base de la programación basada en documentos, donde se guarda (archiva) la versión personalizada de un componente para que pueda ser utilizada más tarde
– Procesamiento de datos tradicional, donde XML codifica los datos para que un programa los procese
– Vinculación, en la que la DTD o el esquema que define una estructura de datos XML se utiliza para generar automáticamente una parte significativa de la aplicación que eventualmente procesará esos datos
¿Hay una relación entre Java y Xml?
Sí, hay una relación. Java + XML = JDOM
¿Qué es JDOM?
JDOM es el Modelo de Objeto de Documento de Java. Es una forma de representar un documento XML para una lectura, manipulación y escritura fácil y eficiente.
Es un API sencillo que es ligero y rápido y también optimizado para Java.
¿Necesitas JDOM?
JDOM es un API ligero. Es un punto de referencia de «carga e impresión» que muestra un rendimiento a la par que el SAX. La manipulación y la salida son también muy rápidas.
JDOM puede representar un documento completo, aunque no todos deben estar en la memoria a la vez.
JDOM soporta la modificación y la creación de documentos desde cero, sin «fábrica».
No requiere un conocimiento profundo de XML
La clase de documentos
Los documentos están representados por la clase org.jdom.Document.
Un objeto liviano que contiene un DocType, Instrucciones de Procesamiento, un elemento raíz y Comentarios.
– Puede ser construido desde cero:
– O puede ser construido a partir de un archivo, flujo o URL:
Document doc = new Document(new Element(«rootElement»));
Builder builder = nuevo SAXBuilder();
Documento doc = builder.build(url);
El proceso de construcción
Un documento puede ser construido usando cualquier herramienta de construcción. La herramienta de construcción SAX utiliza un analizador SAX para crear un documento JDOM.
– Los constructores actuales son SAXBuilder y DOMBuilder
– org.jdom.input.SAXBuilder es rápido y recomendado
– org.jdom.input.DOMBuilder es útil para leer un árbol DOM existente
– Se puede escribir un constructor que construye perezosamente el Documento según sea necesario
– Otros posibles constructores: LDAPBuilder, SQLBuilder
Los constructores tienen parámetros opcionales para especificar las clases de implementación y si debe ocurrir una validación basada en DTD.
SAXBuilder(String parserClass, boolean validate);
DOMBuilder(String adapterClass, validación booleana);
El proceso de salida
Un documento puede ser escrito usando cualquier herramienta de salida
– org.La herramienta jdom.output.XMLOutputter escribe el documento como XML
– La herramienta org.jdom.output.SAXOutputter genera eventos SAX
– La herramienta org.jdom.output.DOMOutputter crea un documento DOM
– Se puede utilizar cualquier herramienta de salida personalizada
Para producir un documento como XML:
XMLOutputter outputter = nuevo XMLOutputter();
outputter.output(doc, System.out);
outputter = nuevo XMLOutputter(«», false);
outputter.output(doc, System.out);
La clase DocType
Un documento puede tener un DocType Esto especifica el DTD del documento
«http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd»>
DocType docType = doc.getDocType();
System.out.println(«Elemento: » + docType.getElementName());
System.out.println(«Identificación pública: » + docType.getPublicID());
System.out.println(«System ID: » + docType.getSystemID());
doc.setDocType(«nuevo DocType(«html», «-//W3C…», «http://…»));
La clase de elemento
Un documento tiene un elemento raíz:
Obtener la raíz como un objeto del elemento:
Un Elemento representa algo como una aplicación web
– Tiene acceso a todo lo que está al descubierto
¡Tengo que poner servilletas en algún lugar!
Elemento webapp = doc.getRootElement();
Acceder a los niños
Un elemento puede contener elementos infantiles
getChild() puede lanzar NoSuchElementException
// Obtener una lista de los niños directos como elementos
Listar todos los Niños = element.getChildren();
out.println(«Primer niño: » +
allChildren.get(0).getName());
// Obtener todos los niños directos con un nombre determinado
Lista denominadaChildren = element.getChildren(«nombre»);
// Consigue el primer niño con un nombre determinado
Element kid = element.getChild(«nombre»);
// Los espacios de nombres están soportados
kid = element.getChild(«nsprefix:nombre»);
kid = element.getChild(«nsprefix», «nombre»);
Los nietos pueden ser recuperados fácilmente:
Los niños pueden ser añadidos y quitados a través de la manipulación de la Lista o de métodos de conveniencia:
Listar todos los niños = element.getChildren();
// Eliminar el cuarto hijo
allChildren.remove(3);
// Quitar todos los niños llamados «Jack»
allChildren.removeAll( element.getChildren(«jack»));
element.removeChildren(«jack»));
// Añadir un nuevo niño
allChildren.add(nuevo elemento(«jane»));
element.addChild(nuevo Elemento(«jane»));
// Añadir un nuevo niño en la segunda posición
allChildren.add(1, nuevo elemento(«second»));
Los elementos se construyen directamente, no se necesita ningún método de fábrica
Algunos prefieren un atajo de anidación, posible ya que addChild() devuelve el elemento en el que se añadió el niño:
Se puede hacer una subclase de Elemento, que ya contiene elementos y contenido hijo
Elemento = nuevo elemento («niño»);
Document doc = new Document( nuevo Elemento(«familia»).addChild(nuevo Elemento(«mamá»))
.addChild(nuevo Elemento(«papá»).addChild(«kidOfDad»)));
root.addChild(new FooterElement());
Obtención de los atributos de los elementos
Los elementos a menudo contienen atributos:
Los atributos pueden ser recuperados de varias maneras:
getAttribute() puede lanzar NoSuchAttributeException
Valor de la cadena = table.getAttribute(«width»).getValue();
// Obtener «border» como un int, por defecto de 2
Valor int = tabla.getAtributo(«borde»).getIntValor(2);
// Obtener «border» como un int, no por defecto
Inténtalo.
valor = tabla.getAtributo(«borde»).getIntValue();
}
catch (DataConversionException e) { }
Establecimiento de los atributos de los elementos
Los atributos de los elementos pueden ser fácilmente añadidos o eliminados
// Añadir un atributo
table.addAttribute(«vspace», «0»);
// Añadir un atributo más formalmente
table.addAttribute( nuevo atributo(«prefijo», «nombre», «valor»));
// Eliminar un atributo
table.removeAttribute(«border»);
// Eliminar todos los atributos
table.getAttributes().clear();
Contenido del elemento
Los elementos pueden contener contenido de texto, El contenido está disponible directamente y puede ser cambiado fácilmente:
Contenido de la cadena = element.getContent();
// Esto hace desaparecer todo el contenido actual
element.setContent(«Una nueva descripción»);
Contenido mixto
A veces un elemento puede contener comentarios, texto
contenido, y los niños
El texto y los niños pueden ser recuperados como siempre:
Esto mantiene los usos estándar simples
Cadena de texto = tabla.getContent();
Elemento tr = table.getChild(«tr»);
Lectura de contenido mixto
Para obtener todo el contenido de un elemento, usa getMixedContent()
– Devuelve una Lista que contiene objetos de Comentario, Cadena y Elemento
Listar contenido mixto = table.getMixedContent();
Iterator i = mixedContent.iterator();
while (i.hasNext()) {
Objeto o = i.next();
si (o instancia de Comentario) {
// El comentario tiene un toString()
out.println(«Comentario: » + o);
}
más si (o instancia de la cuerda) {
out.println(«String: » + o);
}
más si (o instancia de elemento) {
out.println(«Elemento»): » +
((Elemento)o).getName());
}
}
Excepciones
JDOMExcepción es la excepción de la raíz
– Lanzado por errores de construcción
– Siempre incluye un mensaje de error útil
– Puede incluir una excepción de «causa fundamental».
Las subclases incluyen:
NoSuchAttributeException
NoSuchElementException
NoSuchProcessingInstructionException
DataConversionException
Busca palabras clave:
XML, Java, Java y XML, JDOM
