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 hay una etiqueta de cierre coincidente: . Los datos entre la etiqueta y la etiqueta final correspondiente definen un elemento de datos XML.

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

leer  Analizador XML de Java: código completo

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

siempre debe tener un terminador

, 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.

leer  Análisis de XML utilizando la API de Java DOM4J

¿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:

leer  Análisis de XML utilizando la API de Java DOM4J

<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

Por avivcas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *