Rappel sur Java |
 |
Vous savez déjà que, pour travailler avec Lucene, vous avez besoin de Java. Vous verrez que Lucene a d’abord été programmé en Java. Bien qu’il soit maintenant disponible dans d’autres langages, la version que vous utiliserez dans ce cours est celle disponible en Java.
À la semaine 5 de ce cours, vous avez eu l’occasion d’installer Java sur votre ordinateur et d’en vérifier le bon fonctionnement. Au besoin, vous êtes invité à retourner lire l’article qui se rapporte à Java cette semaine-là et, si nécessaire, à relire les éléments de base sur la programmation en Java.
Nous supposons que vous êtes déjà familier avec ce langage et nous nous contenterons, ici, de vous rappeler certaines notions plus pertinentes pour l’utilisation de Lucene, à savoir l’utilisation des classes et de l’approche objet avec Java.
En effet, vous allez voir que Lucene vous propose des classes qui, utilisées par un programme en Java, vont permettre des recherches avancées en un minimum d’opérations.
Vous avez vu brièvement à la semaine 5 ce que sont un objet et une classe. Comme ces notions sont fondamentales dans l’utilisation de Lucene, nous allons les approfondir un peu plus ici.
L’idée de base d’un objet est qu’il permet d’utiliser (et de réutiliser) des éléments programmés qui sont autosuffisants et complets par eux-mêmes. Ces éléments, ce sont des objets.
Un objet en Java sera identifié par deux caractéristiques : ses données et ses méthodes. Nous verrons que les méthodes n’agissent que sur les données de l’objet en question.
On pourrait, par exemple, imaginer un objet (un rectangle) caractérisé par des données : sa longueur, sa largeur et ses coordonnées sur un plan cartésien. Ainsi, on pourrait avoir un rectangle d’une longueur de 3 et d’une largeur de 1, dont le coin inférieur gauche se trouverait au point (2,3) d’un plan cartésien.
Cet objet pourrait, toujours pour les fins de notre exemple, subir trois actions :
– être initialisé ;
– être déplacé sur le plan cartésien ;
– faire imprimer ses données.
Nous dirons alors que notre objet-rectangle comporte trois méthodes d’objet : initialise (ce qui donne les valeurs de départ aux différentes coordonnées du rectangle), déplace (ce qui modifie les coordonnées de départ) et imprime (ce qui permet d’afficher les coordonnées à l’écran).
Parce que ces méthodes ne s’appliquent qu’aux données de notre objet, elles répondent aux caractéristiques que nous attendions d’elles.
Le fait que les données de notre rectangle ne puissent être modifiées que par ces trois méthodes rejoint le concept d’encapsulation. Notre objet-rectangle est désormais complet en lui-même, indépendant. D’autres programmes Java pourront faire appel à lui, mais uniquement en utilisant l’une des trois méthodes. Le rectangle se déplacera, ses coordonnées changeront, mais uniquement parce qu’on aura fait appel à la méthode déplace pour, c’est le cas de le dire, le déplacer.
Dans un programme Java, nous ne trouvons pas de références à des objets comme tels ayant des caractéristiques semblables. Pour revenir à notre exemple, nous pouvons imaginer une classe rectangle qui représente l’ensemble de tous les rectangles possibles, avec chacun leur longueur, leur largeur, leurs coordonnées et une méthode servant à les déplacer.
La classe rectangle ressemblerait à ceci :
public class rectangle {
public void initialise (int x, int y, double longueur, double largeur)
{ x1 = x ;
y1 = y ;
longueur1 = longueur ;
largeur1 = largeur ; }
public void deplace (int diffx, int diffy)
{ x1 += diffx ;
y1 += diffy ;
}
public void imprime ()
{ System.out.println ("Coordonnées du rectangle: (" + x1 + "," + y1 + ")");
System.out.println ("Longueur du rectangle : " + longueur1);
System.out.println ("Largeur du rectangle : " + largeur1);
}
private int x1 ;
private int y1 ;
private double longueur1 ;
private double largeur1 ;
}Un programme Java pourrait alors se référer à la classe rectangle avec un code de ce genre :
// Exemple de programme utilisant la classe {rectangle}public class exemple {
public static void main(String args[]) {
rectangle r;
r = new rectangle();
r.initialise(2,3,10,5);
r.imprime();
r.deplace(100,100);
r.imprime();
}
}Vous noterez que le programme Java utilise la classe rectangle sans nécessairement savoir comment elle fonctionne. Il doit simplement savoir quelles valeurs attribuer aux différentes méthodes pour les utiliser.
Comme les classes risquent de se multiplier et de devenir difficiles à retrouver, on les regroupera dans des ensembles appelés paquetages (packages, en anglais). On regroupera donc, dans un même fichier source, un ensemble de classes qui seront identifiées par un nom de paquetage. Ce nom sera assigné, au début du fichier, par l’instruction packages, suivie du nom du paquetage. Cette opération facilitera, d’une part, la recherche des classes et minimisera, d’autre part, les problèmes de classes ayant le même nom. En effet, il faudra simplement éviter d’avoir deux classes de même nom à l’intérieur d’un même paquetage.
On pourrait imaginer un paquetage, contenant un ensemble de classes se rapportant à des formes géométriques (rectangle, carré, etc.), qui serait identifié par :
package geometrie ;
On pourra, par la suite, importer dans un programme Java la classe désirée en utilisant l’instruction :
import geometrie.rectangle ;
ou encore, pour utiliser l’ensemble des classes du paquetage geometrie :
import geometrie.* ;
Voilà, c’est ainsi que vous utiliserez Lucene. Vous aurez accès à toute une série de classes déjà codées, intégrées dans un ensemble de paquetages servant à analyser un document, créer un index, effectuer une recherche dans un index, etc.
Ainsi, vous verrez, dans les programmes donnés en exemple, des instructions de type
import org.apache.lucene.index.IndexWriter ;
qui va chercher la classe IndexWriter, pour créer un index ou encore :
import org.apache.lucene.analysis.standard.StandardAnalyzer ;
pour utiliser une classe servant à analyser un document.
Vous vous sentez prêt à tester tout cela concrètement ? Passez à la prochaine section pour mieux découvrir et exploiter Lucene.
