Traductions pour la plateforme Java

Utiliser Apache Lucene pour effectuer des recherches textuelles

Article d'origine: 

Ajoutez facilement des capacités de recherche et d'indexation à vos applications

Résumé: 

Avec cet article, découvrez Apache Lucene, un moteur de recherche textuelle riche en fonctionnalités et aux performances élevées. Explorez l'architecture de Lucene et ses principales APIs. Apprenez à utiliser Lucene pour la recherche multi-plateformes de texte libre, l'indexation, l'affichage des résultats, et à utiliser des fonctions de recherche avancées.

Lucene est un moteur de recherche textuelle Open Source et passant bien à l'échelle fourni par la fondation Apache. Vous pouvez utiliser Lucene dans des applications commerciales ou Open Source. Les puissantes APIs de Lucene se concentrent surtout sur l'indexation et le recherche. Il peut être utilisé pour ajouter des capacités d'indexation à des applications comme des clients de courrier, des listes de diffusion, des applications effectuant des recherches sur Internet ou dans une base de données, etc. Des sites Internet tels que Wikipedia, TheServerSide, jGuru, et LinkedIn utilisent Lucene.

Lucene apporte aussi des capacités de recherche à l'EDI Eclipse, Nutch (le célèbre moteur Open Source de recherche Web), et à des sociétés comme IBM®, AOL, et Hewlett-Packard. Lucene a été porté vers beaucoup d'autre langages de programmation, par exemple Perl, Python, C++, et .NET. A la date du 30 juillet 2009, la dernière version Java™ de Lucene est la V2.4.1 (ndT: à la date du 07/05/2010, ce sont les 2.9.2 et 3.0.1).

Lucene a beaucoup d'atouts:

  • Il utilise des algorithmes de recherche puissants, exacts et efficaces.
  • Il calcule un score pour chaque document qui correspond à des critères donnés et retourne les documents les plus appropriés classés par score.
  • Il propose de nombreux types de requêtes, tels que PhraseQuery, WildcardQuery, RangeQuery, FuzzyQuery, BooleanQuery, et d'autres encore.
  • Il permet l'analyse d'expressions de requêtage riches du type de celles qui sont saisies par des êtres humains
  • Il permet aux utilisateurs d'étendre le comportement de la recherche en utilisant des tri personnalisés, des filtres et l'analyse d'expressions de requêtage.
  • Il utilise un mécanisme de verrouillage basé sur les fichiers pour empêcher les modifications d'index concurrentes.
  • Il permet d'indexer et de rechercher simultanément.

Constructions d'applications avec Lucene

Comme le montre la Figure 1, construire une application de recherche complète avec Lucene implique principalement l'indexation et la recherche des données, et l'affichage des résultats d'une recherche.

Figure 1. Les étapes de la construction d'applications avec Lucene

Etapes de la construction d'applications avec Lucene

Cet article utilise des bouts de code d'une application de démonstration développée avec la techologie Java et Lucene V2.4.1. L'application de démonstration indexe un ensemble de courriers électroniques stockés dans un fichier de propriétés et montre comment utiliser les APIs de requêtage de Lucene pour chercher dans un index. Cet exemple vous permettra également de vous familiariser avec les opérations de base sur les index.

Indexation des données

Lucene vous permet d'indexer toute donnée disponible dans un format texte. Il peut être utilisé avec presque n'importe quelle source de données tant que de l'information textuelle peut en être extraite. On peut se servir de Lucene pour indexer et rechercher des données stockées dans des documents HTML, des documents Microsoft® Word, des fichiers PDF et bien davantage. La première étape dans l'indexation des données est de les rendre disponibles sous un format textuel simple. Pour ce faire, on utilise des analyseurs personnalisés et des convertisseurs de données.

Le processus d'indexation

L'indexation est le processus de conversion des données textuelles vers un format qui facilite une recherche rapide. Une analogie simple est celle de l'index que l'on trouve à la fin d'un livre: cet index indique la localisation des différents sujets qui sont traités dans le livre.

