Présentation : Le langage XML (eXtensible Markup Language) est rapidement utilisé dans l'industrie. Il est devenu une norme largement utilisée pour décrire et échanger des données dans un format indépendant de la plate-forme, du langage et du protocole. XML et ses spécifications auxiliaires peuvent être utilisés pour décrire la représentation documentaire des données, décrire les limitations des types de documents XML, décrire les liens entre les documents XML et les ressources et décrire la conversion et le formatage automatiques des documents XML.
Comment développer une bibliothèque de balises personnalisée ?
J'utilise la programmation JSP et ASP depuis longtemps. Parmi les deux méthodes de programmation côté serveur, j'ai de plus en plus l'impression que JSP est beaucoup plus puissant. Pour ne rien dire d'autre, la bibliothèque de balises de JSP est la raison pour laquelle j'ai choisi JSP comme outil de développement d'applications Web côté serveur préféré. Pourquoi? Parce que : rapidité de maintenance et de développement. Au sein d’une seule page de serveur, vous pouvez mélanger et faire correspondre diverses méthodes et objets de script. Comme le « béton », ce mélange rend les scripts côté serveur puissants et permet aux programmeurs côté serveur de concevoir des pages Web très flexibles et dynamiques. Cependant, ce mélange gratuit a aussi ses inconvénients, à savoir qu'il est très lourd à maintenir. d'autant plus que le projet s'agrandit, puisque le produit final est maintenu par un concepteur Web traditionnel, et pire encore, la vitesse de développement augmente à mesure que la complexité du code augmente. Elle deviendra plus lente et n'est pas propice au développement de support et. des applications web à grande échelle. Une fois développé, le site aura encore besoin de trouver des programmeurs qualifiés pour maintenir ces codes plutôt complexes.
Heureusement, JSP offre une bonne solution. Les bibliothèques de balises offrent un moyen simple de créer un bloc de code réutilisable. Une fois qu’une bibliothèque de balises est conçue, elle peut être réutilisée dans de nombreux projets. Ce qui est encore plus pratique, c'est que, contrairement à COM et J2EE, vous n'avez pas besoin d'acquérir d'autres compétences pour créer une bibliothèque de balises ! Tant que vous savez écrire du JSP, vous pouvez créer une bibliothèque de balises. Les bibliothèques de balises peuvent également améliorer la maintenance des applications Web. Il s'agit d'une interface XML simple grâce aux balises personnalisées de la page JSP. De cette manière, les concepteurs Web peuvent même créer des applications Web JSP sans aucune connaissance JSP. Ce développement Web ouvert est très efficace pour les opérations d’équipe. Les programmeurs JSP peuvent créer des balises personnalisées et des modules de code d'arrière-plan, tandis que les concepteurs Web peuvent utiliser des balises personnalisées pour créer des applications Web et se concentrer sur la conception Web.
1. Définition de la bibliothèque de balises La bibliothèque de balises JSP (également appelée bibliothèque personnalisée) peut être considérée comme un ensemble de méthodes permettant de générer des scripts basés sur XML, pris en charge par JavaBeans. Conceptuellement, les bibliothèques de balises sont des constructions de code très simples et réutilisables.
Exemples de balises et pages HTML effectuant une conversion XML/XSL
<%@ taglib uri=" http://www.jspinsider.com/jspkit/JAXP " prefix="JAXP"%>
c:/xml/exemple.xml
c:/xml/example.xsl
Dans cet exemple, en utilisant de simples balises pour accéder au code le plus puissant en arrière-plan, un XML est chargé et un résultat est généré via un fichier XSL et envoyé au client, le tout via Ceci est fait en utilisant un simple appel de balise.
Les balises personnalisées ouvrent la porte à la création de code facilement réutilisable dans les projets JSP. Tout ce dont vous avez besoin est une bibliothèque de balises et sa documentation.
2. Composants de balises Bien que la bibliothèque de balises soit très simple à utiliser, il est assez compliqué de créer une conception interne pour prendre en charge la bibliothèque de balises, du moins plus compliqué que de créer un simple JavaBean. La complexité vient du fait que la bibliothèque de balises est composée de plusieurs parties. Cependant, il vous suffit de connaître Java et JSP.
Une balise simple se compose des éléments suivants :
⑴ JavaBeans : Afin d'obtenir les avantages inhérents à l'orientation objet de Java, le code réutilisable doit être placé dans un conteneur de code indépendant. Ces JavaBeans ne font pas partie de la bibliothèque de balises. Mais il s’agit du bloc de code de base que votre base de code utilise pour effectuer les tâches associées.
⑵ Traitement des balises : C'est le véritable cœur de la bibliothèque de balises. Un gestionnaire de balises référencera toutes les ressources dont il a besoin (vos JavaBeans) et accédera à toutes les informations sur votre page JSP (l'objet pageContext). La page JSP transmettra également tous les attributs de balise qui ont été définis et le contenu du corps de la balise sur la page JSP au processeur de balises. Une fois le traitement terminé, le processeur de balises renvoie la sortie à votre page JSP pour traitement.
⑶ Description de la bibliothèque de balises (fichier tld) : Il s'agit d'un simple fichier XML qui enregistre les attributs, les informations et l'emplacement du processeur de balises. Le conteneur JSP utilise ce fichier pour savoir où et comment appeler une bibliothèque de balises.
⑷ Fichier web.xml du site Web : Il s'agit du fichier d'initialisation de votre site Web. Dans ce fichier, vous définissez les balises personnalisées utilisées dans le site Web et quel fichier tld est utilisé pour décrire chaque balise personnalisée.
⑸ Fichier de distribution (un fichier WAR ou JAR) : Si vous souhaitez réutiliser des balises personnalisées, vous avez besoin d'un moyen de les transférer d'un projet à un autre. L'empaquetage de la bibliothèque de balises dans un fichier JAR est un moyen simple et efficace.
⑹ Faites une déclaration de bibliothèque de balises dans votre fichier JSP : C'est très simple. Si vous souhaitez utiliser cette balise, déclarez-la simplement sur la page. Après cela, vous pouvez l'utiliser n'importe où dans la page JSP.
Cela semble représenter beaucoup de travail, mais ce n'est en réalité pas si difficile. Il ne s’agit pas de coder, mais d’organiser correctement les pièces. Cependant, cette superposition est importante car elle rend l’utilisation des étiquettes flexible et plus facile à transférer. Plus important encore, ces couches existent pour automatiser le processus de création de balises via un IDE JSP (JSP Integrated Development Environment). On s'attend à ce que les futurs IDE JSP puissent effectuer automatiquement la plupart du travail de création d'une balise personnalisée, de sorte que vous n'ayez qu'à écrire du code et à traiter les balises.
Remarque : Un gestionnaire de balises définit une seule balise personnalisée ; une bibliothèque de balises est un ensemble de plusieurs processeurs de balises qui gèrent la même tâche.
3. Créez vos propres balises. Ce qui suit vous apprendra étape par étape comment créer des balises personnalisées. L'exemple spécifique consiste à étendre JSP afin qu'il dispose de sa propre fonction d'encodage HTML. Cette fonctionnalité remplace tous les caractères < et > par du code HTML. Il peut être facilement étendu pour effectuer d’autres traitements d’encodage. Pour simplifier, cet exemple explique uniquement les éléments de base de la création d'une balise personnalisée.
⑴ Créer un JavaBean
Toute partie réutilisable de votre code doit être placée dans un JavaBean. Ceci est important car vous utiliserez souvent ce code ailleurs dans le projet. Tout code placé dans un gestionnaire de balises n'est pas réutilisable en dehors de la balise, il est donc important d'isoler les parties de code réutilisables. Dans cet exemple, la logique codée pour HTML est commune et donc placée dans un JavaBean.
⑵ Codage HTML JavaBean
/* HTML_Format.Java */
la classe publique HTML_Format étend l'objet implémente Java.io.Serialised {
/** Créer un nouveau HTML_Format */
public HTML_Format() {}
/** Remplacez tous les caractères < et > d'une chaîne par l'encodage HTML de la réponse */
chaîne publique HTML_Encode (chaîne as_data)
{
int li_len = as_data.length();
/*La longueur du tampon de chaîne est plus longue que la chaîne d'origine*/
StringBuffer lsb_encode = new StringBuffer(li_len + (li_len/10));
/* Boucle pour remplacer tous les caractères < et >*/
pour(int li_count = 0; li_count < li_len; li_count++)
{ String 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());
}
}
⑶ Créez un processeur de balises. Le processeur de balises utilise le code suivant :
Processeur de balises d'encodage HTML.
importer Java.io.IOException ;
importer Javax.servlet.jsp.* ;
importer Javax.servlet.jsp.tagext.* ;
la classe publique HTML_FormatTag étend BodyTagSupport
{
/* 1} Cette fonction sera appelée à la fin de la balise*/
public int doEndTag() lance JspTagException
{
essayer
{ /* 2} Récupère le texte dans l'étiquette */
BodyContent l_tagbody = getBodyContent();
Chaîne ls_output = "" ;
/* 3} Si le corps de la balise contient du texte, traitez-le */
si(l_tagbody != null)
{ HTML_Format l_format = new HTML_Format();
/* 3a} Convertit le contenu du corps de la balise en chaîne */
Chaîne ls_html_text = l_tagbody.getString();
ls_output = l_format.HTML_Encode(ls_html_text);
}
/* 4}Réécrire les résultats dans le flux de données*/
pageContext.getOut().write(ls_output.trim());
}
attraper (IOException e)
{ throw new JspTagException("Tag Error:" + e.toString());
}
/* Laisser JSP continuer à traiter le contenu des pages suivantes*/
renvoyer EVAL_PAGE ;
}
}
Ce traitement est très simple, il comprend :
o Lire le texte entre le début et la fin de la balise o Appeler la fonction d'encodage html o Renvoyer le résultat à la page JSP.
⑷ La création d'un descripteur de balise doit décrire la balise personnalisée afin que le système sache comment la traiter. Le suffixe de ce fichier de description est .tld, généralement son nom est le même que celui du processeur de balises, et il est stocké dans le répertoire "/WEB-INF/".
Descripteur de balise d'encodage HTML
PUBLIC "-//Sun Microsystems, Inc.//Bibliothèque de balises DTD JSP 1.1//EN"
" http://Java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd ">
<ÉTIQUETTE>
⑸ Mettez à jour le fichier Web XML pour indiquer désormais au conteneur JSP d'utiliser la bibliothèque de balises. Pour ce faire, vous devez modifier le fichier web.xml. Plus précisément, vous devez ajouter un projet taglib pour enregistrer la bibliothèque de balises. Plus important encore, attribuez un URI à la balise. Un URI est une référence unique qui s'applique uniquement à cette balise particulière sur le site Web. C'est une bonne pratique d'utiliser l'URL complète ou le nom du package pour garantir l'unicité puisque la balise peut être utilisée sur différents sites Web. Cet exemple est simplifié.
Modifier le fichier web.xml
PUBLIC "-//Sun Microsystems, Inc.//Application Web DTD 2.2//EN"
" http://Java.sun.com/j2ee/dtds/web-app_2.2.dtd ">
HTMLEncode
/WEB-INF/HTML_FormatTag.tld
⑹ La balise personnalisée utilisant de nouvelles balises a été mise en place et peut être utilisée sur une page JSP. Pour ce faire, déclarez simplement la balise sur la page à l'aide de la directive taglib. La balise est référencée par son URI unique et se voit attribuer un préfixe d'espace de noms. Le préfixe peut être arbitraire tant qu'il n'entre pas en conflit avec d'autres espaces de noms.
Utiliser des balises d'encodage HTML sur une page JSP :
<%@ taglib uri="HTMLEncode" prefix="Examples" %>
Exemple de sortie de code
qui s'affiche comme suit :
Avec cette balise, j'ai encodé tout le code de la page. Ce qui est intéressant, c’est que toutes les balises personnalisées sont gérées sur le serveur. Cela signifie que vous ne verrez pas de balises personnalisées sur la page de sortie.
Il n'est pas difficile de créer un label. Le plus difficile est d’apprendre tous les tenants et aboutissants du traitement des étiquettes. Il s'agit d'une fonctionnalité très puissante, et nous n'avons abordé que les bases. Étant donné que ce processus nécessite plusieurs étapes, les nouveaux programmeurs JSP seront confus lors de la création de balises.
Comment utiliser JSP pour développer des applications DOM ?
DOM est l'abréviation de Document Object Model, qui est le modèle objet de document. XML organise les données dans une arborescence, donc DOM est une description d'objet de cette arborescence. En termes simples, il s'agit de construire logiquement un modèle d'arborescence pour le document XML en analysant le document XML, et les nœuds de l'arborescence sont des objets. Nous pouvons accéder au contenu des documents XML en accédant à ces objets.
Regardons un exemple simple ci-dessous pour voir comment nous exploitons un document XML dans le DOM. Il s'agit d'un document XML et de l'objet sur lequel nous voulons opérer :
Ensuite, nous devons analyser le contenu de ce document en objets Java destinés à être utilisés par le programme. En utilisant JAXP, nous pouvons le faire avec seulement quelques lignes de code. Tout d’abord, nous devons créer une fabrique d’analyseurs pour utiliser cette fabrique afin d’obtenir un objet analyseur spécifique :
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
Le but de l'utilisation de DocumentBuilderFacotry ici est de créer un programme indépendant de l'analyseur spécifique. Lorsque la méthode statique newInstance() de la classe DocumentBuilderFactory est appelée, elle détermine quel analyseur utiliser en fonction d'une variable système. Et comme tous les analyseurs obéissent à l'interface définie par JAXP, le code est le même quel que soit l'analyseur utilisé. Ainsi, lorsque vous basculez entre différents analyseurs, il vous suffit de modifier les valeurs des variables système sans modifier aucun code. C'est l'avantage de l'usine.
DocumentBuilder db = dbf.newDocumentBuilder();
Après avoir obtenu un objet d'usine, utilisez sa méthode statique newDocumentBuilder() pour obtenir un objet DocumentBuilder, qui représente un analyseur DOM spécifique. Mais de quel analyseur il s'agit, celui de Microsoft ou celui d'IBM, n'a pas d'importance pour le programme.
Ensuite, nous pouvons utiliser cet analyseur pour analyser le document XML :
Document doc = db.parse("c:/xml/message.xml");
La méthode parse() de DocumentBuilder accepte un nom de document XML comme paramètre d'entrée et renvoie un objet Document. Cet objet Document représente un modèle arborescent d'un document XML. Toutes les opérations futures sur les documents XML n'ont rien à voir avec l'analyseur et peuvent être effectuées directement sur cet objet Document. Le mode spécifique d'exploitation du Document est défini par les DOM.
À partir de l'objet Document obtenu, nous pouvons commencer notre voyage DOM. En utilisant la méthode getElementsByTagName() de l'objet Document, nous pouvons obtenir un objet NodeList. Un objet Node représente un élément de balise dans un document XML, et l'objet NodeList, comme vous pouvez le voir d'après son nom, représente un objet Node List :
NodeList nl = doc.getElementsByTagName("message");
Ce que nous obtenons grâce à une telle instruction est une liste d'objets Node correspondant à toutes les balises
Nœud mon_node = nl.item(0);
Lorsqu'un objet Node est créé, les données stockées dans le document XML sont extraites et encapsulées dans le Node. Dans cet exemple, pour extraire le contenu de la balise Message, nous utilisons généralement la méthode getNodeValue() de l'objet Node :
Message de chaîne = my_node.getFirstChild().getNodeValue();
Veuillez noter qu'une méthode getFirstChild() est également utilisée ici pour obtenir le premier objet Node enfant sous le message. Bien qu'il n'y ait pas d'autres sous-balises ou attributs sous la balise message à l'exception du texte, nous insistons ici pour utiliser la méthode getFirseChild(), qui est principalement liée à la définition du DOM du W3C. Le W3C définit également la partie texte dans la balise comme un nœud, nous devons donc d'abord obtenir le nœud représentant le texte avant de pouvoir utiliser getNodeValue() pour obtenir le contenu du texte. Maintenant que nous avons pu extraire les données du fichier XML, nous pouvons utiliser ces données à l'endroit approprié pour construire l'application.
Exemple DOM
Parlons d'abord de ce que cet exemple va faire. Nous avons enregistré quelques adresses URL dans un fichier nommé lien. L'adresse URL ajoutée est écrite dans ce fichier XML. C'est très simple, mais très pratique, et cela suffit à illustrer l'essentiel de l'utilisation du DOM.
Le premier programme s'appelle xmldisplay.Java. Sa fonction principale est de lire le contenu de chaque nœud de ce fichier XML, puis de formater la sortie sur System.out. Jetons un coup d'œil à ce programme :
import Javax.xml.parsers . *;
import org.w3c.dom.*;
Il s'agit d'introduire les classes nécessaires, car l'analyseur XML fourni par Sun est utilisé ici, donc le package Java.xml.parsers doit être introduit, qui contient l'analyseur DOM et l'analyse SAX. La mise en œuvre spécifique du dispositif. Le package org.w3c.dom définit l'interface DOM développée par w3c.
Usine DocumentBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Document doc=builder.parse("links.xml");
doc.normalize();
En plus de ce qui précède, il existe également une petite astuce. L'appel de normalize() sur l'objet Document peut supprimer les objets Text Node inutiles mappés dans l'arborescence DOM en tant que blancs dans le document XML en tant que contenu formaté. Sinon, l’arborescence DOM que vous obtenez pourrait ne pas être celle que vous imaginiez. Surtout lors de la sortie, cette normalize() est plus utile.
NodeList links =doc.getElementsByTagName("link");
Comme mentionné tout à l'heure, les espaces dans les documents XML seront également mappés en tant qu'objets dans l'arborescence DOM. Par conséquent, l'appel direct de la méthode getChildNodes de la méthode Node pose parfois des problèmes et ne peut parfois pas renvoyer l'objet NodeList attendu. La solution consiste à utiliser getElementByTagName(String) d'Element, et le NodeLise renvoyé est l'objet attendu. Ensuite, vous pouvez utiliser la méthode item() pour extraire l’élément souhaité.
pour (int i=0;i
System.out.print("Contenu : ");
System.out.println(link.getElementsByTagName("text").item(0).getFirstChild();
.getNodeValue());
...
L'extrait de code ci-dessus complète la sortie formatée du contenu du document XML. Tant que vous faites attention à certains détails, tels que l'utilisation de la méthode getFirstChile() et de la méthode getElementsByTagName(), celles-ci sont relativement simples.
Le contenu suivant concerne la réécriture de l'arborescence DOM dans le document XML après l'avoir modifié. Ce programme s'appelle xmlwrite.Java. Dans la version JAXP 1.0, il n'existe pas de classes ni de méthodes directes capables de gérer l'écriture de documents XML, et vous devez utiliser certaines classes auxiliaires dans d'autres packages. Dans la version JAXP 1.1, la prise en charge de XSLT a été introduite. Ce que l'on appelle XSLT consiste à obtenir une nouvelle structure de document après transformation du document XML (Traduction). En utilisant cette fonction nouvellement ajoutée, nous pouvons facilement réécrire l'arborescence DOM nouvellement générée ou modifiée dans le fichier XML. Jetons un coup d'œil à l'implémentation du code. La fonction principale de ce code est de lier Ajouter un nouveau nœud de lien au. Fichier .xml :
importez Javax.xml.parsers.* ;
importer Javax.xml.transform.* ;
importer Javax.xml.transform.dom.DOMSource ;
importer Javax.xml.transform.stream.StreamResult ;
import org.w3c.dom.*;
Plusieurs classes du nouveau package Java.xml.transform sont utilisées pour gérer les transformations XSLT.
Nous espérons ajouter un nouveau nœud de lien au fichier XML ci-dessus, nous devons donc d'abord lire le fichier links.xml, construire une arborescence DOM, puis modifier l'arborescence DOM (ajouter des nœuds), et enfin ajouter le DOM modifié Write back au Fichier links.xml :
Usine DocumentBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Document doc=builder.parse("links.xml");
doc.normalize();
//---Obtenir des variables----
String text="Page d'accueil de Hanzhong";
Chaîne url=" www.hzliu.com ";
Chaîne auteur="Hzliu Liu";
String description="Un site de Hanzhong Liu, vous surprendra beaucoup !!!";
Afin de voir clairement les points clés et de simplifier la procédure, nous codons en dur le contenu à ajouter dans l'objet String en mémoire. opération, nous utilisons souvent une interface pour extraire les entrées de l'utilisateur, ou extraire le contenu souhaité de la base de données via JDBC.
Texte texte;
Element link=doc.createElement("link");
Tout d'abord, il doit être clair que quel que soit le type de nœud, qu'il s'agisse du type Text, du type Attr ou du type Element, ils sont tous créés via l'objet Document CreateXXX( ) dans (XXX représente le type spécifique à créer), nous devons donc ajouter un élément de lien au document XML, créez d'abord un objet lien :
Element linktext=doc.createElement("text") ;
textseg=doc.createTextNode(text);
lientext.appendChild(textseg);
lien.appendChild(linktext);
...
Le processus de création de nœuds est peut-être un peu uniforme, mais ce qu'il faut noter, c'est que le texte contenu dans Element (dans le DOM, ces textes représentent également un nœud, donc les nœuds correspondants doivent également être créés pour eux). Utilisez directement la méthode setNodeValue() de l'objet Element pour définir le contenu de ces textes, et vous devez utiliser la méthode setNodeValue() de l'objet Text créé pour définir le texte, afin que l'élément créé et son contenu textuel puissent être ajouté à l'arborescence DOM. Jetez un œil au code précédent et vous comprendrez mieux ceci :
doc.getDocumentElement().appendChild(lien);
Enfin, n'oubliez pas d'ajouter le nœud créé à l'arborescence DOM. La méthode getDocumentElement() de la classe Document renvoie l'objet Element représentant le nœud racine du document. Dans un document XML, le nœud racine doit être unique.
TransformerFactory tFactory =TransformerFactory.newInstance();
Transformateur transformer = tFactory.newTransformer();
Source DOMSource = nouveau DOMSource(doc);
Résultat StreamResult = new StreamResult(new Java.io.File("links.xml"));
transformer.transform(source, result);
Ensuite, utilisez XSLT pour afficher l'arborescence DOM. TransformerFactory applique également ici le modèle d'usine, rendant le code spécifique indépendant du transformateur spécifique. La méthode d’implémentation est la même que celle de DocumentBuilderFactory, je n’entrerai donc pas dans les détails ici. La méthode transfrom de la classe Transformer accepte deux paramètres, une source de données Source et une cible de sortie Result. DOMSource et StreamResult sont utilisés ici respectivement, afin que le contenu du DOM puisse être affiché dans un flux de sortie. Lorsque le flux de sortie est un fichier, le contenu du DOM est écrit dans le fichier.
Comment utiliser JSP pour développer des applications SAX ?
SAX est l'abréviation de Simple API for XML. Ce n'est pas un standard officiel proposé par le W3C. On peut dire qu'il s'agit d'un standard "folk" de facto. En fait, c’est le produit d’une discussion communautaire. Malgré cela, SAX n'est pas moins utilisé en XML que DOM, et presque tous les analyseurs XML le prennent en charge.
Comparé au DOM, SAX est une méthode légère. Nous savons que lors du traitement du DOM, nous devons lire l'intégralité du document XML, puis créer une arborescence DOM en mémoire et générer chaque objet Node sur l'arborescence DOM. Lorsque le document est petit, cela ne pose aucun problème, mais une fois que le document devient plus volumineux, le traitement du DOM devient assez long et laborieux. En particulier, ses besoins en mémoire augmenteront également de façon exponentielle, de sorte que l'utilisation du DOM dans certaines applications n'est pas rentable (comme dans les applets). À l’heure actuelle, une meilleure solution alternative est SAX.
SAX est conceptuellement complètement différent de DOM. Tout d'abord, contrairement au pilote de document DOM, il est piloté par les événements, c'est-à-dire qu'il n'a pas besoin de lire l'intégralité du document, et le processus de lecture du document est également le processus d'analyse syntaxique SAX. Ce que l'on appelle l'événementiel fait référence à une méthode d'exécution de programme basée sur le mécanisme de rappel. (Si vous connaissez bien le nouveau modèle d'événement proxy de Java, vous comprendrez facilement ce mécanisme.) XMLReader accepte le document XML et l'analyse pendant le processus de lecture du document XML, c'est-à-dire le processus de lecture du document. Le processus d'analyse est effectué en même temps, ce qui est très différent du DOM. Avant de commencer l'analyse, vous devez enregistrer un ContentHandler auprès de XMLReader, ce qui équivaut à un écouteur d'événements. De nombreuses méthodes sont définies dans ContentHandler, telles que startDocument(), qui personnalise ce qui doit être géré lorsque le document commence à être rencontré lors de l'analyse. processus. Lorsque XMLReader lit le contenu approprié, il lancera l'événement correspondant, déléguera la puissance de traitement de cet événement à ContentHandler et appellera sa méthode correspondante pour répondre.
Cela peut être un peu difficile à comprendre de manière générale, mais ne vous inquiétez pas, les exemples suivants vous aideront à comprendre le processus d'analyse syntaxique SAX. Jetez un œil à ce simple fichier XML :
Lorsque XMLReader lit la balise
Rappel de méthode de projet rencontré
{document start} startDocument()
"n" caractères("
Caractères "Ogden Nash"("
"n" caractères("
Caractères "Puces"("
endElement(null,"TITLE",null)
"n" caractères("
Caractères "Adam"("
"n" caractères("
{Fin du document} endDocument()
ContentHandler est en fait une interface lors du traitement d'un fichier XML spécifique, vous devez créer une classe qui implémente ContentHandler pour gérer des événements spécifiques. On peut dire qu'il s'agit en fait du traitement XML par SAX. le document. Jetons un coup d'œil à certaines des méthodes qui y sont définies :
void caractères(char[] ch, int start, int length) : Cette méthode est utilisée pour traiter la chaîne lue dans le fichier XML. Son paramètre est un tableau de caractères et le point de départ de la chaîne lue dans ce tableau. length, on peut facilement utiliser un constructeur de la classe String pour obtenir la classe String de cette chaîne : String charEncontered=new String(ch,start,length).
void startDocument() : lorsque vous rencontrez le début du document, appelez cette méthode pour effectuer un travail de prétraitement.
void endDocument() : correspondant à la méthode ci-dessus, lorsque le document se termine, cette méthode est appelée pour effectuer un travail ultérieur.
void startElement (String namespaceURI, String localName, String qName, Attributes atts) : Cette méthode sera déclenchée lors de la lecture d'une balise de début. Les espaces de noms ne sont pas pris en charge dans la version SAX1.0, mais la prise en charge des espaces de noms est fournie dans la nouvelle version 2.0. Le namespaceURI dans le paramètre ici est l'espace de noms, localName est le nom de l'étiquette et qName est le préfixe modifié de l'étiquette If. il n'y a pas Lors de l'utilisation d'espaces de noms, aucun des deux paramètres n'est nul. Et atts est la liste des attributs contenus dans cette balise. Grâce à atts, vous pouvez obtenir tous les noms d'attributs et les valeurs correspondantes. Il convient de noter qu'une fonctionnalité importante de SAX est son traitement en streaming lorsqu'il rencontre une balise, il n'enregistrera pas les balises rencontrées auparavant. En d'autres termes, dans la méthode startElement(), toutes les informations que vous connaissez sont le nom et les attributs. de la balise. Quant à la structure imbriquée de la balise, le nom de la balise supérieure, s'il existe des attributs de sous-éléments et d'autres informations liées à la structure, elles sont inconnues et ont besoin de votre aide pour être complétées. Cela rend SAX moins pratique pour la programmation que DOM.
void endElement(String namespaceURI, String localName, String qName) : Cette méthode correspond à la méthode ci-dessus. Cette méthode est appelée lorsqu'une balise de fin est rencontrée.
Nous utilisons toujours l'exemple de document que nous avons utilisé pour parler du DOM, mais regardons d'abord une application plus simple. Nous espérons compter le nombre de fois où chaque balise apparaît dans un fichier XML. Cet exemple est très simple, mais il suffit à illustrer les idées de base de la programmation SAX. Bien entendu, l'instruction import est toujours utilisée au début :
import org.xml.sax.helpers.DefaultHandler;
importer Javax.xml.parsers.* ;
importer org.xml.sax.* ;
importer org.xml.sax.helpers.* ;
importer Java.util.* ;
import Java.io.*;
Ensuite, nous créons une classe qui hérite de DefaultHandler. La logique spécifique du programme peut être mise de côté pour le moment. Ce à quoi nous devons prêter attention, c'est la structure du programme :
public class SAXCounter extends DefaultHandler {.
Balises de table de hachage privées ; //Cette table de hachage est utilisée pour enregistrer le nombre de fois où la balise apparaît.
//Travailler avant de traiter le document
public void startDocument() lance SAXException {
tags = new Hashtable();//Initialiser la table de hachage
}
//Traitement de chaque attribut d'élément de départ
public void startElement (String namespaceURI, String localName,
Chaîne rawName, Attributs atts)
lance une exception SAXException
{
Clé de chaîne = localName ;
...
Voyons ce que fait ce programme. Dans la méthode main(), la principale chose à faire est de créer un analyseur, puis d'analyser le document. En fait, lors de la création de l'objet SAXParser ici, afin de rendre le code du programme indépendant de l'analyseur spécifique, la même technique de conception que dans le DOM est utilisée : créer un objet SAXParser spécifique via une classe SAXParserFactory, de sorte que lorsqu'il est différent lors de l'analyse , tout ce qui doit être modifié est la valeur d'une variable d'environnement, tandis que le code du programme peut rester inchangé. C'est l'idée du modèle FactoryMethod. Je n'entrerai pas dans les détails ici. Si vous ne comprenez toujours pas, vous pouvez vous référer à l'explication dans le DOM ci-dessus. Le principe est le même.
Mais il y a une chose à noter ici, c'est la relation entre la classe SAXParser et la classe XMLReader. Vous êtes peut-être un peu confus. En fait, SAXParser est une classe wrapper pour XMLReader dans JAXP, et XMLReader est une interface définie dans SAX2.0 pour analyser les documents. Vous pouvez également appeler la méthode parser() dans SAXParser ou XMLReader pour analyser le document, et l'effet est exactement le même. Cependant, la méthode parser() de SAXParser accepte plus de paramètres et peut analyser différentes sources de données de documents XML, elle est donc plus pratique à utiliser que XMLReader.
Cet exemple ne touche qu'à la surface de SAX, mais le suivant est plus avancé. La fonction que nous souhaitons implémenter ci-dessous a déjà été implémentée dans l'exemple DOM, qui consiste à lire le contenu du document XML et à formater la sortie. Bien que la logique du programme semble toujours très simple, SAX n'est pas meilleur que DOM.
Comme mentionné précédemment, lorsque nous rencontrons une balise de début, dans la méthode startElement(), nous ne pouvons pas obtenir la position de la balise dans le document XML. C'est un gros problème lors du traitement de documents XML, car la sémantique des balises XML est en partie déterminée par leur emplacement. Et dans certains programmes qui doivent vérifier la structure du document, cela pose encore plus de problèmes. Bien sûr, il n’y a aucun problème qui ne puisse être résolu. Nous pouvons utiliser une pile pour enregistrer la structure du document.
La caractéristique de la pile est premier entré, premier sorti. Notre idée actuelle est d'utiliser push pour ajouter le nom de l'étiquette à la pile dans la méthode startElemnt(), et de l'afficher dans la méthode endElement(). Nous savons que pour un XML bien structuré, sa structure d'imbrication est complète. Chaque balise de début correspond toujours à une balise de fin, et il n'y aura pas de désalignement entre les imbrications de balises. Par conséquent, chaque appel à la méthode startElement() correspondra inévitablement à un appel à la méthode endElement(), donc push et pop apparaissent également par paires. Il suffit d'analyser la structure de la pile pour savoir facilement où se trouve l'étiquette actuelle. .
classe publique SaxReader étend Defaulthandler {
Java.util.stack tags = new java.util.stack ();
...
Bien que l'analyse de la pile ne soit pas utilisée ici, l'analyse de la pile est en fait une tâche très facile. est organisé de bas en haut. attributs de chaque élément. En fait, si nous organisons les éléments de la pile un par un en bas en haut, nous obtiendrons un chemin unique du nœud racine XML au nœud actuel. .
Jusqu'à présent, nous avons maîtrisé les deux principaux outils pour la programmation XML: DOM et SAX, et nous savons également les utiliser dans un programme Java. La programmation DOM est relativement simple, mais lente et prend beaucoup de mémoire, tandis que la programmation S AX est plus complexe, mais rapide et prend moins de mémoire. Par conséquent, nous devons choisir d'utiliser différentes méthodes selon différents environnements. La plupart des applications XML peuvent essentiellement être résolues en les utilisant. Il convient de noter que DOM et SAX sont en fait indépendants du langage et ne sont pas uniques à Java.