El siguiente artículo le dará una idea de qué 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 entre corchetes angulares, como este: <…>). En conjunto, las etiquetas se conocen como “marcado”.
Las etiquetas XML dicen cuáles son los datos medioen lugar de cómo mostrarlo. Ponga una etiqueta en un dato que lo identifique (por ejemplo:
Al igual que en los nombres de campo de una estructura de datos, cualquier nombre se puede utilizar en etiquetas XML que tengan sentido para una aplicación determinada. Para que varias aplicaciones utilicen los mismos datos XML, debe haber coherencia en los nombres utilizados.
A continuación, se muestra un ejemplo de algunos datos XML:
<personal_info>
<first_name>Chaitanya</first_name>
<last_name>Singh</last_name>
<address>Agra</address>
<message>
This is a sample XMl.
</message>
</personal_info>
Las etiquetas en este ejemplo identifican la información personal como un todo, nombre, apellido, dirección y mensaje. Para cada etiqueta
Es esta capacidad de una etiqueta para contener otras lo que le da a XML la capacidad de representar estructuras de datos jerárquicas.
Etiquetas y atributos
Las etiquetas también pueden contener atributos de información adicional incluidos como parte de la propia etiqueta, dentro de los corchetes angulares de la etiqueta. El siguiente ejemplo muestra una estructura de información personal que usa atributos para los campos “first_name”, “last_name” y “address”:
<personal_information first_name="Chaitanya" last_name="Singh"
address="Agra">
</personal_information>
El nombre del atributo va seguido de un signo igual y el 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 no puede proporcionar los datos. Por ejemplo
Una etiqueta vacía sin datos se puede representar de la siguiente manera:
</Phone_Number>
La etiqueta vacía le evita tener que codificar <Phone_Number></ Phone_Number>
tener un documento bien formado.
Comentarios en archivos XML
Los comentarios XML tienen este aspecto:
El prólogo XML
Para completar la introducción de este trabajador a XML, tenga en cuenta que un archivo XML siempre comienza con un prólogo. El prólogo mínimo contiene una declaración que identifica el documento como un documento XML:
<?xml version="1.0"?>
La declaración también puede contener información adicional:
<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
versión
Identifica la versión del lenguaje de marcado XML utilizado en los datos. Este atributo no es opcional.
codificación
Identifica el juego de caracteres utilizado para codificar los datos. “ISO-8859-1” es “Latin-1”, el conjunto de caracteres de los idiomas inglés y de Europa occidental. (El valor predeterminado es Unicode comprimido: UTF-8).
independiente, autónomo
Indica si este documento se refiere a una entidad externa o una especificación de tipo de datos externos (ver más abajo). Si no hay referencias externas, entonces “sí” es apropiado
¿Por qué es importante XML?
Hay varias razones para la creciente aceptación de XML. Esta sección enumera algunos de los más importantes.
Jerárquico
Finalmente, 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 pueden profundizar en la parte necesaria, como pasar por un índice. También son más fáciles de reorganizar, porque cada pieza está delimitada.
Estilizabilidad
Cuando la visualización es importante, el estándar de la hoja de estilo, XSL, determina cómo se representan los datos. Más importante aún, debido a que XML no tiene estilo de forma inherente, es posible utilizar una hoja de estilo completamente diferente para generar postscript, TEX, PDF o un nuevo formato.
Identificación de los datos
XML indica qué tipo de datos están presentes, no cómo mostrarlos. Debido a que las etiquetas de marcado identifican información y dividen los datos en partes, un programa de búsqueda puede buscar información específica. En resumen, dado que se han identificado las diferentes partes de la información, pueden ser utilizadas de diferentes formas por diferentes aplicaciones.
Texto sin formato
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, un front-end XML para una base de datos permite almacenar de manera eficiente incluso grandes cantidades de datos XML. Por tanto, XML proporciona escalabilidad para cualquier cosa, desde pequeños archivos de configuración hasta un repositorio de datos para toda la empresa.
Reutilización en línea
Una de las ventajas de los documentos XML es que pueden estar formados por entidades independientes. A diferencia de HTML, las entidades XML se pueden incluir “en línea” en un documento.
Procesado fácilmente
Como se mencionó anteriormente, la notación regular y consistente facilita la creación de un programa para procesar datos XML. En XML, la etiqueta
, de lo contrario se definirá como una etiqueta
. Esta restricción es una parte fundamental de las restricciones que hacen que un documento XML esté bien formado.¿Cómo se puede utilizar XML?
Hay varias formas básicas de utilizar XML:
· Programación basada en documentos, en la que los documentos XML son contenedores que crean interfaces y aplicaciones a partir de componentes existentes.
Archivado: la base de la programación basada en documentos, donde la versión personalizada de un componente se guarda (archiva) para que pueda usarse más tarde
· Procesamiento de datos tradicional, en el que XML codifica datos para que un programa los procese
Enlace, donde el DTD o 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.
¿Existe una relación entre Java y Xml?
Sí, existe una relación. Java + XML = JDOM
¿Qué es JDOM?
JDOM es el modelo de objetos de documento de Java. Es una forma de representar un documento XML para una lectura, manipulación y escritura fáciles y eficientes.
Es una API simple, ligera y rápida y también optimizada para Java.
¿Necesitas JDOM?
JDOM es una API ligera. Este es un punto de referencia de “cargar e imprimir” que muestra un rendimiento a la par con SAX. El manejo y la salida también son ultrarrápidos.
JDOM puede representar un documento completo, aunque no es necesario que todos estén en memoria al mismo tiempo.
JDOM admite la edición y creación de documentos desde cero, sin “fábrica”.
No requiere un conocimiento profundo de XML
La clase de documento
Los documentos están representados por el org.jdom.Document clase.
Un objeto ligero que contiene un DocTypes ProcessingInstructions, una raíz Elemenusted Comentarios.
• Se puede construir desde cero:
• O puede construirse a partir de un archivo, flujo o URL:
Documento doc = nuevo documento (nuevo elemento (“rootElement”));
Constructor constructor = nuevo SAXBuilder ();
Documento doc = builder.build (url);
El proceso de construcción
Se puede crear un documento utilizando cualquier herramienta de compilación. La herramienta del compilador 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
– Puede escribir un constructor que construya el documento de manera perezosa según sea necesario
– Otros posibles constructores: LDAPBuilder, SQLBuilder
Los constructores tienen parámetros opcionales para especificar clases de implementación y si se debe realizar una validación basada en DTD.
SAXBuilder (String parserClass, validación booleana);
DOMBuilder (String adapterClass, boolean validate);
El proceso de salida
Un documento se puede escribir con cualquier herramienta de salida.
– org.jdom.output.XMLOutputter
la herramienta escribe el documento como XML
– org.jdom.output.SAXOutputter
herramienta genera eventos SAX
– org.jdom.output.DOMOutputter la herramienta crea un documento DOM
– Se puede utilizar cualquier herramienta de salida personalizada
Para producir un Documento como XML:
XMLOutputter outputter = new XMLOutputter();
outputter.output(doc, System.out);
outputter = new XMLOutputter("", false);
outputter.output(doc, System.out);
La clase DocType
A Documento puede tener un DocType Especifica la DTD del documento.
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
DocType docType = doc.getDocType();
System.out.println("Element: " + docType.getElementName());
System.out.println("Public ID: " + docType.getPublicID());
System.out.println("System ID: " + docType.getSystemID());
doc.setDocType( new DocType("html", "-//W3C...", "http://..."));
La clase Element
A Documento tiene una raíz Element:
Obtener la raíz como un archivo Elemento objeto:
A Elemento representa algo similar Aplicación Web
– Tiene acceso a todo desde el exterior
<web-app> to the closing </web-app>
<web-app id="demo">
<description>
Gotta fit servlets in somewhere!
</description>
<distributable/>
</web-app>
Element webapp = doc.getRootElement();
Acceso para niños
Un elemento puede contener elementos secundarios
getChild() may throw NoSuchElementException
// Get a List of direct children as Elements
List allChildren = element.getChildren();
out.println("First kid: " +
allChildren.get(0).getName());
// Get all direct children with a given name
List namedChildren = element.getChildren("name");
// Get the first kid with a given name
Element kid = element.getChild("name");
// Namespaces are supported
kid = element.getChild("nsprefix:name");
kid = element.getChild("nsprefix", "name");
Los nietos se pueden recuperar fácilmente:
<linux-config>
<gui>
<window-manager>
<name>Enlightenment</name>
<version>0.16.2</version>
</window-manager>
<!-- etc -->
</gui>
</linux-config>
String manager = root.getChild("gui").getChild("window-manager").getChild("name").getContent();
Los niños se pueden agregar y eliminar a través de Lista métodos de manipulación o conveniencia:
List allChildren = element.getChildren();
// Remove the fourth child
allChildren.remove(3);
// Remove all children named "jack"
allChildren.removeAll( element.getChildren("jack"));
element.removeChildren("jack");
// Add a new child
allChildren.add(new Element("jane"));
element.addChild(new Element("jane"));
// Add a new child in the second position
allChildren.add(1, new Element("second"));
Los elementos se construyen directamente, no se necesita ningún método de fábrica.
Algunos prefieren un atajo de anidación, que ha sido posible desde entonces. addChild () devuelve el Elemento en el que se agregó el niño:
Una subclase de Elemento se puede crear, ya que contiene elementos secundarios y contenido
Element element = new Element("kid");
Document doc = new Document( new Element("family").addChild(new Element("mom"))
.addChild(new Element("dad").addChild("kidOfDad")));
root.addChild(new FooterElement());
Recuperando los atributos de los elementos
Los elementos suelen contener atributos:
Los atributos se pueden recuperar de varias formas:
getAttribute() may throw NoSuchAttributeException
<table width="100%" border="0"> </table>
String value = table.getAttribute("width").getValue();
// Get "border" as an int, default of 2
int value = table.getAttribute("border").getIntValue(2);
// Get "border" as an int, no default
try {
value = table.getAttribute("border").getIntValue();
}
catch (DataConversionException e) { }
Establecer atributos de elemento
Los atributos de los elementos se pueden agregar o eliminar fácilmente
// Add an attribute
table.addAttribute("vspace", "0");
// Add an attribute more formally
table.addAttribute( new Attribute("prefix", "name", "value"));
// Remove an attribute
table.removeAttribute("border");
// Remove all attributes
table.getAttributes().clear();
Contenido del elemento
Los elementos pueden contener contenido de texto, el contenido está disponible directamente y se puede editar fácilmente:
<description>A cool demo</description>
String content = element.getContent();
// This blows away all current content
element.setContent("A new description");
Contenido mixto
A veces, un elemento puede contener comentarios, texto
contenido y niños
El texto y los niños se pueden recuperar como de costumbre:
Esto hace que los usos estándar sean simples
<table>
<!-- Some comment -->
Some text
<tr>Some child</tr>
</table>
String text = table.getContent();
Element tr = table.getChild("tr");
Lectura de contenido mixto
Para obtener todo el contenido dentro de un archivo Element, usa getMixedContent ()
– Devuelve un Lista conteniendo Comment, String, e Elemento objetos
List mixedContent = table.getMixedContent();
Iterator i = mixedContent.iterator();
while (i.hasNext()) {
Object o = i.next();
if (o instanceof Comment) {
// Comment has a toString()
out.println("Comment: " + o);
}
else if (o instanceof String) {
out.println("String: " + o);
}
else if (o instanceof Element) {
out.println("Element: " +
((Element)o).getName());
}
}
Excepciones
JDOMException es la principal excepción
– Lanzado por errores de construcción
– Siempre incluye un mensaje de error útil
– Puede incluir una excepción de “causa raíz”
Las subclases incluyen:
NoSuchAttributeException
NoSuchElementException
NoSuchProcessingInstructionException
DataConversionException
Buscar palabras clave:
XML, Java, Java y XML, JDOM