Lucene stocke les données en entrée dans une structure de données appelée index inversé, qui est lui même stocké dans le système de fichiers ou en mémoire comme un ensemble de fichiers d'index. La plupart des moteurs de recherche Internet utilisent un index inversé. Cela permet aux utilisateurs d'exécuter des recherches par mot-clé rapides et de trouver les documents répondant à une requête données. Avant que la donnée textuelle ne soit ajoutée à l'index, elle est traitée par un analyseur.

L'analyse

L'analyse est la conversion des données textuelles en unités fondamentales de recherche, appelées termes. Pendant l'analyse, le texte subit plusieurs opérations: extraction des mots, suppression des mots les plus courants et de la ponctuation, réduction des mots à leur racine, passage en minuscules, etc. L'analyse du texte est effectuée avant l'indexation et l'analyse des requêtes. Elle convertit les données textuelles en tokens, et ces tokens sont ajoutés en tant que termes à l'index Lucene.

Lucene offre une grande variété d'analyseurs, tels que SimpleAnalyzer, StandardAnalyzer, StopAnalyzer, SnowballAnalyzer, sans être exhaustif. Ils diffèrent dans leur manière de découper le texte et d'appliquer des filtres. Comme l'analyse supprime des mots avant l'indexation, elle diminue la taille de l'index, mais peut avoir un effet négatif sur la précision du traitement des requêtes. Il est possible d'obtenir un meilleur contrôle du processus d'analyse en utilisant les briques de base fournies par Lucene. Le Tableau 1 liste quelques-uns des analyseurs fournis par Lucene et leur manière de traiter les données.

Analyseur Opérations effectuées sur les données textuelles
Tableau 1. Analyseurs fournis par Lucene
WhitespaceAnalyzer Découpe en signes sur la base de l'espace
SimpleAnalyzer Découpe sur la base des caractères autres que des lettres et met le texte en minuscules
StopAnalyzer Supprime les mots d'arrêt (inutiles pour la recherche) et met le texte en minuscules
StandardAnalyzer Découpe le texte sur la base d'une grammaire sophistiquée qui reconnait: les adresses électroniques, les acronymes, les caractères chinois, coréens et japonais, les combinaisons alphanumériques (liste non-exhaustive). Met le texte en minuscules et supprimes les mots d'arrêt.

Classes principales pour l'indexation

Directory
Classe abstraite qui représente l'endroit où les fichiers d'index sont stockés. Deux sous-classes surtout sont couramment utilisées.
  • FSDirectory est une implémentation de Directory qui stocke les index dans le système de fichiers, ce qui est utile pour les gros index.
  • RamDirectory est une implémentation qui stocke tous les index en mémoire. C'est valable pour les index de plus petite taille qui peuvent être entièrement chargés en mémoire et détruits lors de la sortie de l'application. Comme l'index est en mémoire, il est plus rapide que FSDirectory.
Analyzer
Comme nous l'avons vu, la fonction des analyseurs est de prétraiter les données texte et de les convertir en termes stockés dans l'index. IndexWriter accepte un analyseur utilisé pour découper la donnée avant de l'indexer. Pour indexer correctement le texte, on doit utiliser un analyseur adapté à la langue du texte qui doit être indexé. Les analyseurs par défaut marchent bien pour la langue anglaise. Il existe plusieurs autres analyseurs dans le bac à sable de Lucene, dont ceux traitant le chinois, le japonais et le coréen (ndT: et le français !).
IndexDeletionPolicy
Interface dont les implémentations définissent des stratégies de suppression des versions périmées de l'index. La politique de suppression par défaut est KeepOnlyLastCommitDeletionPolicy, qui garde uniquement la version la plus récente et qui supprime les versions précédentes quand une nouvelle version est prête.
IndexWriter
Classe qui crée ou maintient un index. Son constructeur prend un booléen qui détermine si un nouvel index est créé ou si un index existant est ouvert. Il fournit des méthodes pour ajouter, supprimer ou mettre à jour des documents dans l'index. Les modifications apportées à l'index sont tout d'abord mises en mémoire tampon, et périodiquement écrites dans le répertoire d'index. IndexWriter expose plusieurs champs qui contrôlent la manière dont les index sont mis en mémoire tampon et écrits sur le disque. Les modifications ne sont pas visibles pour IndexReader tant que les méthodes commit() ou close() de IndexWriter ne sont pas appelées. IndexWriter crée un fichier de verrouillage pour le répertoire afin d'empêcher la corruption de l'index par des mises à jour simultanées. IndexWriter permet à l'utilisateur de spécifier optionnellement une politique de suppression des autres versions.

