Documentation SDX-2 Télécharger Installer Présentation Architecture Serveur Applications Bases de documents Entrepôt Multilinguisme Analyseurs Débuter Configuration Indexation Recherche OAI Javadoc Référence API-XSP Migration Schemas Performances | # SDX et le multilinguisme SDX est un outil de recherche et de consultation de documents XML qui accorde une grande importance à la langue. C'est pourquoi il est présenté comme un outil multilingue. Ce concept est large et nous allons décrire ici d'une part ce qu'il signifie pour SDX et d'autre part quels sont les services multilingues offerts par SDX. Avant d'y arriver, il est important de rappeler un fait important à ce sujet : SDX est une plate-forme qui permet de réaliser des applications de recherche multilingues ; cela ne signifie pas que SDX prévoit déjà tous les outils nécessaires pour traiter correctement toutes les langues souhaitées par un développeur. ## Qu'est-ce qu'une langue pour SDX ? Toute discussion sur le multilinguisme doit d'abord bien préciser ce qu'est une langue dans SDX-2. D'autant plus que SDX est construit autour de deux technologies qui ont leur propre conception de la langue (Java et XML) ; heureusement ces deux conceptions ne sont pas opposées. Pour Java, une langue est en fait une "locale" (voir la classe java.util.Locale pour une définition complète) ; c'est-à-dire une combinaison d'un code de langue (ISO-639), d'un code de pays (ISO-3166) et d'une "variante", optionnelle, qui permet de préciser certaines options concernant la langue. Pour XML, la section 2.12 de la norme indique ce qu'est une langue et comment elle peut être représentée. Ainsi, XML prévoit un attribut spécial (`xml:lang`) pour identifier une langue. Cet attribut doit avoir une valeur définie dans le RFC-1766 de l'IETF. Essentiellement, cette norme prévoit qu'une langue est spécifiée par la combinaison d'un code de langue, suivi d'un code de pays selon les mêmes normes que pour Java, bien que cette combinaison puisse être remplacée par un code de langue enregistré auprès de l'IANA. A partir de ces deux définitions, il a été décidé que pour SDX-2, une langue est une combinaison d'un code de langue ISO-639, d'un code de pays ISO-3166 (optionnel) et d'une variante (optionelle). Toutefois, pour représenter ces langues dans un contexte XML, l'attribut `xml:lang` est utilisé pour les deux premières parties, un attribut `variant` est utilisé pour la troisième. C'est pourquoi on peut avoir, par exemple :
      <sdx:field xml:lang="fr-CA" variant="qc".../>
A noter toutefois que pour la langue d'interface (dont il est question dans la section suivante) la notion de variante n'est jamais exploitée ; on peut seulement retrouver un code de langue et un code de pays, tous deux identifiés à l'aide d'un attribut `xml:lang` par exemple. ## La langue d'interface Les applications Web construites avec SDX utilisent en général le langage XSP pour constuire les pages Web dynamiques. Ces pages XSP présentent généralement un élément `sdx:page` qui permet d'utiliser par la suite l'un ou l'autre des services SDX. L'utilisation de cet élément (peu importe ce qu'on y retrouve) a un impact important : le document XML (virtuel) résultant de la page XSP aura à sa racine un élément `sdx:document` possédant un attribut `xml:lang`. Ce dernier identifie la langue souhaitée pour l'interface. Exemple 1. L'attribut `xml:lang`
    <sdx:document xml:lang="fr-CA">
      ...
      <sdx:results ...>
        ...
      </sdx:results>
    </sdx:document>
Cet attribut est toujours présent ; il est destiné à servir de base pour créer des interfaces multilingues. Ainsi, dans une transformation XSLT appliquée à ce document virtuel afin d'obtenir une page HTML, il est possible d'utiliser cette information pour sortir du contenu différent en fonction de la langue :
    ...
    <xsl:variable name="l" select="string(/sdx:document/@xml:lang)"/>
    ...
    <xsl:choose>
      <xsl:when test="starts-with($l, 'fr')">Bonjour</xsl:when>
      <xsl:when test="starts-with($l, 'en')">Hello</xsl:when>
      ...
    </xsl:choose>
    ...
