Exemples de sites Web structurés JSP+XML
Auteur：Eve Cole
Date de mise à jour：2009-07-02 17:11:58
XML (Extensible Markup Language) peut ressembler à une sorte de standard du W3C - il a peu d'impact pratique pour le moment, et s'il s'avère utile plus tard, cela prendra du temps. Mais en fait, il est déjà utilisé. N'attendez donc pas que XML soit ajouté à votre éditeur HTML préféré pour commencer à l'utiliser. Il peut désormais résoudre divers problèmes internes et problèmes du système B2B.
Chez Sparks.com, nous utilisons XML pour standardiser la représentation des données sur des systèmes disparates, des objets Java aux affichages de données HTML.
En particulier, nous avons constaté que les données peuvent être partagées et manipulées plus facilement lorsqu'elles sont standardisées sur une structure XML très basique. En cours de route, nous avons découvert de nombreuses façons efficaces d’utiliser XML. Ce qui suit décrit en détail notre application actuelle.
Standardiser Avant d'utiliser XML, créez un format de données XML différent des informations que vous souhaitez utiliser.
Générer du XML dynamique
Générer du HTML à partir d'une base de données n'est pas nouveau, mais générer du XML l'est. Nous introduisons ici les étapes de génération spécifiques.
Utiliser XSL comme langage de modèle
XSL (Extensible Stylesheet Language) est un bon moyen de définir le format d'affichage des données XML, et il serait plus efficace s'il était écrit sous forme de plusieurs modèles statiques.
Générer du HTML
XML plus XSL équivaut à HTML. Cela peut ne pas sembler correct, mais les pages HTML que les utilisateurs voient sont en réalité le résultat de la combinaison de XML et XSL.
1. Normalisation
La puissance de XML vient de sa flexibilité. Mais malheureusement, il est parfois si flexible que vous vous retrouvez avec une page blanche à vous demander comment résoudre le problème.
Dans tout projet XML, la première étape consiste à créer un format de données standard. Pour ce faire, vous devez prendre les décisions suivantes :
&&&
Confirmez les données :
Puisqu’il n’existe pas de format XML standard, les développeurs sont libres de développer leurs propres formats. Toutefois, si votre format n'est reconnu que par une seule application, vous ne pouvez exécuter que cette application pour utiliser le format. Il serait évidemment plus utile s'il existait d'autres programmes capables également de lire votre format XML. Si un format XML est modifié, le système qui l'utilise devra peut-être également être modifié, vous devez donc créer un format aussi complet que possible. Étant donné que la plupart des systèmes ignorent les balises qu'ils ne reconnaissent pas, le moyen le plus sûr de modifier le format d'un XML consiste à ajouter des balises plutôt que de les modifier.
Cliquez ici pour voir des exemples de formats de données XML
Chez Sparks.com, nous avons examiné toutes les données produit nécessaires aux différentes présentations de produits. Bien que toutes les pages n'utilisent pas toutes les données, nous avons développé un format de données XML très complet et adapté à toutes les données. Par exemple, notre page de détails du produit affiche plus de données que notre page de navigation des produits. Cependant, nous utilisons toujours le même format de données dans les deux cas car le modèle XSL de chaque page utilise uniquement les champs dont il a besoin.
S'il faut utiliser la DTD
Chez Sparks.com, nous utilisons du XML bien organisé plutôt que du XML correct, car le premier ne nécessite pas de DTD. DTD ajoute une couche de traitement entre le clic de l'utilisateur et la visualisation de la page. Nous avons constaté que cette couche nécessitait trop de traitement. Bien sûr, il est toujours agréable d'utiliser des DTD pour communiquer avec d'autres entreprises au format XML. Parce que DTD peut garantir que la structure des données est correcte lors de l'envoi et de la réception.
Choisir un moteur d'analyse Il existe désormais plusieurs moteurs d'analyse qui peuvent être utilisés. Le choix que vous choisirez dépend presque entièrement des besoins de votre application. Si vous décidez d'utiliser une DTD, le moteur d'analyse doit permettre à votre XML d'être validé par la DTD. Vous pouvez placer la validation dans un processus distinct, mais cela aurait un impact sur les performances.
SAX et DOM sont deux modèles d'analyse de base. SAX est basé sur les événements, donc lorsque le XML est analysé, les événements sont envoyés au moteur. Ensuite, les événements sont synchronisés avec le fichier de sortie. Le moteur d'analyse DOM crée une structure arborescente hiérarchique pour les données XML dynamiques et les feuilles de style XSL. En accédant de manière aléatoire à l'arborescence DOM, les données XML peuvent être fournies comme si elles étaient déterminées par une feuille de style XSL. Le débat sur le modèle SAX porte principalement sur la réduction excessive de la mémoire de la structure DOM et l'accélération du temps d'analyse des feuilles de style XSL.
Cependant, nous avons constaté que de nombreux systèmes utilisant SAX ne l'utilisaient pas au maximum de ses capacités. Ces systèmes l'utilisent pour construire la structure DOM et envoyer des événements via la structure DOM. Avec cette approche, le DOM doit être construit à partir de la feuille de style avant tout traitement XML, les performances en souffriront donc.
2. Générer du XML dynamique
Une fois le format XML établi, nous avons besoin d'un moyen de le porter dynamiquement depuis la base de données.
La génération de documents XML est relativement simple car elle nécessite uniquement un système capable de gérer des chaînes. Nous avons construit un système utilisant des servlets Java, un serveur Enterprise JavaBean, JDBC et RDBMS (système de gestion de base de données relationnelle).
&&&&
(Pour plus d’informations sur l’application de XSL, consultez XSL comme langage de modèle.)
Exemple de génération de XML Le code réel permettant de créer une docstring XML en Java peut être divisé en plusieurs méthodes et classes.
Le code qui démarre le processus de génération XML est placé dans la méthode EJB. Cette instance crée immédiatement un StringBuffer pour stocker la chaîne XML générée.
StringBuffer xml = new StringBuffer();
xml.append(XmlUtils.beginDocument("/browse_find/browse.xsl", "browse", request));
xml.append(product.toXml());
xml.append(XmlUtils.endDocument("parcourir");
out.print(xml.toString());
Les trois variables xml.append() suivantes sont elles-mêmes des appels à d'autres méthodes.
Génération de l'en-tête du fichier La première méthode supplémentaire appelle la classe XmlUtils pour générer l'en-tête du fichier XML. Le code de notre servlet Java est le suivant :
public static String beginDocument (feuille de style String, page String)
{
StringBuffer xml = new StringBuffer();
xml.append("<?xml version="1.0"?> ")
.append("<?xml-stylesheet href="")
.append(feuille de style).append(""")
.append(" type ="text/xsl"?> ");
xml.append("<").append(page).append("> ");
return xml.toString();
}
Ce code génère l'en-tête du fichier XML. La balise <?xml> définit ce fichier comme un fichier XML prenant en charge la version 1.0. La deuxième ligne de code pointe vers l'emplacement de la feuille de style correcte pour afficher les données. La dernière chose incluse est la balise au niveau de l'élément (<browse> dans cet exemple). A la fin du fichier, seule la balise <browse> doit être fermée.
<?xml version="1.0"?> <?xml-stylesheet href="/browse_find/browse.xsl" type="text/xsl"?> <parcourir>
Après avoir renseigné les informations sur le produit et complété l'en-tête du fichier, la méthode de contrôle appellera l'objet Java pour générer son XML. Dans cet exemple, l'objet produit est appelé. L'objet produit utilise deux méthodes pour générer sa représentation XML. La première méthode toXML() crée le nœud produit en générant les balises <product> et </product>. Il appelle ensuite internalXML(), qui fournit le contenu requis pour le XML du produit. internalXML() est une série d'appels StringBuffer.append(). Le StringBuffer est également converti en chaîne et renvoyé à la méthode de contrôle.
chaîne publique toXml()
{
StringBuffer xml = new StringBuffer("<produit> ");
xml.append(internalXml());
xml.append("</product> ");
return xml.toString();
}
chaîne publique internalXml()
{
StringBuffer xml = nouveau
StringBuffer(" ")
.append(productType).append(" ");
xml.append(" ").append(idValue.trim())
.append(" ");
xml.append(" ").append(idName.trim())
.append(" ");
xml.append(" ").append(page.trim())
.append(" ");
Serrement?
xml.append(" ").append(montant).append(" ");
xml.append(" ").append(vendor).append(" ");
xml.append(" ");
xml.append(" ").append(pubDesc).append(" ");
xml.append(" ").append(venDesc).append(" ";
Serrement?
return xml.toString();
}
Enfin, la méthode XMLUtils.endDocument() est appelée après la fermeture du fichier. Cet appel ferme la balise XML (dans ce cas) et complète enfin le fichier XML structuré. L'intégralité du StringBuffer de la méthode de contrôle est également convertie en chaîne et renvoyée au servlet qui a traité la requête HTTP d'origine.
3. Utilisez XSL comme langage de modèle
Pour obtenir une sortie HTML, nous combinons le fichier XML généré avec un modèle XSL qui contrôle la façon dont les données XML sont représentées. Nos modèles XSL sont constitués de balises XSL et HTML soigneusement organisées.
Commencez à créer le modèle Le début de notre modèle XSL ressemble au code suivant. La première ligne de code est obligatoire et définit ce fichier comme une feuille de style XSL. L'attribut xmlns:xsl= fait référence à l'espace de noms XML utilisé par ce fichier et l'attribut version= définit le numéro de version de l'espace de noms. A la fin du fichier, nous fermons la balise.
La deuxième ligne de code commençant par <xsl:template> détermine le modèle du modèle XSL. L'attribut Match est obligatoire et pointe ici vers la balise XML <basketPage>. Dans notre système, la balise <basketPage> contient la balise <product>, qui permet au modèle XSL d'accéder aux informations sur le produit intégrées dans la balise <product>. Encore une fois, nous devons fermer la balise <xsl:template> à la fin du fichier.
Examinons ensuite le HTML bien organisé. Puisqu’il sera traité par un moteur d’analyse XML, il doit respecter toutes les règles d’un XML bien organisé. Essentiellement, cela signifie que toutes les balises d'ouverture doivent avoir une balise de fermeture correspondante. Par exemple, une balise <P> qui n'est normalement pas fermée doit être fermée avec </P>.
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">
<xsl:template match="basketPage">
<html>
<tête>
<title>Panier / Ajuster la quantité</title>
</tête>
<corps bgcolor="
</xsl:modèle>
</xsl:feuille de style>
Dans le corps du modèle, de nombreuses balises XSL sont utilisées pour fournir une logique de présentation des données. Deux balises couramment utilisées sont expliquées ci-dessous.
Choisir
La balise <xsl:choose> est similaire au début d'une structure if-then-else dans les langages de programmation traditionnels. En XSL, la balise Choose indique que dans la partie où entre le code, l'affectation déclenchera l'action. La balise <xsl:when> avec les attributs attribués suit la balise Choose. Si l'affectation est correcte, le contenu entre les balises d'ouverture et de fermeture de <xsl:when> sera utilisé. Si l'affectation est erronée, le contenu entre les balises d'ouverture et de fermeture de <xsl:otherwise> est utilisé. La section entière se termine par </xsl:choose>.
Dans cet exemple, la balise when vérifie le XML pour la balise de quantité. Si l'étiquette de quantité contient un attribut d'erreur avec une valeur true, l'étiquette de quantité affichera les cellules du tableau répertoriées ci-dessous. Si la valeur de l'attribut n'est pas vraie, XSL affichera autrement le contenu entre les balises. Dans l'exemple ci-dessous, si l'attribut d'erreur n'est pas vrai, rien ne sera affiché.
<xsl:choisir>
<xsl:when test="quantity[@error='true']">
<td bgcolor="src=""/></td>
<td valign="top" bgcolor="<font face="Verdana, Arial" size="1" color="<b>*Pas assez en stock.</b></font>
</td>
</xsl:quand>
<xsl:sinon>
</xsl:sinon>
</xsl:choisir>
Pour chaque
La balise <xsl:for-each> peut être utilisée pour appliquer la même feuille de style à plusieurs situations de données XML similaires. Pour nous, une série d'informations sur les produits peuvent être extraites de la base de données et formatées de manière uniforme sur la page Web. Voici un exemple :
<xsl:for-each select="package">
<xsl:apply-templates select="produit"/>
</xsl:pour-chacun>
La boucle for-each démarre lorsque le programme rencontre une étiquette. Cette boucle se terminera lorsque le programme rencontrera une étiquette. Une fois cette boucle exécutée, ce modèle sera appliqué à chaque fois que l'étiquette apparaît.
4. Générer du HTML
À un moment donné dans le futur, les navigateurs intégreront des moteurs d'analyse XML. À ce stade, vous pouvez envoyer des fichiers XML et XSL directement au navigateur, et celui-ci affiche les données XML conformément aux règles répertoriées dans la feuille de style. Cependant, d’ici là, les développeurs devront créer des capacités d’analyse dans leurs systèmes côté serveur.
Chez Sparks.com, nous avons intégré un analyseur XML dans le servlet Java. Cet analyseur utilise un mécanisme appelé XSLT (XSL Transformation) pour ajouter des données XML au modèle XSL comme spécifié par la balise XSL.
Lorsque notre servlet Java gère une requête HTTP, la servlet récupère le XML généré dynamiquement, qui est ensuite transmis au moteur d'analyse. Sur la base des instructions contenues dans le fichier XML, le moteur d'analyse recherche la feuille de style XSL appropriée. L'analyseur crée un fichier HTML à partir de la structure DOM, puis ce fichier est envoyé à l'utilisateur qui fait la requête HTTP.
Si vous choisissez d'utiliser le modèle SAX, l'analyseur lit la source XML et crée un événement pour chaque balise XML. Les événements correspondent à des données XML, et les données sont finalement insérées dans la feuille de style selon les balises XSL.