Listing 1. Utilisation de l'IndexWriter de Lucene

//Création de l'instance de Directory où les fichiers d'index seront stockés
Directory fsDirectory =  FSDirectory.getDirectory(indexDirectory);
/* Création d'une instance d'analyseur, qui sera utilisée pour découper
les données d'entrée */
Analyzer standardAnalyzer = new StandardAnalyzer();
//Création d'un nouvel index
boolean create = true;
//Création d'une stratégie de suppression
IndexDeletionPolicy deletionPolicy = new KeepOnlyLastCommitDeletionPolicy(); 
indexWriter =new IndexWriter(fsDirectory,standardAnalyzer,create,
	deletionPolicy,IndexWriter.MaxFieldLength.UNLIMITED);

Ajout de données à un index

Deux classes sont impliquées dans l'ajout de texte à l'index.

Field représente un fragment de donnée utilisé dans les requêtes ou retourné par une recherche. La classe Field encapsule un nom de champ et sa valeur. Lucene fournit des options pour spécifier si un champ doit être indexé ou analysé et si sa valeur doit être stockée. Ces options peuvent être passées à la création d'une instance de champ. Le tableau ci-dessous montre le détail des options de métadonnées de Field.

Option Description
Tableau 2. Détail des métadonnées de Field
Field.Store.Yes Utilisé pour stocké la valeur des champs. Adapté pour les champs affichés dans les résultats de recherche - chemin du fichier et URL, par exemple.
Field.Store.No La valeur du champ n'est pas stockée - le corps d'un courrier électronique, par exemple.
Field.Index.No Adapté pour les champs qui ne sont pas requêtés - souvent utilisé avec les champs stockés, comme le chemin du fichier.
Field.Index.ANALYZED Utilisé pour les champs indexés et analysés - le corps et le sujet d'un courrier électronique, par exemple.
Field.Index.NOT_ANALYZED Utilisé pour les champs indexés mais non analysés. Il préserve complètement la valeur d'origine du champ - comme par exemple les informations personnelles (dates, noms)

Un Document est quant à lui une collection de Fields. Lucene permet de donner plus d'importance à une partie des données (documents et champs) stockées. L'indexation d'un fichier texte implique l'encapsulation des données textuelles dans des champs, la création d'un document qui agrège ces champs, et l'ajout du document à l'index par le biais d'IndexWriter.

Le Listing 2 montre un exemple d'ajout de données à un index.

Listing 2. Ajout de données à un index

/* Etape 1. Préparation des données à indexer. Extraction des données. */

String sender = properties.getProperty("sender");
String date = properties.getProperty("date");
String subject = properties.getProperty("subject");
String message = properties.getProperty("message");
String emaildoc = file.getAbsolutePath();

/* Etape 2. Encapsulation des données dans des Fields et ajout à un Document */

Field senderField =
    new Field("sender",sender,Field.Store.YES,Field.Index.NOT_ANALYZED);
Field emaildatefield = 
    new Field("date",date,Field.Store.NO,Field.Index.NOT_ANALYZED); 
Field subjectField = 
    new Field("subject",subject,Field.Store.YES,Field.Index.ANALYZED);
Field messagefield = 
    new Field("message",message,Field.Store.NO,Field.Index.ANALYZED);
