Accueil / Articles PiApplications. / La plate-forme Java / Exemples de codes source Java

Vérification grammaticale d'un fichier XML.

Un fichier XML doit, par définition, répondre à des règles de bonne formation comme celle qui interdit aux contenus des balises de se chevaucher. Toutefois, il est également possible d'imposer une "grammaire" à respecter aux flux XML.

Cette grammaire définit les balises, les attributs et leur type, les contraintes propres aux balises et aux attributs ainsi que l'organisation générale du flux (positionnement des balises entres-elles). Cela est un outil puissant qui permet de s'assurer avec un minimum de code que le flux XML à traiter est compatible de l'utilisation que l'on souhaite en faire. Nous supposons ici le lecteur familier des notions de "bonne-formation" et de contrôle "grammatical" via un descripteur XSD des flux XML.

Cette définition de la grammaire se fait via un descripteur XML qui répond lui-même à un schéma disponible à l'URL http://www.w3.org/2001/XMLSchema. Lorsque le flux est stocké dans un fichier, ce dernier a généralement l'extension [.xsd]. De nombreux outils permettent de créer de façon quasi-graphique ces descripteurs grammaticaux. Hélas, les outils du monde libre sont moins efficaces que ceux que l'ont peu rencontrer dans le domaine commercial (en fait peu d'outils "libres" disposent d'un éditeur grammatical [voir comparatif wikipedia]). Pour notre part, nous utilisons les excellents outils produits par Oxygen.

Nous partons du principe que vous disposez d'un flux XML à contrôler (dans un fichier) et d'un fichier de contrôle grammatical associé. Pour corser un peu l'affaire et parce que cela correspond à un usage répandu, nous supposerons notre fichier grammatical intégré en tant que ressource d'une librairie Java (fichier d'extension [.jar]). Le chargement d'un fichier ressource est l'objet d'un autre extrait de code.

Dans notre prototype de test, nous commençons par déclarer nos deux fichiers (descripteur grammatical XSD et fichier XML à contrôler en tant qu'attributs :

  /**
   * Identification de la ressource fichier qui fixe la grammaire des fichiers XML à contrôler.
   */
  public static String XSD = "/proto008/resources/scheme.xsd";
  
  /**
   * Nom du fichier XML à contrôler.
   */
  private final String _sXmlFile = "/home/jm/nb/proto008/src/proto008/resources/scheme.xml";

Voici ensuite le code de contrôle du fichier XML :

/**
 * Point d'entrée logique dans le programme (mode non statique).
 * @param args Arguments de la ligne de commande.
 * @throws java.io.IOException Echec d'E/S (probablement sur fichier ici).
 * @throws org.xml.sax.SAXException Document XML mal-formé ou qui ne respecte pas la grammaire imposée.
 * @throws javax.xml.parsers.ParserConfigurationException Mauvaise configuration du parseur XML.
 */
public void execute(String[] args)
    throws IOException,
           SAXException,
           ParserConfigurationException
{
  // lecture des règles grammaticales servant de base au contrôle
  String sXsdSchema = Proto008.readStringFromFileFromResources(XSD, Charset.forName("UTF-8"));
  XmlErrorsHandler xeh = new XmlErrorsHandler();
  Document dom = XmlReader.read(new File(_sXmlFile), sXsdSchema, xeh);
  if (xeh.hasError())
  {
    System.err.println(String.format("Le fichier XML est invalide : %s", xeh.toString()));
    System.exit(1);
    return;
  }
  System.out.println(String.format("Fichier XML bien-formé et valide (%d \"billets\")",
      dom.getElementsByTagName("billet").getLength()));
}

La méthode de lecture du fichier [.xsd] readStringFromFileFromResources est exposée dans un autre extrait de code. Cette lecture faite, on déclare un gestionnaire d'erreurs du parseur XML de type SAX (parseur séquentiel). Un tel parseur doit implémenter l'interface org.xml.sax.ErrorHandler. La librairie Jmp référencée par notre prototype contient un tel gestionnaire avec la classe XmlErrorsHandler.

La méthode statique XmlReader.read reçoit le fichier XML à contrôler, la grammaire à respecter et notre gestionnaire d'erreur d'analyse. Cette méthode lance l'analyse séquentielle des éléments XML du fichier à contrôler.

Si une erreur est détectée, le programme en donne le détail. Sinon, il affiche le nombre d'éléments "billets" que contient le flux XML contrôlé.

(c) PiApplications 2016