Cet aspect est intéressant (sans être une révolution), mais il pose une question fondamentale : comment SDX détermine la langue spécifiée dans cet attribut ? En fait, SDX va chercher cette information à différents endroits, dans un ordre bien précis. La première langue qu'il trouve est celle qu'il va mettre dans l'attribut. Nous allons donc documenter ces différents endroits où la langue est définie et dans quel ordre ils sont examinés : ### Où trouver la langue ? #### La langue de l'application Dans le fichier de configuration (`application.xconf`), l'élément supérieur `sdx:application` doit avoir un attribut `xml:lang`. La valeur de cet attribut peut être utilisée par SDX pour identifier la langue de consultation. On peut considérer cette valeur comme la langue par défaut de l'application ; pour une application unilingue cet attribut est en général suffisant pour indiquer la langue. #### La langue de l'utilisateur Les applications Web construites avec SDX offrent des services à des utilisateurs qui demandent les différentes pages du Web. Même lorsqu'il n'y a pas d'identification formelle des personnes qui consultent, pour SDX il y a un utilisateur spécial, l'utilisateur anonyme. Aucune langue n'est associée à cet utilisateur, mais il s'agit d'une exception. Tous les autres utilisateurs auront une langue associée et cette langue peut être utilisée pour déterminer la langue d'interface. Dans l'interface de création des utilisateurs de SDX, il est possible d'associer une langue à l'utilisateur. Les applications qui ont leur propre interface de gestion des utilisateurs peuvent, de leur côté, associer une langue avec la méthode de leur choix, SDX pourra tout de même utiliser cette langue pour indiquer la langue d'interface. #### La langue de la page XSP Dans une page XSP, il est possible d'indiquer directement une langue et de faire en sorte que SDX utilise cette langue comme indication de langue d'interface. Cette spécification de la langue doit se faire par un attribut `xml:lang` de l'élément `sdx:page` ou de son élément parent `xsp:page`. Par exemple :
    <xsp:page>
      <sdx:page xml:lang="es">
      ...
      </sdx:page>
    </xsp:page>