Field emailDocField =
    new Field("emailDoc",emaildoc,Field.Store.YES,Field.Index.NO);

Document doc = new Document();
// Ajout des champs à un Document Lucene
doc.add(senderField);
doc.add(emaildatefield);
doc.add(subjectField);
doc.add(messagefield);
doc.add(emailDocField);

// Ajout du Document à l'index Lucene.
indexWriter.addDocument(doc);

Rechercher des données indexées

Rechercher, c'est examiner l'index pour y trouver des mots puis obtenir les documents qui contiennent ces mots. Il est facile d'ajouter des possibilités de recherche à une application en utilisation l'API de recherche de Lucene. Cette partie parle des principales classes de cette API.

Searcher

Searcher est une classe abstraite qui possède différentes méthodes de recherche surchargées. IndexSearcher est une sous-classe couramment utilisée qui permet de rechercher dans les index stockés dans un répertoire donné. La méthode retourne une collection de documents classés selon leurs scores calculés. Lucene calcule un score pour chaque document correspondant à une requête. IndexSearcher est thread-safe: une instance unique peut être utilisée de manière concurrente par plusieurs threads.

Term

Un terme est l'unité de recherche la plus fondamentale qui soit. Il est composé de deux éléments: le texte du mot et le nom du champ dans lequel ce texte apparait. Les termes sont aussi impliqués dans l'indexation, mais ils sont créés par Lucene de manière interne.

Query et ses sous classes

Query est la classe abstraite pour les requêtes. Rechercher un mot ou une expression se fait en l'encapsulant dans un un plusieurs termes, en les ajoutant à un objet requête et en passant cette requête à la méthode de recherche de IndexSearcher.

Lucene fournit plusieurs implémentations de requêtes, tels que TermQuery, BooleanQuery, PhraseQuery, PrefixQuery, RangeQuery, MultiTermQuery, FilteredQuery, SpanQuery, etc. La section suivante discute des principales classes de requête de l'API de requêtage de Lucene.

TermQuery
Le type de requête le plus basique pour chercher dans un index. TermQuery peut être construit en utilisant un seul terme. La valeur du terme devrait être sensible à la casse, mais ce n'est pas toujours vrai. Il est important de noter que les termes passés à la recherche devraient être consistents avec les termes produits par l'analyse des documents, car les analyseurs effectuent de nombreuses opérations sur le texte original avant que l'index ne soit construit.
Prenons comme exemple le sujet de courrier électronique "Job openings for Java Professionals at Bangalore". Supposons que cet index a été construit en utilisant StandardAnalyzer. Si nous recherchons "Java" en utilisant TermQuery, nous n'aurons aucun résultat puisque ce texte aura été normalisé et mis en minuscules. Si nous cherchons le mot "java" en minuscules, nous aurons tous les courriers électroniques contenant ce mot dans le sujet.

Listing 3. Recherche utilisant TermQuery

// Recherche des courriers ayant le mot 'java' dans le champ sujet
Term term = new Term("subject","java");
Query termQuery = new TermQuery(term);	 
TopDocs topDocs = indexSearcher.search(termQuery,10); 
 
RangeQuery
Tous les termes sont mis dans l'ordre lexivographique dans l'index. On peut chercher dans un intervalle donné en utilisant RangeQuery. L'intervalle est spécifié en donnant des termes de début et de fin, inclus ou exclus.

Listing 4. Recherche dans un intervalle

/* Recherche des courriers du 01/06/2009 au 6/06/2009 
inclus tous les deux */
Term begin = new Term("date","20090601");
Term end = new Term("date","20090606");
Query query = new RangeQuery(begin, end, true);
PrefixQuery
Il est possible de rechercher sur un préfixe donné avec PrefixQuery, qui est utilisée pour construire une requête qui retournera les documents contenant des termes qui commencent par ce préfixe.

Listing 5. Recherche utilisant PrefixQuery

