Descripción general: el lenguaje de marcado extensible (XML) se está utilizando rápidamente en la industria. Se ha convertido en un estándar ampliamente utilizado para describir e intercambiar datos en un formato independiente de la plataforma, el lenguaje y el protocolo. XML y sus especificaciones auxiliares se pueden utilizar para describir la representación de datos en documentos, describir las limitaciones de los tipos de documentos XML, describir los vínculos entre documentos y recursos XML y describir la conversión y el formato automático de documentos XML.
¿Cómo desarrollar una biblioteca de etiquetas personalizada?
He estado usando la programación JSP y ASP durante mucho tiempo. Entre los dos métodos de programación del lado del servidor, siento cada vez más que JSP es mucho más poderoso. Sin mencionar nada más, la biblioteca de etiquetas de JSP es la razón por la que elijo JSP como la herramienta de desarrollo de aplicaciones web del lado del servidor preferida. ¿Por qué? Porque: velocidad de mantenimiento y desarrollo. Dentro de una única página de servidor, puede mezclar y combinar varios métodos y objetos de script. Al igual que "concrete", esta combinación hace que las secuencias de comandos del lado del servidor sean poderosas y permite a los programadores del lado del servidor diseñar páginas web muy flexibles y dinámicas. Sin embargo, esta combinación gratuita también tiene sus desventajas, que son muy difíciles de mantener. Especialmente a medida que el proyecto se hace más grande, ya que el producto final lo mantiene un diseñador web tradicional, y lo que es peor, la velocidad de desarrollo aumenta a medida que aumenta la complejidad del código. Se volverá más lento y no propicio para el desarrollo medio y. aplicaciones web a gran escala una vez desarrolladas, el sitio aún necesitará encontrar programadores calificados para mantener estos códigos bastante complejos.
Afortunadamente, JSP proporciona una buena solución. Las bibliotecas de etiquetas proporcionan una forma sencilla de crear un bloque de código reutilizable. Una vez diseñada una biblioteca de etiquetas, se puede volver a utilizar en muchos proyectos. Lo que es aún más conveniente es que, a diferencia de COM y J2EE, no es necesario aprender ninguna otra habilidad para crear una biblioteca de etiquetas. Siempre que sepa escribir JSP, puede crear una biblioteca de etiquetas. Las bibliotecas de etiquetas también pueden mejorar el mantenimiento de las aplicaciones web. Esta es una interfaz XML simple gracias a las etiquetas personalizadas de la página JSP. De esta manera, los diseñadores web pueden incluso crear aplicaciones web JSP sin tener ningún conocimiento de JSP. Este desarrollo web abierto es muy eficaz para las operaciones en equipo. Los programadores JSP pueden crear etiquetas personalizadas y módulos de código de fondo, mientras que los diseñadores web pueden usar etiquetas personalizadas para crear aplicaciones web y centrarse en el diseño web.
1. Definición de biblioteca de etiquetas La biblioteca de etiquetas JSP (también llamada biblioteca personalizada) puede considerarse como un conjunto de métodos para generar scripts basados en XML, que es compatible con JavaBeans. Conceptualmente, las bibliotecas de etiquetas son construcciones de código muy simples y reutilizables.
Ejemplos de etiquetas y páginas HTML que realizan conversión XML/XSL
<%@ taglib uri=" http://www.jspinsider.com/jspkit/JAXP " prefix="JAXP"%>
c:/xml/ejemplo.xml
c:/xml/example.xsl
En este ejemplo, al usar etiquetas simples para acceder al código más potente detrás de escena, se carga un XML y se genera un resultado a través de un archivo XSL y se envía al cliente, todo a través de Esto se hace usando una simple llamada de etiqueta.
Las etiquetas personalizadas abren la puerta a la creación de código fácilmente reutilizable en proyectos JSP. Todo lo que necesitas es una biblioteca de etiquetas y su documentación.
2. Componentes de etiquetas Aunque la biblioteca de etiquetas es muy fácil de usar, es bastante complicado crear un diseño interno para soportar la biblioteca de etiquetas, al menos más complicado que crear un JavaBean simple. La complejidad proviene del hecho de que la biblioteca de etiquetas se compone de varias partes. Sin embargo, sólo necesitas conocer Java y JSP.
Una etiqueta simple consta de los siguientes elementos:
⑴ JavaBeans: para obtener los beneficios inherentes de Java orientados a objetos, el código reutilizable debe colocarse en un contenedor de código independiente. Estos JavaBeans no forman parte de la biblioteca de etiquetas. Pero es el bloque básico de código que utiliza su base de código para realizar tareas relacionadas.
⑵ Procesamiento de etiquetas: este es el verdadero núcleo de la biblioteca de etiquetas. Un controlador de etiquetas hará referencia a cualquier recurso que necesite (sus JavaBeans) y accederá a toda la información sobre su página JSP (el objeto pageContext). La página JSP también transmitirá todos los atributos de etiqueta que se hayan configurado y el contenido del cuerpo de la etiqueta en la página JSP al procesador de etiquetas. Una vez que el procesador de etiquetas haya terminado de procesar, enviará la salida a su página JSP para su procesamiento.
⑶ Descripción de la biblioteca de etiquetas (archivo tld): este es un archivo XML simple que registra los atributos, la información y la ubicación del procesador de etiquetas. El contenedor JSP utiliza este archivo para saber dónde y cómo llamar a una biblioteca de etiquetas.
⑷ Archivo web.xml del sitio web: este es el archivo de inicialización de su sitio web. En este archivo, usted define las etiquetas personalizadas utilizadas en el sitio web y qué archivo tld se utiliza para describir cada etiqueta personalizada.
⑸ Archivo de distribución (un archivo WAR o JAR): si desea reutilizar etiquetas personalizadas, necesita una forma de transferirlas de un proyecto a otro. Empaquetar la biblioteca de etiquetas en un archivo JAR es una forma sencilla y eficaz.
⑹ Haga una declaración de biblioteca de etiquetas en su archivo JSP: es muy simple si desea usar esta etiqueta, simplemente declarela en la página. Después de eso, puede usarla en cualquier parte de la página JSP.
Parece mucho trabajo por hacer, pero en realidad no es tan difícil. La cuestión no es codificar, sino organizar las piezas correctamente. Sin embargo, esta estratificación es importante porque hace que el uso de la etiqueta sea flexible y más fácil de transferir. Más importante aún, estas capas existen para automatizar el proceso de creación de etiquetas a través de un IDE JSP (entorno de desarrollo integrado JSP). Se espera que los futuros IDE JSP puedan completar automáticamente la mayor parte del trabajo de creación de etiquetas personalizadas, de modo que solo necesite escribir código y procesar etiquetas.
Nota: Un controlador de etiquetas define solo una etiqueta personalizada; una biblioteca de etiquetas es una colección de varios procesadores de etiquetas que manejan la misma tarea.
3. Cree sus propias etiquetas. Lo siguiente le enseñará paso a paso cómo crear etiquetas personalizadas. El ejemplo específico es extender JSP para que tenga su propia función de codificación HTML. Esta característica reemplaza todos los caracteres < y > con código HTML. Se puede ampliar fácilmente para realizar otros procesos de codificación. Para simplificar, este ejemplo solo explica los elementos básicos para crear una etiqueta personalizada.
⑴ Crear un JavaBean
Cualquier parte reutilizable de su código debe colocarse en un JavaBean. Esto es importante porque a menudo utilizará este código en otras partes del proyecto. Cualquier código colocado dentro de un controlador de etiquetas no es reutilizable fuera de la etiqueta, por lo que es importante aislar las partes del código reutilizables. En este ejemplo, la lógica codificada para HTML es común y, por lo tanto, se ubica en un JavaBean.
⑵ Codificación HTML JavaBean
/* HTML_Format.Java */
la clase pública HTML_Format extiende el objeto implementa Java.io.Serializable {
/** Crear nuevo HTML_Format */
HTML_Format público() {}
/** Reemplace todos los caracteres < y > en una cadena con la codificación HTML de respuesta */
Cadena pública HTML_Encode (Cadena como_datos)
{
int li_len = as_data.length();
/*La longitud del buffer de cadena es más larga que la cadena original*/
StringBuffer lsb_encode = nuevo StringBuffer(li_len + (li_len/10));
/* Bucle para reemplazar todos los caracteres < y >*/
para(int li_count = 0; li_count < li_len; li_count++)
{ Cadena ls_next = String.valueOf(as_data.charAt(li_count));
if (ls_next.equals("<")) ls_next = "<";
if (ls_next.equals(">")) ls_next = ">";
lsb_encode.append(ls_next);
}
return(lsb_encode.toString());
}
}
⑶ Cree un procesador de etiquetas. El procesador de etiquetas utiliza el siguiente código:
Procesador de etiquetas de codificación HTML.
importar Java.io.IOException;
importar Javax.servlet.jsp.*;
importar Javax.servlet.jsp.tagext.*;
la clase pública HTML_FormatTag extiende BodyTagSupport
{
/* 1} Esta función será llamada al final de la etiqueta*/
public int doEndTag() lanza JspTagException
{
intentar
{ /* 2} Obtener el texto en la etiqueta */
Contenido del cuerpo l_tagbody = getBodyContent();
Cadena ls_output = "";
/* 3} Si el cuerpo de la etiqueta tiene texto, procéselo */
si (l_tagbody! = nulo)
{ HTML_Format l_format = nuevo HTML_Format();
/* 3a} Convierte el contenido del cuerpo de la etiqueta en una cadena */
Cadena ls_html_text = l_tagbody.getString();
ls_output = l_format.HTML_Encode(ls_html_text);
}
/* 4}Escribe los resultados en el flujo de datos*/
pageContext.getOut().write(ls_output.trim());
}
captura (IOException e)
{ throw new JspTagException("Error de etiqueta:" + e.toString());
}
/* Deja que JSP continúe procesando el contenido de las siguientes páginas*/
devolver EVAL_PAGE;
}
}
Este procesamiento es muy sencillo, incluye:
o Leer el texto entre el principio y el final de la etiqueta o Llamar a la función de codificación html o Devolver el resultado a la página JSP.
⑷ La creación de un descriptor de etiqueta debe describir la etiqueta personalizada para que el sistema sepa cómo procesarla. El sufijo de este archivo de descripción es .tld, normalmente su nombre es el mismo que el del procesador de etiquetas y se almacena en el directorio "/WEB-INF/".
Descriptor de etiqueta de codificación HTML
<?xml versión="1.0" codificación="UTF-8" ?>
<!DOCTYPE etiquetalib
PUBLIC "-//Sun Microsystems, Inc.//Biblioteca de etiquetas DTD JSP 1.1//ES"
" http://Java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd ">
<TAGLIB>
<TLIBVERSION>1.0</TLIBVERSION>
<JSPVERSION>1.1</JSPVERSION>
<SHORTNAME>HTML_FormatTag</SHORTNAME>
<URI></URI>
<INFO>Etiqueta de codificación HTML </INFO>
<ETIQUETA>
<NOMBRE>Código HTML</NOMBRE>
<TAGCLASS>HTML_FormatTag</TAGCLASS>
<INFO>Codificar HTML</INFO>
</TAG>
</TAGLIB>
⑸ Actualice el archivo Web XML para indicarle al contenedor JSP que use la biblioteca de etiquetas. Para hacer esto, debe modificar el archivo web.xml. Específicamente, debe agregar un proyecto taglib para registrar la biblioteca de etiquetas. Lo más importante es asignar un URI a la etiqueta. Un URI es una referencia única que se aplica únicamente a esta etiqueta particular en el sitio web. Es una buena práctica utilizar la URL completa o el nombre del paquete para garantizar la unicidad, ya que la etiqueta se puede utilizar en diferentes sitios web. Este ejemplo está simplificado.
Modificar el archivo web.xml
<?xml versión="1.0" codificación="ISO-8859-1"?>
<!DOCTYPE aplicación web
PÚBLICO "-//Sun Microsystems, Inc.//Aplicación web DTD 2.2//ES"
" http://Java.sun.com/j2ee/dtds/web-app_2.2.dtd ">
<APLICACIÓN WEB>
<TAGLIB>
<TAGLIB-URI>
Codificación HTML
</TAGLIB-URI>
<UBICACIÓN-TAGLIB>
/WEB-INF/HTML_FormatTag.tld
</TAGLIB-UBICACIÓN>
</TAGLIB>
</WEB-APP>
⑹ La etiqueta personalizada que utiliza etiquetas nuevas se ha configurado y se puede utilizar en una página JSP. Para hacer esto, simplemente declare la etiqueta en la página usando la directiva taglib. La etiqueta es referenciada por su URI único y se le asigna un prefijo de espacio de nombres. El prefijo puede ser arbitrario siempre que no entre en conflicto con otros espacios de nombres.
Utilice etiquetas de codificación HTML en una página JSP:
<%@ taglib uri="HTMLEncode" prefix="Ejemplos" %>
<PRE>
<?XML:NAMESPACE PREFIX = Ejemplos /><Ejemplos:HTMLEncode>
<Hola, muestra sencilla>
</Ejemplos:HTMLEncode>
</PRE>
Salida de código de muestra
<Hola, muestra sencilla>
que se muestra como:
<Hola, muestra simple>
Con esta etiqueta codifiqué todo el código de la página. Lo interesante es que todas las etiquetas personalizadas se manejan en el servidor. Esto significa que no verá etiquetas personalizadas en la página de salida.
No es difícil crear una etiqueta. La parte más difícil es aprender todos los entresijos del procesamiento de etiquetas. Esta es una característica muy poderosa y solo hemos tocado lo básico. Debido a que este proceso requiere varios pasos, los nuevos programadores JSP se sentirán confundidos al crear etiquetas.
¿Cómo utilizar JSP para desarrollar aplicaciones DOM?
DOM es la abreviatura de Document Object Model, que es el modelo de objetos de documento. XML organiza los datos en un árbol, por lo que DOM es una descripción de objeto de este árbol. En términos sencillos, se trata de construir lógicamente un modelo de árbol para el documento XML analizando el documento XML, y los nodos del árbol son objetos. Podemos acceder al contenido de los documentos XML accediendo a estos objetos.
Veamos un ejemplo simple a continuación para ver cómo operamos un documento XML en el DOM. Este es un documento XML y el objeto sobre el que queremos operar:
<?xml version="1.0" encoding="UTF-8"?>
<mensajes>
<message>¡Adiós serialización, hola Java!</message>
</messages>
A continuación, necesitamos analizar el contenido de este documento en objetos Java para que lo utilice el programa. Usando JAXP, podemos hacer esto con solo unas pocas líneas de código. Primero, necesitamos crear una fábrica de analizadores para usar esta fábrica para obtener un objeto de analizador específico:
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
El propósito de usar DocumentBuilderFacotry aquí es crear un programa que sea independiente del analizador específico. Cuando se llama al método estático newInstance() de la clase DocumentBuilderFactory, determina qué analizador usar en función de una variable del sistema. Y como todos los analizadores obedecen a la interfaz definida por JAXP, el código es el mismo sin importar qué analizador se utilice. Entonces, al cambiar entre diferentes analizadores, solo necesita cambiar los valores de las variables del sistema sin cambiar ningún código. Este es el beneficio de la fábrica.
DocumentBuilder db = dbf.newDocumentBuilder();
Después de obtener un objeto de fábrica, utilice su método estático newDocumentBuilder () para obtener un objeto DocumentBuilder, que representa un analizador DOM específico. Pero qué analizador sea, de Microsoft o de IBM, no es importante para el programa.
Luego, podemos usar este analizador para analizar el documento XML:
Documento doc = db.parse("c:/xml/message.xml");
El método parse() de DocumentBuilder acepta un nombre de documento XML como parámetro de entrada y devuelve un objeto Documento. Este objeto Documento representa un modelo de árbol de un documento XML. Todas las operaciones futuras en documentos XML no tienen nada que ver con el analizador y pueden operarse directamente en este objeto Documento. El método específico de operación del Documento está definido por el DOM.
A partir del objeto Documento obtenido, podemos comenzar nuestro viaje DOM. Usando el método getElementsByTagName() del objeto Documento, podemos obtener un objeto NodeList. Un objeto Node representa un elemento de etiqueta en un documento XML, y el objeto NodeList, como puede ver por su nombre, representa un objeto Node List:
NodeList nl = doc.getElementsByTagName("mensaje");
Lo que obtenemos a través de dicha declaración es una lista de objetos Node correspondientes a todas las etiquetas <message> en el documento XML. Luego, podemos usar el método item() del objeto NodeList para obtener cada objeto Node en la lista:
Nodo mi_nodo = nl.item(0);
Cuando se crea un objeto Node, los datos almacenados en el documento XML se extraen y se encapsulan en el objeto Node. En este ejemplo, para extraer el contenido dentro de la etiqueta Mensaje, normalmente usamos el método getNodeValue() del objeto Nodo:
Mensaje de cadena = my_node.getFirstChild().getNodeValue();
Tenga en cuenta que aquí también se utiliza un método getFirstChild() para obtener el primer objeto Nodo secundario debajo del mensaje. Aunque no hay otras subetiquetas o atributos debajo de la etiqueta del mensaje excepto el texto, insistimos en usar el método getFirseChild () aquí, que está relacionado principalmente con la definición de DOM del W3C. W3C también define la parte de texto dentro de la etiqueta como un Nodo, por lo que primero debemos obtener el Nodo que representa el texto antes de poder usar getNodeValue() para obtener el contenido del texto. Ahora, como hemos podido extraer los datos del archivo XML, podemos utilizar estos datos en el lugar apropiado para crear la aplicación.
Ejemplo de DOM
Primero hablemos de lo que va a hacer este ejemplo. Hemos guardado algunas direcciones URL en un archivo llamado enlace. La dirección URL agregada está escrita en este archivo XML. Es muy simple, pero muy práctico, y es suficiente para ilustrar la mayor parte del uso de DOM.
El primer programa se llama xmldisplay.Java. Su función principal es leer el contenido de cada nodo en este archivo XML y luego formatear la salida en System.out. Echemos un vistazo a este programa:
import Javax.xml.parsers. *;
import org.w3c.dom.*;
Esto es para presentar las clases necesarias, porque aquí se utiliza el analizador XML proporcionado por Sun, por lo que es necesario introducir el paquete Java.xml.parsers, que contiene el analizador DOM y el análisis SAX. La implementación específica del dispositivo. El paquete org.w3c.dom define la interfaz DOM desarrollada por w3c.
DocumentBuilderFactory fábrica = DocumentBuilderFactory.newInstance();
Constructor de DocumentBuilder=factory.newDocumentBuilder();
Documento doc=builder.parse("links.xml");
doc.normalize();
Además de lo anterior, también hay un pequeño truco: llamar a normalize() en el objeto Documento puede eliminar objetos de nodo de texto innecesarios asignados en el árbol DOM como espacios en blanco en el documento XML. De lo contrario, es posible que el árbol DOM que obtenga no sea lo que imaginaba. Especialmente al generar, este normalize() es más útil.
Enlaces NodeList =doc.getElementsByTagName("link");
Como se mencionó hace un momento, los caracteres de espacio en blanco en los documentos XML también se asignarán como objetos en el árbol DOM. Por lo tanto, llamar directamente al método getChildNodes del método Node a veces tiene algunos problemas y, a veces, no puede devolver el objeto NodeList esperado. La solución es utilizar getElementByTagName(String) de Element, y el NodeLise devuelto es el objeto esperado. Luego, puede utilizar el método item() para extraer el elemento deseado.
para (int i=0;i<links.getLength();i++){
Enlace de elemento=(Elemento) enlaces.item(i);
System.out.print("Contenido: ");
System.out.println(link.getElementsByTagName("text").item(0).getFirstChild();
.getNodeValue());
...
El fragmento de código anterior completa la salida formateada del contenido del documento XML. Siempre que prestes atención a algunos detalles, como el uso del método getFirstChile() y el método getElementsByTagName(), son relativamente fáciles.
El siguiente contenido trata sobre reescribir el árbol DOM en el documento XML después de modificarlo. Este programa se llama xmlwrite.Java. En la versión JAXP 1.0, no existen clases ni métodos directos que puedan manejar la escritura de documentos XML, y es necesario utilizar algunas clases auxiliares en otros paquetes. En la versión JAXP 1.1, se introdujo soporte para XSLT. El llamado XSLT sirve para obtener una nueva estructura de documento después de transformar el documento XML (Traducción). Usando esta función recién agregada, podemos escribir fácilmente el árbol DOM recién generado o modificado en el archivo XML. Echemos un vistazo a la implementación del código. La función principal de este código es agregar un nuevo nodo de enlace. Archivo .xml:
importar Javax.xml.parsers.*;
importar Javax.xml.transform.*;
importar Javax.xml.transform.dom.DOMSource;
importar Javax.xml.transform.stream.StreamResult;
import org.w3c.dom.*;
varias clases del paquete Java.xml.transform recientemente introducido se utilizan para manejar transformaciones XSLT.
Esperamos agregar un nuevo nodo de enlace al archivo XML anterior, por lo que primero debemos leer el archivo links.xml, crear un árbol DOM, luego modificar el árbol DOM (agregar nodos) y finalmente agregar el DOM modificado. Archivo links.xml:
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
Constructor de DocumentBuilder=factory.newDocumentBuilder();
Documento doc=builder.parse("links.xml");
doc.normalizar();
//---obtenemos variables----
String text="Página de inicio de Hanzhong";
Cadena url=" www.hzliu.com ";
Autor de cadena = "Hzliu Liu";
String descripción="¡¡Un sitio de Hanzhong Liu, te doy muchas sorpresas!!!";
Para ver los puntos clave claramente y simplificar el procedimiento, codificamos el contenido que se agregará al objeto String de memoria. Durante la operación, a menudo usamos una interfaz para extraer la entrada del usuario o extraer el contenido deseado de la base de datos a través de JDBC.
Texto textseg;
Element link=doc.createElement("link");
En primer lugar, debe quedar claro que no importa qué tipo de Nodo, ya sea tipo Texto, tipo Attr o tipo Elemento, todos se crean a través del objeto Documento CreateXXX( ) método en (XXX representa el tipo específico que se creará), por lo tanto, necesitamos agregar un elemento de enlace al documento XML, primero cree un objeto de enlace:
Elemento linktext=doc.createElement("text");
textseg=doc.createTextNode(texto);
enlacetext.appendChild(textseg);
enlace.appendChild(texto de enlace);
...
El proceso de creación de nodos puede ser un poco uniforme, pero lo que hay que tener en cuenta es que el texto contenido en el Elemento (en el DOM, estos textos también representan un Nodo, por lo que también se deben crear los nodos correspondientes para ellos). Utilice directamente el método setNodeValue () del objeto Elemento para establecer el contenido de estos textos, y debe utilizar el método setNodeValue () del objeto Texto creado para establecer el texto, de modo que el Elemento creado y su contenido de texto puedan ser agregado al árbol DOM. Echa un vistazo al código anterior y lo entenderás mejor:
doc.getDocumentElement().appendChild(enlace);
Finalmente, no olvide agregar el nodo creado al árbol DOM. El método getDocumentElement() de la clase Documento devuelve el objeto Elemento que representa el nodo raíz del documento. En un documento XML, el nodo raíz debe ser único.
TransformerFactory tFactory =TransformerFactory.newInstance();
Transformador transformador = tFactory.newTransformer();
Fuente DOMSource = nueva DOMSource(doc);
Resultado de StreamResult = nuevo StreamResult(new Java.io.File("links.xml"));
transformador.transform(fuente, resultado);
Luego use XSLT para generar el árbol DOM. TransformerFactory aquí también aplica el patrón de fábrica, haciendo que el código específico sea independiente del transformador específico. El método de implementación es el mismo que el de DocumentBuilderFactory, por lo que no entraré en detalles aquí. El método transfrom de la clase Transformer acepta dos parámetros, una fuente de datos y un resultado de destino. DOMSource y StreamResult se utilizan aquí respectivamente, de modo que el contenido del DOM se puede enviar a una secuencia de salida. Cuando la secuencia de salida es un archivo, el contenido del DOM se escribe en el archivo.
¿Cómo utilizar JSP para desarrollar aplicaciones SAX?
SAX es la abreviatura de Simple API para XML. No es un estándar oficial propuesto por el W3C. Se puede decir que es un estándar "popular" de facto. De hecho, es producto de una discusión comunitaria. Aun así, SAX no se usa menos en XML que DOM, y casi todos los analizadores XML lo admiten.
Comparado con DOM, SAX es un método ligero. Sabemos que al procesar DOM, necesitamos leer el documento XML completo, luego crear un árbol DOM en la memoria y generar cada objeto Nodo en el árbol DOM. Cuando el documento es pequeño, esto no causa ningún problema, pero una vez que el documento se hace más grande, el procesamiento del DOM se vuelve bastante laborioso y requiere mucho tiempo. En particular, sus requisitos de memoria también aumentarán exponencialmente, por lo que usar DOM en algunas aplicaciones no es rentable (como en los subprogramas). En este momento, una mejor solución alternativa es SAX.
SAX es conceptualmente completamente diferente de DOM. En primer lugar, a diferencia del controlador de documentos DOM, está controlado por eventos, es decir, no necesita leer el documento completo, y el proceso de lectura del documento también es el proceso de análisis SAX. El llamado impulsado por eventos se refiere a un método de ejecución de programa basado en el mecanismo de devolución de llamada. (Si tiene claro el nuevo modelo de eventos proxy de Java, comprenderá fácilmente este mecanismo). XMLReader acepta el documento XML y lo analiza durante el proceso de lectura del documento XML, es decir, el proceso de lectura del documento. El proceso de análisis se realiza al mismo tiempo, lo cual es muy diferente del DOM. Antes de que comience el análisis, debe registrar un ContentHandler con XMLReader, que es equivalente a un detector de eventos. En ContentHandler se definen muchos métodos, como startDocument(), que personaliza lo que se debe manejar cuando el documento comienza a aparecer durante el análisis. proceso. Cuando XMLReader lee el contenido apropiado, generará el evento correspondiente, delegará la potencia de procesamiento de este evento a ContentHandler y llamará a su método correspondiente para responder.
Puede resultar un poco difícil de entender de forma general, pero no se preocupe, los siguientes ejemplos le ayudarán a comprender el proceso de análisis de SAX. Eche un vistazo a este sencillo archivo XML:
<POEM>
<AUTHOR>Ogden Nash</AUTHOR>
<TITLE>Pulgas</TITLE>
<LINE>Adán</LINE>
</POEM>
Cuando XMLReader lee la etiqueta <POEM>, llama al método ContentHandler.startElement() y pasa el nombre de la etiqueta POEM como parámetro. Se deben realizar las acciones correspondientes en el método startElement() que implemente para manejar lo que se debe hacer cuando aparece <POEM>. Cada evento se descarta uno por uno junto con el proceso de análisis (es decir, el proceso de lectura del documento), y los métodos correspondientes también se llaman secuencialmente. Finalmente, cuando se completa el análisis y se llaman los métodos, se procesa el documento. . Eso es todo. La siguiente tabla enumera los métodos que se llaman secuencialmente al analizar el archivo XML anterior:
Devolución de llamada del método del proyecto encontrado
{inicio del documento} startDocument()
<POEM> startElement(nulo,"POEM",nulo,{Atributos})
"n" caracteres("<POEMA>n...", 6, 1)
<AUTOR> startElement(nulo,"AUTOR",nulo,{Atributos})
Caracteres de "Ogden Nash"("<POEM>n...", 15, 10)
</AUTHOR> endElement(nulo,"AUTOR",nulo)
"n" caracteres("<POEM>n...", 34, 1)
<TÍTULO> startElement(nulo,"TÍTULO",nulo,{Atributos})
Personajes "Pulgas"("<POEM>n...", 42, 5)
</TÍTULO> endElement(nulo,"TÍTULO",nulo)
"n" caracteres("<POEMA>n...", 55, 1)
<LÍNEA> startElement(nulo,"LÍNEA",nulo,{Atributos})
Caracteres de "Adán"("<POEMA>n...", 62, 4)
</LINE> endElement(nulo,"LÍNEA",nulo)
"n" caracteres("<POEM>n...", 67, 1)
</POEM> endElement(nulo,"POEM",nulo)
{Fin del documento} endDocument()
ContentHandler es en realidad una interfaz. Al procesar un archivo XML específico, debe crear una clase que implemente ContentHandler para manejar eventos específicos. Se puede decir que en realidad es el núcleo de procesamiento XML de SAX. el documento. Echemos un vistazo a algunos de los métodos definidos en él:
caracteres vacíos (char [] ch, int start, int length): este método se utiliza para procesar la cadena leída en el archivo XML. Su parámetro es una matriz de caracteres y el punto inicial de la cadena leída en esta matriz. longitud, podemos usar fácilmente un constructor de la clase String para obtener la clase String de esta cadena: String charEncontered=new String(ch,start,length).
void startDocument(): cuando encuentre el comienzo del documento, llame a este método para realizar un trabajo de preprocesamiento.
void endDocument(): correspondiente al método anterior, cuando finaliza el documento, se llama a este método para realizar algún trabajo posterior.
void startElement (String namespaceURI, String localName, String qName, Attributes atts): este método se activará cuando se lea una etiqueta de inicio. Los espacios de nombres no son compatibles con la versión SAX1.0, pero la compatibilidad con espacios de nombres se proporciona en la nueva versión 2.0. El namespaceURI en el parámetro aquí es el espacio de nombres, localName es el nombre de la etiqueta y qName es el prefijo modificado de la etiqueta. no hay Cuando se utilizan espacios de nombres, ninguno de los parámetros es nulo. Y atts es la lista de atributos contenidos en esta etiqueta. A través de atts, puede obtener todos los nombres de atributos y sus valores correspondientes. Cabe señalar que una característica importante de SAX es su procesamiento de transmisión. Cuando encuentra una etiqueta, no registrará las etiquetas encontradas antes. En otras palabras, en el método startElement (), toda la información que conoce es el nombre y los atributos. de la etiqueta En cuanto a la estructura anidada de la etiqueta, el nombre de la etiqueta superior, si hay atributos de subelemento y otra información relacionada con la estructura, se desconoce y necesita su ayuda para completarla. Esto hace que SAX sea menos conveniente para programar que DOM.
void endElement (String namespaceURI, String localName, String qName): este método corresponde al método anterior. Este método se llama cuando se encuentra una etiqueta final.
Seguimos usando el ejemplo de documento que usamos cuando hablamos de DOM, pero primero, veamos una aplicación más simple. Esperamos contar la cantidad de veces que aparece cada etiqueta en un archivo XML. Este ejemplo es muy simple, pero suficiente para ilustrar las ideas básicas de la programación SAX. Por supuesto, la declaración de importación todavía se usa al principio:
import org.xml.sax.helpers.DefaultHandler;
importar Javax.xml.parsers.*;
importar org.xml.sax.*;
importar org.xml.sax.helpers.*;
importar Java.util.*;
import Java.io.*
Luego, creamos una clase que hereda de DefaultHandler. La lógica específica del programa se puede dejar de lado por el momento. A lo que debemos prestar atención es a la estructura del programa:
public class SAXCounter extends DefaultHandler {.
etiquetas Hashtable privadas // Esta Hashtable se utiliza para registrar la cantidad de veces que aparece la etiqueta;
//Trabajar antes de procesar el documento
startDocument public void() lanza SAXException {
etiquetas = new Hashtable();//Inicializar Hashtable
}
//Procesa cada atributo del elemento inicial
elemento de inicio público vacío (String namespaceURI, String localName,
Cadena rawName, Atributos atributos)
lanza SAXException
{
Clave de cadena = nombre local;
...
Veamos qué hace este programa. En el método main(), lo principal que debe hacer es crear un analizador y luego analizar el documento. De hecho, al crear el objeto SAXParser aquí, para que el código del programa sea independiente del analizador específico, se utiliza la misma técnica de diseño que en el DOM: cree un objeto SAXParser específico a través de una clase SAXParserFactory, de modo que cuando sea diferente Al analizar , todo lo que es necesario cambiar es el valor de una variable de entorno, mientras que el código del programa puede permanecer sin cambios. Esta es la idea del patrón FactoryMethod. No entraré en detalles aquí. Si aún no lo comprende, puede consultar la explicación en el DOM anterior.
Pero hay una cosa a tener en cuenta aquí, que es la relación entre la clase SAXParser y la clase XMLReader. Puede que esté un poco confundido. De hecho, SAXParser es una clase contenedora para XMLReader en JAXP, y XMLReader es una interfaz definida en SAX2.0 para analizar documentos. También puede llamar al método parser() en SAXParser o XMLReader para analizar el documento, y el efecto es exactamente el mismo. Sin embargo, el método parser() en SAXParser acepta más parámetros y puede analizar diferentes fuentes de datos de documentos XML, por lo que es más conveniente de usar que XMLReader.
Este ejemplo sólo toca la superficie de SAX, pero el siguiente es más avanzado. La función que queremos implementar a continuación ya se implementó en el ejemplo DOM, que es leer el contenido del documento XML y formatear la salida. Aunque la lógica del programa todavía parece muy simple, SAX no es mejor que DOM.
Como se mencionó anteriormente, cuando encontramos una etiqueta de inicio, en el método startElement(), no podemos obtener la posición de la etiqueta en el documento XML. Esto supone un gran problema al procesar documentos XML, porque la semántica de las etiquetas en XML está determinada en parte por su ubicación. Y en algunos programas que necesitan verificar la estructura del documento, esto es un problema aún mayor. Por supuesto, no hay ningún problema que no pueda resolverse. Podemos utilizar una pila para registrar la estructura del documento.
La característica de la pila es primero en entrar, primero en salir. Nuestra idea actual es usar push para agregar el nombre de la etiqueta a la pila en el método startElemnt() y sacarlo en el método endElement(). Sabemos que para un XML bien estructurado, su estructura de anidamiento está completa. Cada etiqueta inicial siempre corresponde a una etiqueta final y no habrá desalineación entre las etiquetas anidadas. Por lo tanto, cada llamada al método startElement() corresponderá inevitablemente a una llamada al método endElement(), por lo que push y pop también aparecen en pares. Solo necesitamos analizar la estructura de la pila para saber fácilmente dónde está la etiqueta actual. . Posición en la estructura del documento.
Saxreader de clase pública extiende DeFaulthandler {
Java.util.stack etiquetas = new java.util.stack ();
...
Aunque el análisis de la pila no se usa aquí, el análisis de la pila es en realidad una tarea muy fácil. se organiza de abajo hacia arriba. atributos de cada elemento. De hecho, si organizamos los elementos de la pila uno por uno de abajo hacia arriba, obtendremos una ruta única desde el nodo raíz XML al nodo actual. .
Hasta ahora, hemos dominado las dos herramientas principales para la programación XML: DOM y SAX, y también sabemos cómo usarlas en un programa Java. La programación DOM es relativamente simple, pero lenta y toma mucha memoria, mientras que la programación S AX es más compleja, pero rápida y toma menos memoria. Por lo tanto, debemos elegir usar diferentes métodos según diferentes entornos. La mayoría de las aplicaciones XML se pueden resolver básicamente usando ellas. Cabe señalar que DOM y SAX son realmente independientes del lenguaje y no son exclusivos de Java.