#### Le paramètre dynamique de langue L'API-SDX utilise un concept générique de paramètres et offre de nombreuses façons de spécifier ces paramètres dans une page XSP. Pour en connaître les détails, il est préférable de consulter la documentation sur cette notion de paramètres. Nous allons ici illustrer leur utilisation pour la langue. Les paramètres SDX ont nécessairement un nom ; pour la langue, le nom du paramètre concerné est lang. Ensuite, SDX prévoit cinq façons de spécifier la valeur d'un paramètre. Ces façons sont dans l'ordre de priorité : une variable Java de type `String`, non nulle, définie dans la XSP ; un paramètre défini dans la Sitemap ; une valeur provenant d'un paramètre de la requête HTTP (donc de l'URL) ; une valeur explicite dans la page XSP ; une valeur par défaut dans SDX. Nous pouvons tout de suite signaler que, pour la langue, il n'y a pas de valeur par défaut dans SDX. Cet aspect importe peu, car la langue de l'application (définie dans le `application.xconf`) joue le rôle de valeur par défaut. Nous devons également mentionner que l'utilisation d'une valeur explicite d'un paramètre n'apporte rien par rapport à l'utilisation de l'attribut `xml:lang` dans la page XSP, tel que mentionné plus haut. Ce paramètre code doit nécessairement être associé à l'élément `sdx:page`. L'exemple suivant illustre les différentes façons de le faire :
    <!--
    Valeur explicite
    -->
    <sdx:page lang="fr">

    <!--
    Valeur provenant de l'objet de
    session dont la clé est "langue"
    -->
    <sdx:page langSession="langue">

    <!--
    Valeur provenant d'un paramètre
    HTTP "l" (par exemple l'URL test.xsp?l=fr)
    -->
    <sdx:page langParam="l">

    <!--
    Valeur provenant d'une variable
    Java de type String préalablement définie
    -->
    <xsp:logic>
      String l = "fr";
    </xsp:logic>
    <sdx:page langString="l">
Ces exemples utilisent tous la méthode des attributs pour identifier un paramètre. Mais SDX offre une seconde méthode : celle des sous-éléments `sdx:parameter` permettant de spécifier des paramètres. Ainsi, il est possible de remplacer le troisième exemple ci-dessus par ce code :
    <sdx:page>
      <sdx:parameter name="lang" valueParam="l"/>
Cette méthode des paramètres est très souple. Elle est d'ailleurs nécessaire pour créer de véritables applications Web dynamiques et multilingues. Par exemple, il est possible d'ajouter à toutes les URL de l'interface le paramètre l, de lui donner une valeur de langue et dans la page XSP utiliser l'attribut `langParam="l"` pour ainsi toujours avoir une valeur appropriée comme langue d'interface. Toutefois, cette approche comporte un inconvénient : le développeur doit toujours faire attention à inclure le paramètre l dans les liens hypertextes, ce qui est sujet à erreur. Une solution est de stocker cette valeur dans un objet de session. Ainsi, une fois que l'objet de session est défini, SDX peut l'exploiter. Pour y arriver, il s'agit tout simplement d'utiliser ceci dans les pages XSP :
    <sdx:page langSession="l" langParam="l">
Mettre ces deux indications n'est pas contradictoire. Au contraire, puisque SDX définit une priorité : le paramètre d'URL (attribut `langParam`) est prioritaire sur l'objet de session, mais cette priorité n'est exploitée que s'il y a effectivement ce paramètre dans l'URL. De plus, s'il est présent, alors, non seulement SDX l'utilise, mais en plus il va conserver sa valeur en objet de session, à cause de la présence de l'attribut `langSession` avec la même valeur que celle de l'attribut `langParam`. Cette caractéristique des paramètres SDX est problablement celle qui permet la plus grande souplesse et aussi la plus grande simplicité pour la gestion de la langue. Nous allons l'illustrer avec un exemple. Exemple 2. Définition de la langue dans les paramètres Supposons que le code ci-dessus soit dans une page XSP nommée `index.xsp`. On va faire plusieurs appels successifs à cette page avec différentes valeurs de paramètres et voir comment est définie la langue d'interface : `index.xsp` : la langue est celle définie dans l'objet de session dont la clé est code. Si celui-ci n'existe pas, alors SDX cherche la langue ailleurs ; `index.xsp?l=en` : la langue sera en ; `index.xsp` : la langue ne change pas, c'est toujours en ; `index.xsp?l=fr` : la langue change pour fr. Bref, cette approche permet au développeur de spécifier un paramètre d'URL seulement lorsqu'il désire changer la langue d'interface. Notons également qu'il est possible d'ajouter un attribut `langString` qui se comporte de la même manière que `langParam`, mais avec une valeur définie par une variable Java de type `String` et avec une priorité encore plus grande. Cela permet de spécifier la langue selon une logique plus fine que celle permise par de simples valeurs de paramètres URL, si nécessaire. ### Règle de priorité Nous avons vu que SDX peut aller chercher l'information sur la langue dans les paramètres dynamiques, dans la page XSP explicitement, dans les informations sur l'utilisateur en cours et dans la configuration de l'application. Tous ces endroits peuvent avoir des informations de langue, alors il est nécessaire de définir une priorité. La logique veut que les informations dynamiques soient prioritaires par rapport aux informations de configuration ou mentionnées explicitement ; par ailleurs nous appliquons une seconde logique qui veut que les informations qui se trouvent dans la page XSP sont prioritaires par rapport aux informations qui se trouvent à l'extérieur de cette page. Par conséquent, l'ordre de priorité est le suivant : Les paramètres dynamiques ; La langue de la page XSP ; La langue de l'utilisateur ; La langue de l'application (`application.xconf`). ## La langue et la recherche L'autre aspect important du multilinguisme pour SDX est sa relation avec la recherche. En effet, toute application qui manipule le texte est influencée par la langue de ces textes. En recherche documentaire, cette influence se fait sentir de trois façons : Lors de l'indexation et dans les requêtes de recherche, il est nécessaire de séparer le texte en mots et cette séparation dépend nécessairement de la langue du texte en question ; Lors de l'indexation et dans les requêtes de recherche, il peut être nécessaire de transformer le texte pour, par exemple, le mettre en minuscules, supprimer les diacritiques, etc. Encore une fois, la langue du texte influence cette transformation ; Lors du tri des résultats de recherche selon des informations textuelles contenues dans les valeurs des différents champs. Le tri sur du contenu textuel est également une opération qui dépend de la langue du texte. SDX permet au développeur d'applications de contrôler les opérations dépendantes de la langue de façon très fine ; ce contrôle se fait en grande partie au niveau des champs d'une base de documents. Lors de la définition de ces champs, on peut leur attribuer une langue et, optionnellement, un analyseur de mots spécifique. Il est important de noter que la discussion ci-dessous est spécifique à l'utilisation de moteur de recherche Lucene par SDX. Eventuellement, si SDX permet d'utiliser d'autres moteurs de recherche, ces informations pourraient ne pas s'appliquer. ### L'analyseur de mots Lorsque SDX indexe du contenu textuel dans un champ de type word, ce contenu textuel sera d'abord transformé par un analyseur de mots. En effet, chaque mot individuel est stocké dans l'index. De plus, ces mots peuvent être transformés, par exemple pour mettre tout le texte en minuscules et supprimer les diacritiques. Exemple 3. Analyse de mots en indexation et en requête Lors de l'indexation du contenu textuel « Première personne de la soirée », un analyseur pourrait fournir trois mots à indexer : premiere, personne et soiree. Cet analyseur serait ainsi responsable de la suppression de mots vides éventuels. Pour ce que système fonctionne, il est nécessaire d'appliquer la même transformation (et donc d'utiliser le même analyseur de mots) sur la requête de recherche. Ainsi, si un utilisateur cherche Soirée, l'analyseur de mots va retourner le mot soiree, ce qui permettra de trouver le document ayant le contenu donné en exemple. Il serait difficile de concevoir un analyseur de mots qui fonctionne bien pour toutes les langues, car nous l'avons vu, l'identification des mots et leur transformation dépend en général de la langue du texte. C'est pourquoi SDX permet au développeur d'applications d'utiliser des analyseurs de mots différents pour tous les champs des bases de documents. Ces analyseurs peuvent être soit inclus dans SDX, soit fournis par le développeur lui-même ; un analyseur de mots est tout simplement une classe Java qui étend (directement ou indirectement) la classe `fr.gouv.culture.sdx.search.lucene.analysis.Analyzer`. Les analyseurs de mots inclus dans SDX 2 sont les suivants : `fr.gouv.culture.sdx.search.lucene.analysis.Analyzer_cn` : chinois ; `fr.gouv.culture.sdx.search.lucene.analysis.Analyzer_de` : allemand ; `fr.gouv.culture.sdx.search.lucene.analysis.Analyzer_en` : anglais ; `fr.gouv.culture.sdx.search.lucene.analysis.Analyzer_fr` : français ; `fr.gouv.culture.sdx.search.lucene.analysis.Analyzer_ru` : russe. `fr.gouv.culture.sdx.search.lucene.analysis.Analyzer_ar` : arabe (version 2.2 ou supérieure). D'autres analyseurs seront éventuellement ajoutés dans SDX ; toute contribution est acceptée avec plaisir. Pour rendre encore plus souple l'utilisation des analyseurs ou pour faire en sorte que les mêmes analyseurs puissent être utilisés de façon légèrement différente, SDX prévoit un mécanisme de configuration des analyseurs. Cette configuration se fait à l'aide d'un document XML qui contient différentes informations qui peuvent être spécifiques à un analyseur ou valables pour tous les analyseurs, sauf exception. Un fichier de configuration pour chaque langue est inclus avec SDX dans un fichier situé dans `sdx/resources/conf/analysis` à partir du dossier d'installation de SDX (par exemple `.../webapps/sdx`). Voici un extrait du fichier de configuration pour le français :
    <?xml version="1.0" encoding="ISO-8859-1"?>
    <french useStopWords="true" keepAccents="false">
       <stopWords>
         <stopWord>le</stopWord>
         <stopWord>la</stopWord>
         <stopWord>les</stopWord>
         ...
      </stopWords>
    </french>
Les sous-éléments `stopWord` contiennent des mots vides. Par ailleurs, l'attribut `keepAccents` indique si l'analyseur doit supprimer les diacritiques ou pas. Il s'agit donc d'une fonction optionnelle de l'analyseur de mots pour la langue française. Pour chaque champ, il doit y avoir un analyseur de mots. Cet analyseur peut être spécifié directement, indirectement, être l'analyseur par défaut de la base de documents ou l'analyseur par défaut de SDX. Nous allons voir comment ces différentes indications peuvent être utilisées. #### Spécifier un analyseur de mots directement Deux attributs peuvent être utilisés pour spécifier directement quel analyseur de mots utiliser : `analyzerClass` et `analyzerConf`. Ces attributs peuvent être associés à l'élément `sdx:field`, et dans ce cas ils identifient l'analyseur de mots du champ en question, ou encore ils peuvent être associés à l'élément `sdx:fieldList`, et dans ce cas ils identifient l'analyseur de mots par défaut pour la base de documents. L'attribut `analyzerClass` indique tout simplement la classe à utiliser comme analyseur ; tel qu'indiqué ci-dessus, cette classe doit étendre la classe `fr.gouv.culture.sdx.search.lucene.analysis.Analyzer` et bien entendu elle doit être disponible dans le CLASSPATH Java. L'attribut `analyzerConf` donne la localisation du fichier de configuration pour l'analyseur de mots. La valeur de l'attribut est une URL, absolue ou relative au fichier `application.xconf`. Si cet attribut est omis, la configuration par défaut de l'analyseur est utilisée. Il est à noter que cet attribut peut également spécifier un fichier de configuration dans le cas où l'analyseur de mots est spécifié de manière indirecte. #### Spécifier un analyseur de mots indirectement Il est aussi possible de spécifier un analyseur de mots indirectement, c'est-à-dire en précisant la langue du contenu du champ ou de l'ensemble des champs de la base de documents. Ainsi, si on utilise les attributs `xml:lang` et `variant` avec les éléments `sdx:field` (pour un champ en particulier) ou `sdx:fieldList` (comme valeur par défaut pour tous les champs de la base de documents), SDX tentera de trouver un analyseur de mots adéquat pour cette langue. Exemple 4. Localisation de l'analyseur de mots La méthode utilisée par SDX pour trouver cet analyseur peut s'exprimer plus facilement si on prend un exemple. Supposons la définition suivante :
    <sdx:field ... xml:lang="fr-CA" variant="qc"/>
L'algorithme sera le suivant : S'il existe une classe `fr.gouv.culture.sdx.search.lucene.analysis.Analyzer_fr_CA_qc` et que cette classe est disponible, elle est utilisée, sinon on passe à l'étape suivante ; S'il existe une classe `fr.gouv.culture.sdx.search.lucene.analysis.Analyzer_fr_CA` et que cette classe est disponible, elle est utilisée, sinon on passe à l'étape suivante ; S'il existe une classe `fr.gouv.culture.sdx.search.lucene.analysis.Analyzer_fr` et que cette classe est disponible, elle est utilisée, sinon on passe à l'étape suivante ; La classe par défaut `fr.gouv.culture.sdx.search.lucene.analysis.Analyzer` est utilisée. A noter que si un attribut `xml:lang` est utilisé conjointement avec un attribut `analyzerClass`, c'est ce dernier qui est utilisé pour trouver un analyseur de mots. La méthode directe a donc priorité sur la méthode indirecte. #### Analyseur par défaut de SDX Lorsqu'aucun analyseur n'est spécifié pour un champ ou une base de documents, SDX utilise l'analyseur `fr.gouv.culture.sdx.search.lucene.analysis.DefaultAnalyzer`. Il s'agit d'un analyseur de mots pour la langue anglaise. Il est également utilisé si un champ déclare indirectement un analyseur qui n'est pas disponible avec SDX. ### Le tri Les résultats de recherche fournis par SDX peuvent être triés selon n'importe quel champ défini dans la base. Par ailleurs, les listes de termes des champs sont toujours retournés en ordre alphabétique. Ces deux opérations de tri sont effectuées par SDX en essayant de tenir compte de la langue des champs triés. Ainsi, si un élément `sdx:field` a un attribut `xml:lang` et, de façon optionelle, un attribut `variant`, ces informations sont utilisées pour construire un comparateur (concept Java) permettant de trier correctement selon la langue en question. Pour en savoir plus sur ces comparateurs et leur utilisation pour le tri et le texte, voir la classe java.text.Collator de Java. Les machines virtuelles Java sont habituellement livrées avec un certain nombre de collator pour différentes langues. Consulter la documentation de machine virtuelle en question pour connaître la liste des langues supportées.
| Auteur : Martin Sévigny ( AJLSM ) - 2003-06-04

| Home |
Copyright © 2000, 2001, 2002, 2003, 2004 Ministère de la culture et de la communication, AJLSM.