// Recherche des courriers dont le champ expéditeur commence par le mot 'job'
PrefixQuery prefixQuery = new PrefixQuery(new Term("sender","job"));
PrefixQuery query = new PrefixQuery(new Term("sender","job"));
BooleanQuery
On peut construire des requêtes puissantes en combinant un nombre arbitraire de requêtes par le moyen de BooleanQuery. Elle utilise une requête et une clause qui indique si la requête peut aboutir, doit aboutir ou ne doit pas aboutir. Dans une BooleanQuery, le nombre maximum de clauses est limité à 1024 par défaut. Il est possible de positionner ce nombre en appelant la méthode setMaxClauseCount.

Listing 6. Recherche utilisant BooleanQuery

// Recherche des courriers ayant les mots
// 'java' et 'bangalore' dans le champ sujet
Query query1 = new TermQuery(new Term("subject","java"));
Query query2 = new TermQuery(new Term("subject","bangalore"));
BooleanQuery query = new BooleanQuery();
query.add(query1,BooleanClause.Occur.MUST);
query.add(query2,BooleanClause.Occur.MUST);
PhraseQuery
On peut chercher une expression, c'est-à-dire une séquence particulière de termes, en utilisant PhraseQuery. utilise l'information sur la position du terme stockée dans l'index. La distance maximale entre les termes qui doivent être considérés comme répondant à la requête est appelée slop. Par défaut la valeur du slop est zéro, et elle peut être positionnée en appelant la méthode setSlop. PhraseQuery permet également d'utiliser plusieurs termes.

Listing 7. Recherche utilisant PhraseQuery

/* Recherche des courriers contenant l'expression
   'job opening j2ee' dans le champ sujet*/
PhraseQuery query = new PhraseQuery();
query.setSlop(1);
query.add(new Term("subject","job"));
query.add(new Term("subject","opening"));
query.add(new Term("subject","j2ee"));
WildcardQuery
WildcardQuery implémente une recherche avec des jokers, qui permet de faire des recherches telles que arch* (qui permet de  trouver les documents contenant architecte, architecture, etc.). Deux jokers standards sont utilisés:
  • * pour remplacer 0 caractère ou plus
  • ? pour remplacer 1 caractère ou plus
Il pourrait y avoir une chute des performances si vous utilisiez des jokers au début d'une recherche, puisque tous les termes de l'index devraient être requêtés pour trouver les documents résultats.

Listing 8. Recherche utilisant WildcardQuery

/* Recherche des courriers contenant le modèle 'arch*' dans le champ sujet*/
Query query = new WildcardQuery(new Term("subject","arch*"));
FuzzyQuery
Il est possible de rechercher sur des termes similaires avec FuzzyQuery. La mesure de similarité est basée sur l'algorithme de Levenshtein. Dans le Listing 9, est utilisée pour trouver un résultat acceptable avec un mot mal orthographié "admnistrtor", quand bien même ce mot n'est pas indexé.

Listing 9. Recherche utilisant FuzzyQuery

/* Recherche des courriers contenant des mots similaires
   à 'admnistrtor' dans le champ sujet.
   Notez que 'admnistrtor' est volontairement mal orthographié */
Query query = new FuzzyQuery(new Term("subject", "admnistrtor"));
QueryParser
QueryParser est utile pour analyser des requêtes entrées par des êtres humains. On peut l'utiliser pour analyser des expressions entrées par les utilisateurs pour en faire une requête Lucene, qui peut être passée à la méthode de recherche de IndexSearcher. Il peut analyser des requêtes riches et les convertir en une des sous-classes concrètes de Query. Il faut échapper les caractères spéciaux comme * et ? avec un backslash (\). Il est possible de construire des construire textuellement des requêtes comportant des clauses booléennes en utilisant les opérateurs AND, OR, et NOT.

Listing 10. Recherche à partir d'une expression entrée par un utilisateur

