Présentation du service web TaxoMap
A.1 La plate-forme TaxoMap Web Service
La plate-forme TaxoMap Web Service implémente une architecture orientée plugins. Cette architecture permettra l'évolution de la plate-forme en y intégrant de nouveaux plugins. Comme le montre la gure A.1, la plate-forme est composée essentiellement de trois parties : le noyau, les plugins et les interfaces.
Annexe A. Présentation du service web TaxoMap
Le noyau constitue le coeur du service, il contrôle l'ensemble des traitements à exécuter. Les techniques d'alignement sont implémentées sous forme de plugins. Les interfaces assurent l'intégration des plugins dans le noyau et permettront aussi d'intégrer ce service dans d'autres systèmes. Les trois composantes de la plate-forme sont présentées en détail dans ce qui suit.
A.1.1 Le noyau
Le noyau est le coeur de la plate-forme. Il contient trois modules principaux, chaque module réalisant une tâche bien précise. Le module principal (cf. Service Kernel Fig. A.1) s'occupe de la tâche d'alignement, en exécutant les techniques implémentées dans les plugins. Le gestionnaire des plugins (cf. Plugin Manager Fig. A.1) s'occupe du chargement de ces derniers. L'interface du service Web (cf. Service Interface Fig. A.1) permet d'interagir avec le module principal.
Le module principal
1 p u b l i c Matching [ ] ontologyAlignment ( String OntoSource , String OntoCible , String lg , ←-ArrayList listTechnics , HashMap params ) {
2 Matching [ ] matchings = n u l l;
3
4 // Parsing s o u r c e ontology
5 LiteParser4OWL2 parse2owl1 = new LiteParser4OWL2 ( OntoSource , " s o u r c e ", 1 , lg ) ;
6 Ontology ontoSrc = parse2owl1 . parseOntology ( ) ;
7
8 // Parsing t a r g e t ontology
9 LiteParser4OWL2 parse2owl2 = new LiteParser4OWL2 ( OntoCible , " t a r g e t ", 2 , lg ) ;
10 Ontology ontoCbl = parse2owl2 . parseOntology ( ) ;
11
12 // Executing the lemmatization p r o c e s s
13 i f ( LiteParser4OWL2 . file !=n u l l) {
14 ArrayList <Ontology> v = new ArrayList <Ontology >() ;
15 v . add ( ontoSrc ) ;
16 v . add ( ontoCbl ) ;
17
18 File f1 = LemmatizationProcess . preProcess ( v ) ;
19 LemmatizationProcess . setLanguage ( lg ) ;
20 File f2 = LemmatizationProcess . launchTreeTagger ( f1 ) ;
21 LemmatizationProcess . saveLemmatization ( f2 , "$ $") ;
22
23 // Computing the s i m i l a r i t y matrix
24 double[ ] [ ] SimMatrice ;
25 Alignement al = new Alignement (" Align ", ontoSrc , ontoCbl , 3 , prop ) ;
26 al . computeNgramFreq ( ) ; 27 SimMatrice = al . computeSimilarityMat ( . . . ) ; 28 29 // Applying the a v a i l a b l e t e c h n i q u e s 30 f o r( PluginInterface plg : listTechnics ) 31 {
32 matchings = plg . Align ( ontoSrc , ontoCbl , lg , matchings , SimMatrice ,
←-params ) ;
33 }
34 }
35 r e t u r n matchings ;
36 }
A.1. La plate-forme TaxoMap Web Service La fonction principale de ce module est d'analyser les ontologies puis d'appliquer les tech-niques d'alignement sur ces ontologies. La gure A.2 donne une vue globale sur cette fonction. Elle est appelée ontologyAlignment et accepte comme paramètres l'URI de l'ontologie source, l'URI de l'ontologie cible, la langue, les techniques à appliquer ainsi que leurs paramètres (seuils). La fonction commence par faire l'analyse des deux ontologies en créant des objets de type Ontology. Ces objets sont utilisés dans le processus de lemmatisation et pour calculer la matrice de simi-larité.
Finalement, les techniques d'alignement sont appliquées en respectant l'ordre donné en en-trée et en utilisant les données précédemment calculées. Le résultat de l'application de chaque technique est une entrée de la technique suivante appliquée. Le résultat de la dernière technique est retourné comme résultat de l'alignement.
Le gestionnaire de plugins
Le gestionnaire des plugins s'occupe du chargement et de l'instanciation des plugins. L'ajout de nouveau plugins se fait par le chargement d'un chier zip contenant la description du plugin et de ses sources. Le gestionnaire des plugins fournit les noms des plugins disponibles aux autres modules, il fournit aussi les instances au module principal en vue d'une éventuelle exécution. Les noms des plugins disponibles peuvent être récupérés par l'utilisateur à travers l'interface du service (cf. Service Interface Fig. A.1).
1 p u b l i c c l a s s PluginClassLoader { 2 p r i v a t e void addFile ( File file ) {
3 // Using system ClassLoader to load c l a s s
4 Method addURL = URLClassLoader .c l a s s. getDeclaredMethod ("addURL", new
Class←-[ ] { URL .c l a s s}) ;
5 addURL . setAccessible (t r u e) ;
6 URLClassLoader cl = ( URLClassLoader ) ClassLoader . getSystemClassLoader ( ) ;
7 addURL . invoke ( cl , new Object [ ] { file . toURI ( ) . toURL ( ) }) ;
8 }
9
10 p u b l i c void loadPlugin ( File pluginDir ) { 11 t r y {
12 // Loading s o u r c e f i l e s
13 File classesDir = new File ( pluginDir , " c l a s s e s ") ;
14 i f ( classesDir . exists ( ) )
15 addFile ( classesDir ) ;
16 // Loading a a d i t i o n a l l i b r a r y ( j a r ) f i l e s
17 File libDir = new File ( pluginDir , " l i b ") ;
18 File [ ] jars = libDir . listFiles ( ) ;
19 i f ( jars != n u l l)
20 f o r ( File jar : jars )
21 addFile ( jar ) ; 22 } catch ( Exception ex ) { 23 ex . printStackTrace ( ) ; 24 } 25 } 26 }
FIG. A.3 La classe PluginClassLoader
Pour l'instanciation des plugins, le gestionnaire contient une classe appelée PluginClassLoa-der ( gure A.3) qui implémente le mécanisme d'introspection dé ni dans l'API Re ection de
Annexe A. Présentation du service web TaxoMap
Java. Ce mécanisme permet de charger de manière dynamique, au moment de l'exécution, les informations relatives à une classe Java. Il ore aussi la possibilité de créer dynamiquement des instances des classes chargées.
1 p u b l i c PluginInterface getInstance ( String name ) {
2 String className="";
3 // Find the f u l l c l a s s name
4 f o r( Plugin p : plugins ) {
5 i f( name . equals ( p . getName ( ) ) )
6 className = p . getMain_class ( ) ;
7 }
8 // Class not found
9 i f( className == "")
10 r e t u r n n u l l;
11 // Create and r e t u r n the i n s t a n c e
12 Class C = Class . forName ( className ) ;
13 PluginInterface plg = ( PluginInterface ) C . newInstance ( ) ;
14 r e t u r n plg ;
15 }
FIG. A.4 La méthode getInstance
La classe PluginClassLoader dé nit deux méthodes addFile et loadPlugin. La méthode add-File récupère une instance du chargeur de classes du système, puis lui demande d'ajouter le chier à charger en utilisant la méthode addURL. La méthode loadPlugin s'occupe du charge-ment de tous les chiers source et jar d'un plugin. Si un chier a déjà été chargé, le chargeur de classe ne le charge pas une deuxième fois mais réutilise l'instance existante.
Une fois la classe chargée par le système, le gestionnaire des plugins ore la possibilité d'en créer des instances en utilisant la méthode getInstance (voir gure A.4).
L'interface du service Web
1 p u b l i c c l a s s TaxoMapService {
2 p r i v a t e PluginManager manager = new PluginManager (" . . . ") ; 3 4 p u b l i c String [ ] getLanguages ( ) { 5 // L i s t supported languages 6 . . . 7 } 8 9 p u b l i c String [ ] getHeuristics ( ) { 10 // L i s t a v a i l a b l e p l u g i n s
11 String [ ] plugs = new String [ manager . getPlugins ( ) . size ( ) ] ;
12 f o r(i n t i=0; i< manager . getPlugins ( ) . size ( ) ; i++)
13 plugs [ i ] = manager . getPlugins ( ) . get ( i ) ;
14 r e t u r n plugs ;
15 }
16
17 p u b l i c Threshold [ ] getThresholds ( ) { 18 // L i s t p l u g i n s t h r e s h o l d s
19 Threshold [ ] thresholds = new Threshold [ thds . size ( ) ] ;
20 f o r(i n t i=0; i< manager . getThresholds ( ) . size ( ) ; i++)
A.1. La plate-forme TaxoMap Web Service
22 r e t u r n thresholds ;
23 }
24
25 p u b l i c Matching [ ] alignment ( String OntoSource , String OntoCible ,
26 String lg , String [ ] listTechnics ,
27 String [ ] thresholdsNames , Double [ ] thresholdsValues ) {
28 ArrayList<Param> params = manager . getThresholds ( ) ;
29 String name="", meth="";
30 // Loading t h r e s h o l d s v a l u e s
31 f o r(i n t i=0; i<thresholdsNames . length ; i++){
32 name = thresholdsNames [ i ] . substring ( . . . ) ;
33 meth = thresholdsNames [ i ] . substring ( . . . ) ;
34 f o r( Param p : params )
35 i f( p . getMethod ( ) . == meth && p . getName ( ) == name )
36 p . setDefault_val ( thresholdsValues [ i ] ) ;
37 }
38 ArrayList techniques = new ArrayList ( ) ;
39 HashMap realparams = new HashMap ( ) ;
40 HashMap tmpar ;
41 // Loading p l u g i n s i n s t a n c e s
42 PluginInterface technique = n u l l;
43 f o r ( String s : listTechnics ) {
44 i f ( manager . getPlugins ( ) . contains ( s ) ) {
45 technique = manager . getInstace ( s ) ;
46 techniques . add ( technique ) ;
47 tmpar = new HashMap<String , Param >() ;
48 f o r( Param p : params )
49 i f( p . getMethod ( ) . equals ( s ) )
50 tmpar . put ( p . getName ( ) , p ) ;
51 realparams . put ( technique , tmpar ) ;
52 }
53 }
54 // C a l l the alignment method o f the main module
55 AlignProcess process = new AlignProcess ( ) ;
56 r e t u r n process . ontologyAlignment ( OntoSource , OntoCible , lg , techniques , ←-realparams ) ;
57 }
58 }
FIG. A.5 L'interface du service Web
Le noyau dispose d'une interface utilisateur également implémentée sous forme d'interface de service Web. Cette interface interagit avec les autres composants du noyau en orant quatre mé-thodes : getLanguages, getHeuristics, getThresholds et alignment (voir gure A.5). La méthode getLanguages consulte le chier des paramètres et retourne la liste des langues supportées par le système. Les méthodes getHeuristics et getThresholds récupèrent les noms des plugins dispo-nibles ainsi que leurs paramètres (seuils) pour les retourner à l'utilisateur. Ces informations sont données par le gestionnaire des plugins. La méthode alignment applique le processus d'aligne-ment dé ni dans le module principal en lui fournissant les bons paramètres.
Annexe A. Présentation du service web TaxoMap
A.1.2 Les plugins
FIG. A.6 Structure d'un plugin
Les plugins implémentent les techniques d'alignement. Pour ajouter une nouvelle technique, il faut donc l'implémenter sous forme de plugin et l'intégrer dans la plate-forme. La gure A.6 représente le contenu d'un dossier de plugin. Le dossier doit contenir au moins deux chiers, un descripteur de plugin et une classe principale. Le descripteur de plugin est un chier appelé plugin.xml qui décrit le plugin ainsi que ses paramètres. Le descripteur contient un élément prin-cipal plugin ayant les paramètres suivants :
name, indiquant le nom de la technique,
class_folder, le dossier qui contient les sources (.class), jar_folder, le dossier qui contient les librairies (.jar),
plugin_class, contenant le nom de la classe principale implémentant le plugin et l'interface PluginInterface.
L'élément plugin peut contenir des éléments param décrivant les paramètres (seuils) d'une technique. Chaque paramètre est dé ni par un nom, un type et une valeur par défaut.
La classe principale du plugin est obligatoire, elle doit implémenter l'interface PluginInterface. Son nom est indiqué dans le paramètre plugin_class. Cette classe Java contient donc l'implémen-tation de la méthode align qui calcule l'alignement selon une technique donnée. Cette technique peut éventuellement utiliser des paramètres (seuils) dé nis dans le descripteur du plugin, et pas-sés en paramètre par le noyau du service. La gure A.7 donne un exemple d'implémentation de la classe principale pour la technique Equivalence.
1 p u b l i c c l a s s Equivalence implements PluginInterface {
2 p u b l i c ArrayList<Matching> Align ( OntologyInterface onto1 , OntologyInterface
←-onto2 , String lg , ArrayList<Matching> matchings , double[ ] [ ] matSim , HashMap
←-<String , Double> thresholds ) { 3
4 Matching match = n u l l;
A.1. La plate-forme TaxoMap Web Service
6
7 f o r (i n t i = 0 ; i < onto1 . getNumberofConcepts ( ) ; i++) { 8 f o r (i n t j = 0 ; j < onto2 . getNumberofConcepts ( ) ; j++) {
9 . . .
10 }
11 i f ( matSim [ i ] [ j ] >= thresholds . get (" Threshold ") ) {
12 onto1 . getListofConcepts ( ) . get ( i ) . setMatch (t r u e) ;
13 match = new Matching ( . . . ) ;
14 matchings . add ( match ) ;
15 }
16 }
17 r e t u r n matchings ;
18 }
19 }
FIG. A.7 Le plugin Equivalence
Le plugin peut aussi contenir d'autres classes ou réutiliser d'autres librairies (.jar). Pour indiquer ceci au gestionnaire de plugins, il faut mettre toutes les classes dans un même dossier et tous les Jar dans un même dossier. Le nom du dossier qui contient les classes est indiqué dans le paramètre class_folder du descripteur de plugin. Le paramètre jar_folder, comme son nom l'indique, pointe sur le dossier des librairies Jar. Le plugin doit obligatoirement contenir au moins la classe principale (dans le dossier des classes) et le Jar des interfaces appelé TaxoMapIn-terfaces.jar (dans le dossier des librairies).
Une fois un plugin chargé dans la plate-forme, le contenu de son descripteur est ajouté à un plus grand chier contenant les descripteurs des plugins disponibles. Ce chier, appelé plu-gins.xml, est utilisé par le gestionnaire de plugins pour extraire les informations relatives aux plugins disponibles (nom, paramètres, ...). En plus du descripteur, tout le dossier du plugin est copié dans un dossier appelé plugins accessible au noyau (pour une éventuelle instanciation du plugin).
A.1.3 Les interfaces
1 p u b l i c i n t e r f a c e PluginInterface {
2 p u b l i c ArrayList<Matching> Align ( OntologyInterface OntoSource ,
OntologyInterface OntoCible , String lg , ArrayList<Matching> matchings ,
←-double[ ] [ ] SimMatrice , HashMap<String , Double> thresholds ) ;
3 }
FIG. A.8 L'interface de plugins
Les interfaces (cf. TaxoMap Interfaces Fig. A.1) assurent l'interopérabilité entre le service Web et les plugins et entre le service Web et les clients. L'interface la plus importante est la PluginInterface, qui contient la signature d'une seule méthode align (voir gure A.8). Cette mé-thode a six paramètres : l'ontologie source, l'ontologie cible, la langue, la liste des alignements précédemment générés, la matrice de similarité et les seuils des plugins.
Chaque implémentation de plugin doit impérativement implémenter cette interface pour per-mettre au gestionnaire des plugins de le charger correctement. Cette interface fait référence à
Annexe A. Présentation du service web TaxoMap
d'autres interfaces comme, par exemple, OntologyInterface, qui est une interface de manipulation des ontologies (voir gure A.9).
1 p u b l i c i n t e r f a c e OntologyInterface {
2 p u b l i c i n t position ( ConceptInterface c ) ; 3
4 p u b l i c void addLabel ( LabelInterface l ) ; 5
6 p u b l i c void addLabels ( Collection<LabelInterface> l ) ; 7
8 p u b l i c ArrayList<LabelInterface> getlistOfLabels ( ) ; 9
10 p u b l i c void addConcept ( ConceptInterface c ) ; 11
12 p u b l i c void addConcepts ( Collection<ConceptInterface> c ) ; 13 14 p u b l i c ArrayList<ConceptInterface> getListofConcepts ( ) ; 15 16 p u b l i c void computeNgramFreq ( . . . ) ; 17 18 p u b l i c void clear ( ) ; 19 20 p u b l i c String getURI ( ) ; 21 22 p u b l i c i n t getNumberofConcepts ( ) ; 23 }
FIG. A.9 L'interface des ontologies
Les interfaces comportent également une classe importante pour l'utilisation du résultat de l'alignement par un client. Cette classe, appelée Matching ( gure A.10), encode les mappings entre deux concepts. Un objet de type Matching contient les noms des concepts source et cible, les labels associés à ces concepts, le type de la relation établi entre ces concepts ainsi que le nom de la technique qui a généré le mapping.
1 p u b l i c c l a s s Matching {
2 String sourceConcept , targetConcept , relation , heuristc ;
3 ArrayList<String> sourcelabels , targetlabels ;
4 double confidence ; 5
6 p u b l i c ArrayList<String> getSourceLabels ( ) {r e t u r n sourcelabels ; } 7
8 p u b l i c ArrayList<String> getTargetLabels ( ) {r e t u r n targetlabels ; } 9
10 p u b l i c void addSourceLabel ( String l ) { sourcelabels . add ( l ) ; } 11
12 p u b l i c void addTargetLabel ( String l ) { targetlabels . add ( l ) ; } 13
14 p u b l i c void addSourceLabels ( Collection<String> labels ) {
15 i f( labels != n u l l) t h i s. sourcelabels . addAll ( labels ) ;
16 }
17
18 p u b l i c void addTargetLabels ( Collection<String> labels ) {
19 i f( labels != n u l l) t h i s. targetlabels . addAll ( labels ) ;
20 }
21
A.2. Exemple d'utilisation
23
24 p u b l i c void setRelation ( String r ) { relation = r ; } 25
26 p u b l i c String getTargetConcept ( ) {r e t u r n targetConcept ; } 27
28 p u b l i c void setTargetConcept ( String tC ) { targetConcept = tC ; } 29
30 p u b l i c String getSourceConcept ( ) {r e t u r n sourceConcept ; } 31
32 p u b l i c void setSourceConcept ( String sC ) { sourceConcept = sC ; } 33
34 p u b l i c double getConfidence ( ) {r e t u r n confidence ; } 35
36 p u b l i c void setConfidence (double c ) { confidence = c ; } 37
38 p u b l i c String getHeuristc ( ) {r e t u r n heuristc ; } 39
40 p u b l i c void setHeuristc ( String h ) { heuristc = h ; } 41
42 p u b l i c Matching ( String sourceConcept , String targetConcept , String relation ,
←-String heuristc , double confidence ) {
43 . . .
44 }
45 }
FIG. A.10 La classe Matching
A.2 Exemple d'utilisation
Annexe A. Présentation du service web TaxoMap
Un client Web a été développé pour illustrer l'utilisation du service web TaxoMap. L'interface du client est présentée dans la gure A.11. Les URIs des ontologies source et cible sont saisies respectivement dans (1) et (2). La liste des langues supportées est chargée à partir du service et est a chée dans (3). Dans (4) la liste des techniques (plugins) disponibles dans le système est a chée, permettant à l'utilisateur de choisir une ou plusieurs techniques à appliquer. Cette liste est aussi chargée à partir du service. Les techniques que l'on veut appliquer sont ajoutées à (5) a n d'être exécutées dans l'ordre indiqué. Pour choisir une technique, ou changer l'ordre d'exécution des techniques, les boutons (6) sont utilisés. En n, Le bouton (7) sert à lancer le processus d'alignement du service Web.
FIG. A.12 Le résultat d'un alignement
Le résultat retourné par le service est présenté dans la gure A.12. Le nombre total de map-pings trouvés est présenté dans (1). Le nombre de mapmap-pings trouvés par chaque technique est a ché dans (2). Le bouton (3) permet de générer un chier .rdfs contenant le résultat de l'ali-gnement. La liste de tous les mappings trouvés est détaillée dans (4).
Conclusion
Le web service TaxoMap Web Service est une implémentation de l'outil TaxoMap facilitant son évolution. De nouvelles techniques peuvent être ajoutées très facilement. Cette implémen-tation rend, par ailleurs, plus facile l'utilisation de TaxoMap et son intégration dans n'importe
A.2. Exemple d'utilisation quel autre système tout en préservant son code source.
Un autre aspect intéressant de l'implémentation réalisée vient du fait qu'il y a une claire séparation entre les aspects interfaces et les aspects traitements d'alignement. Ainsi, si d'autres calculs doivent compléter les traitements d'alignement actuels, ces calculs devront être dé nis dans la méthode align et l'interface n'aura pas à être modi ée.
Le service Web est disponible à l'adresse suivante :
http://taxomap.lri.fr:8090/axis2/services/TaxoMapService?wsdl Le client est déployé à l'adresse : http://taxomap.lri.fr/