QueryParser queryParser = new QueryParser("subject",new StandardAnalyzer());
// Recherche des courriers contenant les mots
// 'job openings' et '.net' et 'pune'
Query query = queryParser.parse("job openings AND .net AND pune");

Affichage du résultat de la recherche

IndexSearcher retourne un tableau classé de références vers les résultats de la recherche, tels que les documents qui satisfont une requête donnée. On peut décider du nombre de résultats à retourner en le spécifiant dans la méthode de recherche d'IndexSearcher. Une pagination personnalisée des résultats de recherche peut être construite sur cette base, que ce soit dans une application Web ou classique. Les classes les plus importantes en ce qui concerne la manipulation des résultats sont ScoreDoc et TopDocs.

ScoreDoc
Un simple pointeur vers un document satisfaisant la recherche. Il encapsule la position du document dans l'index et le score calculé par Lucene.
TopDocs
Encapsule le nombre total de résultats de recherche et un tableau de ScoreDoc.

Le bout de code ci-dessous montre comment récupérer les documents répondant à la recherche.

Listing 11. Affichage des résultats de recherche

/* Le premier paramètre est la requête à exécuter,
   le second est le nombre de résultats qui doivent être ramenés */
TopDocs topDocs = indexSearcher.search(query,20);	
System.out.println("Total hits "+topDocs.totalHits);

// Récupère le tableau de références vers les documents
ScoreDoc[] scoreDocArray = topDocs.scoreDocs;	
for(ScoreDoc scoredoc: scoreDocArray){
   // Retourne le document et affiche les détails
   Document doc = indexSearcher.doc(scoredoc.doc);
   System.out.println("\nSender: "+doc.getField("sender").stringValue());
   System.out.println("Subject: "+doc.getField("subject").stringValue());
   System.out.println("Email file location: " +
      doc.getField("emailDoc").stringValue());	
}

Opérations de base sur les index

Suppression de documents dans un index

Les applications doivent souvent mettre à jour l'index avec les dernières données et supprimer les données obsolètes, comme dans un moteur de recherche Internet qui indexerait des pages Web. Lucene fournit l'interface IndexReader pour effectuer ces opérations.

IndexReader est une classe abstraite qui propose différentes méthodes pour accéder à l'index. En interne, Lucene pointe vers les documents au moyen de numéros qui varient en fonction des ajouts et des suppressions de documents dans l'index. IndexReader ne peut pas être utilisé pour mettre à jour les index dans un répertoire pour lequel un IndexWriter est déjà ouvert. IndexReader travaille systématiquement sur un instantané de l'index pris au moment de son ouverture. Toute modification apportée à l'index est invisible jusqu'à ce que IndexReader soit réouvert. Il est crucial que les applications utilisant Lucene réouvrent leurs IndexReaders pour voir les dernières modifications de l'index.

Listing 12. Suppression de documents dans un index

// Suppression dans l'index des courriers reçus en mai
IndexReader indexReader = IndexReader.open(indexDirectory);
indexReader.deleteDocuments(new Term("month","05"));
// Fermeture des fichiers d'index et sauvegarde physique des suppressions
indexReader.close();

Promotion de documents ou de champs

Parfois on souhaite donner plus d'importance à une partie des données indexées. On peut le faire en positionnant un facteur d'importance pour un document (ndT: c'est-à-dire pour tous les champs du document) ou un champ particulier. Par défaut, tous les documents et les champs ont le même facteur d'importance qui est 1.0.

Listing 13. Promotion de champs

// Affichage prioritaire des résultats contenant 'pune'
// dans le sujet en positionnant le facteur d'importance
if(subject.toLowerCase().indexOf("pune") != -1){
	subjectField.setBoost(2.2F);
}
// Affichage prioritaire des résultats
// contenant 'job' dans l'expéditeur
if(sender.toLowerCase().indexOf("job")!=-1){	
	luceneDocument.setBoost(2.1F);
}

Aller plus loin avec la recherche

Lucene offre des fonctionnalités de tri avancées. Il est possible de trier les résultats d'une recherche sur des champs qui sont stockés et indexés sous leur forme d'origine. Les résultats de recherche peuvent également refléter l'ordre de l'index. Par défaut, Lucene trie les résultats par pertinence décroissante, qui est le score calculé. L'ordre du tri peut également être modifié.

Listing 14. Tri des résultats

/* Recherche des courriers pour lesquels le sujet contient 'job' et
   tri décroissant des résultats par email de l'expéditeur
 */
SortField sortField = new SortField("sender", true);	
Sort sortBySender = new Sort(sortField);
WildcardQuery query = new WildcardQuery(new Term("subject","job*"));
TopFieldDocs topFieldDocs = 
			indexSearcher.search(query,null,20,sortBySender);
// Tri dans l'ordre de l'index
topFieldDocs = indexSearcher.search(query,null,20,Sort.INDEXORDER);

Le filtrage consiste à contraindre l'espace de recherche en permettant à un sous-ensemble seulement des documents d'être considérés comme satisfaisant la recherche. On peut utiliser cette fonctionnalité pour implémenter des recherches imbriquées, ou appliquer une couche de sécurité sur les résultats de recherche. Lucene fournit nativement un ensemble de filtres tels que BooleanFilter, CachingWrapperFilter, ChainedFilter, DuplicateFilter, PrefixFilter, QueryWrapperFilter, RangeFilter, RemoteCachingWrapperFilter, SpanFilter, etc. Pour utiliser un filtre, il faut passer un Filter à la méthode de recherche d'IndexSearcher.

Listing 15. Filtrage de la recherche

/* Filtrer les résultats pour ne montrer que les courriers
   dont l'expéditeur est préfixé par 'jobs' */
Term prefix = new Term("sender","jobs");
Filter prefixFilter = new PrefixFilter(prefix);
WildcardQuery query = new WildcardQuery(new Term("subject","job*"));
indexSearcher.search(query,prefixFilter,20);

Conclusion

Lucene, une librairie de recherche Open Source très populaire provenant d'Apache, fournit des fonctions d'indexation et de recherche très puissantes. Il propose une API simple d'utilisation qui ne requiert qu'une compréhension minimale des mécanismes d'indexation et de recherche. Dans cet article, vous avez découvert l'architecture de Lucene et ses APIs de base.

Lucene motorise différentes applications de recherche utilisées par de nombreux sites Internet et organisations bien connus. Il a été porté dans d'autres langages de programmation. Lucene bénéficie d'une communauté large et active. Si vous cherchez une librairie de recherche Open Source, facile d'emploi, qui passe à l'échelle, et très performante, Apache Lucene est un excellent choix.

Commentaires

Bonjour, je dois implementer

Bonjour,
je dois implementer les differents modéle de recherche d'information (modéle boolean, vectoriel,probabiliste..) de l'indexation jusqu'a la rercherche et la classification des resulats...
j'ai décidé de travailler avec du java et je suis interessé par lucene ...
j'aimerai bien savoir à quelle point LUCENE va m'etre utiil!??
sachant qu'il se base sur le modéle boolean et vectoriel!!!!
 

Merci pour cette traduction.

Merci pour cette traduction. Une précision toutefois. Le terme "phrase" ne signifie pas "phrase" en français, mais "expression" (le terme technique est syntagme  = http://fr.wikipedia.org/wiki/Syntagme). Une phrase en anglais se dit "sentence". Ceci  modifie sensiblement la compréhension des traitements proposés par les api de lucène.

Et merci pour ce commentaire

Et merci pour ce commentaire constructif ! J'ai appliqué ta suggestion en remplaçant dans ma traduction 'phrase' par 'expression'. J'espère que les lecteurs précédents auront compris le sens exact de 'phrase', qui je pense se comprend en lisant le contexte. En tous cas c'est nettement plus clair maintenant.

est t-il possible d'utiliser

est t-il possible d'utiliser lucene pour detecter et extraire des informations temporelles