De nos jours, si l’on pense à un moteur de recherche, Google est le premier à venir à l’esprit. Les ex­ploi­tants de sites Web utilisent également Google sous la forme d’un moteur de recherche per­son­na­lisé (CSE) pour offrir ra­pi­de­ment et fa­ci­le­ment aux uti­li­sa­teurs une fonction de recherche pour leur propre contenu. Mais ce n’est bien sûr pas la seule option et pour de nombreux ex­ploi­tants de sites Web, ce n’est pas la meilleure pour offrir aux visiteurs une recherche plein texte. À la place, vous pouvez utiliser Lucene, un projet open source gratuit d’Apache.

De nom­breuses en­tre­prises ont intégré Apache Lucene, en ligne ou hors ligne. Wikipédia avait im­plé­menté Lucene comme fonction de recherche jusqu’à il y a quelques années et utilise main­te­nant Solr, qui est tout de même basé sur Lucene, et les re­cherches sur Twitter sont aussi en­tiè­re­ment basées sur Lucene. Le projet, que Doug Cutting a débuté comme un passe-temps à la fin des années 1990, s’est depuis trans­formé en un logiciel qui bénéficie à des millions de personnes au quotidien.

Qu’est-ce que Lucene ?

Lucene est une bi­blio­thèque de pro­grammes publiée par l’Apache Software Foun­da­tion. C’est un logiciel gratuit et libre, n’importe qui peut l’utiliser et le modifier. À l’origine, Lucene a été écrit en­tiè­re­ment en Java, mais il existe main­te­nant aussi des ports vers d’autres langages de pro­gram­ma­tion. Avec Apache Solr et Elas­tic­search, il existe des ex­ten­sions puis­santes qui apportent encore plus de pos­si­bi­li­tés à la fonction de recherche.

Lucene est une recherche plein texte. Cela signifie tout sim­ple­ment qu’un programme recherche un ou plusieurs termes définis par l’uti­li­sa­teur dans une série de documents texte. Cela montre que Lucene n’est pas seulement utilisé dans le contexte du World Wide Web, même si les fonctions de recherche sont om­ni­pré­sentes sur le Web. Lucene peut également être utilisé pour les archives, les bi­blio­thèques ou même le PC à domicile. Lucene ne recherche pas seulement des documents HTML, mais travaille aussi avec des emails ou même des fichiers PDF.

Le facteur décisif pour la recherche est un index, c’est le cœur de Lucene : tous les termes de tous les documents sont stockés ici. Un tel « Inverted Index » n’est en principe qu’un tableau dans lequel, pour chaque terme, la position cor­res­pon­dante est en­re­gis­trée. Pour cons­truire un index, il faut d’abord procéder à une ex­trac­tion. Tous les termes doivent être extraits de tous les documents et sau­ve­gar­dés dans l’index. Lucene permet aux uti­li­sa­teurs de con­fi­gu­rer cette ex­trac­tion in­di­vi­duel­le­ment. Lors de la con­fi­gu­ra­tion, les dé­ve­lop­peurs décident quels champs ils veulent inclure dans l’index. Pour mieux com­prendre le processus, il nous faut prendre du recul.

Les objets avec lesquels Lucene travaille sont des documents sous toutes leurs formes. Cependant, les documents eux-mêmes con­tien­nent, du point de vue de Lucene, des champs. Ces champs con­tien­nent, par exemple, le nom de l’auteur, le titre du document ou le nom du fichier de l’auteur. Chaque champ possède un nom unique et une valeur. Par exemple, le champ nommé titre peut avoir la valeur « Apache Lucene user manual ». Lors de la création de l’index, vous pouvez décider quelles mé­ta­don­nées vous voulez inclure.

Lors de l’in­dexa­tion des documents, on procède à ce qu’on appelle une « to­ke­ni­sa­tion ». Pour une machine, un document est en effet d’abord un as­sem­blage de données. Même si l’on s’éloigne du niveau des bits et que l’on se tourne vers le contenu lisible par l’homme, un document est avant tout constitué d’une chaîne de ca­rac­tères : lettres, ponc­tua­tion et espaces.

À partir de cette quantité de données, des segments sont créés avec la to­ke­ni­sa­tion, les termes (la plupart du temps des mots simples), peuvent fi­na­le­ment être re­cher­chés. La façon la plus simple d’exécuter une telle to­ke­ni­sa­tion est d’utiliser la méthode White-Space : un terme se termine lorsqu’un espace (un espace blanc) apparaît. Toutefois, cela n’est pas utile si les termes fixes sont composés de plusieurs mots, par exemple « veille de Noël ». Des dic­tion­naires sont également utilisés à cet effet, qui peuvent également être im­plé­men­tés di­rec­te­ment dans le code Lucene.

Lors de l’analyse des données, dont la to­ke­ni­sa­tion fait partie, Lucene effectue également une nor­ma­li­sa­tion. Cela signifie que les termes sont trans­for­més en une forme stan­dar­di­sée, par exemple, toutes les lettres ma­jus­cules sont écrites en mi­nus­cules. En outre, Lucene crée un ordre de tri. Ceci fonc­tionne via dif­fé­rents al­go­rithmes, par exemple via la mesure TF-IDF. En tant qu’uti­li­sa­teur, vous voulez pro­ba­ble­ment d’abord obtenir les résultats les plus per­ti­nents ou les plus récents, les al­go­rithmes du moteur de recherche Lucene rendent cela possible.

Pour que les uti­li­sa­teurs puissent trouver quoi que ce soit, ils doivent alors entrer un terme de recherche dans une ligne de texte. Les termes sont appelés « Query » dans le contexte de Lucene. Le mot anglais pour requête indique que l’entrée ne doit pas seulement consister en un ou plusieurs mots, mais peut aussi contenir des mo­di­fi­ca­teurs tels que AND, OR ou + et - ainsi que des ca­rac­tères gé­né­riques. Le Que­ry­Par­ser, une classe au sein de la bi­blio­thèque du programme, traduit l’entrée en une demande de recherche concrète pour le moteur de recherche. Le Que­ry­Par­ser fournit également aux dé­ve­lop­peurs des options de pa­ra­mé­trage. L’analyseur peut être configuré de manière à être exac­te­ment adapté aux besoins de l’uti­li­sa­teur.

Ce que Lucene a apporté de com­plè­te­ment nouveau dès sa sortie est l’in­dexa­tion in­cré­men­tale. Avant Lucene, seule l’in­dexa­tion par lots était possible. Alors que seuls des index complets peuvent être im­plé­men­tés, un index peut être mis à jour avec l’in­dexa­tion in­cré­men­tale. Des entrées in­di­vi­duelles peuvent être ajoutées ou sup­pri­mées.

Image: Représentation schématique des processus au sein d’Apache Lucene
Au cœur du fonc­tion­ne­ment de Lucene se trouve l’index.

Lucene versus Google & Co ?

La question semble justifiée : pourquoi cons­truire votre propre moteur de recherche alors qu’il existe déjà Google, Bing ou d’autres moteurs de recherche ? Bien sûr, y répondre n’est pas si évident, après tout, vous devez tenir compte de l’ap­pli­ca­tion in­di­vi­duelle. Mais une chose est im­por­tante pour com­prendre : lorsque nous parlons de Lucene comme d’un moteur de recherche, c’est juste une ap­pel­la­tion simplifié.

En fait, il s’agit plus pré­ci­sé­ment d’une bi­blio­thèque de recherche d’in­for­ma­tion (In­for­ma­tion Retrieval Library). Lucene est donc un système avec lequel on peut chercher et trouver de l’in­for­ma­tion. C’est aussi le cas de Google et d’autres moteurs de recherche, mais ces derniers se limitent à l’in­for­ma­tion provenant du World Wide Web. Vous pouvez par contre utiliser Lucene dans n’importe quel scénario et le con­fi­gu­rer en fonction de vos besoins précis. Par exemple, vous pouvez intégrer Lucene au sein d’autres ap­pli­ca­tions.

En résumé

Apaches Lucene, con­trai­re­ment aux moteurs de recherche Web, n’est pas un logiciel prêt à l’emploi : afin de bé­né­fi­cier des capacités du système, vous devez d’abord pro­gram­mer votre propre moteur de recherche. Nous vous montrons les premières étapes dans notre tutoriel sur Lucene.

Lucene, Solr, Elas­tic­search, quelles sont les dif­fé­rences ?

Les débutants se demandent notamment quelle est la dif­fé­rence entre Apache Lucene d’une part et Apache Solr et Elas­tic­search d’autre part. Ces deux derniers sont basés sur Lucene : l’ancien produit est un moteur de recherche pur. Alors que Solr et Elas­tic­search sont des serveurs de recherche complets qui étendent encore plus le champ d’ap­pli­ca­tion de Lucene.

Note

Si vous n’avez besoin que d’une seule fonction de recherche pour votre site Web, Solr ou Elas­tic­search sont pro­ba­ble­ment plus adaptés. Ces deux systèmes sont spé­ci­fi­que­ment conçus pour une uti­li­sa­tion sur le Web.

Apache Lucene : le tutoriel

Lucene est, dans sa version originale, basé sur Java : ceci permet d’utiliser le moteur de recherche pour dif­fé­rentes pla­te­formes en ligne et hors ligne, si vous savez comment faire. Nous vous ex­pli­quons étape par étape comment cons­truire votre propre moteur de recherche avec Apache Lucene.

Note

Ce tutoriel traite de Lucene basé sur Java. Le code a été testé sous la version Lucene 7.3.1 et la version JDK 8. Nous tra­vail­lons avec Eclipse sous Ubuntu. Les étapes in­di­vi­duelles peuvent être dif­fé­rentes lorsqu’on utilise d’autres en­vi­ron­ne­ments de dé­ve­lop­pe­ment et systèmes d’ex­ploi­ta­tion.

Ins­tal­la­tion

Pour pouvoir tra­vail­ler avec Apache Lucene, Java doit être installé sur votre système. Tout comme Lucene, vous pouvez également té­lé­char­ger gra­tui­te­ment le Java De­ve­lop­ment Kit (JDK) sur le site officiel. Vous devriez également installer un en­vi­ron­ne­ment de dé­ve­lop­pe­ment que vous pouvez utiliser pour écrire le code pour Lucene. De nombreux dé­ve­lop­peurs font confiance à Eclipse, mais il existe de nom­breuses autres offres open source. Ensuite, vous pouvez té­lé­char­ger Lucene à partir de la page du projet. Choi­sis­sez la version de base (Core Version) du programme.

Vous n’avez pas besoin d’installer Lucene. Il suffit de dé­com­pres­ser le té­lé­char­ge­ment à l’em­pla­ce­ment souhaité. Vous créez ensuite un nouveau projet dans Eclipse ou un autre en­vi­ron­ne­ment de dé­ve­lop­pe­ment et ajoutez Lucene comme bi­blio­thèque. Pour cet exemple, nous utilisons trois bi­blio­thèques, qui sont toutes incluses dans le paquet d’ins­tal­la­tion :

  • …/lucene-7.3.1/core/lucene-core-7.3.1.jar
  • …/lucene-7.3.1/que­ry­par­ser/lucene-que­ry­par­ser-7.3.1.jar
  • …/lucene-7.3.1/analysis/common/lucene-analyzers-common-7.3.1.jar

Si vous utilisez une version dif­fé­rente ou si vous avez modifié la structure des dossiers, vous devez adapter les spé­ci­fi­ca­tions en con­sé­quence.

Image: Ajouter des bibliothèques dans Eclipse
Ajoutez les bi­blio­thèques requises à votre projet.
Conseil

Sans con­nais­sance de base de Java et de la pro­gram­ma­tion en général, les étapes suivantes sont dif­fi­ciles à suivre. Cependant, si vous avez déjà une con­nais­sance de base de ce langage de pro­gram­ma­tion, tra­vail­ler avec Lucene est un bon moyen de dé­ve­lop­per vos com­pé­tences.

In­dexa­tion

Le cœur d’un moteur de recherche basé sur Lucene est l’index. Sans index, vous ne pouvez pas proposer de fonction de recherche. C’est donc la première étape : nous créons une classe Java pour l’in­dexa­tion.

Mais avant de cons­truire le mécanisme d’in­dexa­tion pro­pre­ment dit, nous créons deux classes pour vous aider avec le reste. La classe index et la classe de recherche que nous uti­li­se­rons plus tard.

package tutorial;
public class LuceneConstants {
    public static final String CONTENTS = "contents";
    public static final String FILE_NAME = "filename";
    public static final String FILE_PATH = "filepath";
    public static final int MAX_SEARCH = 10;
}

Cette in­for­ma­tion sera im­por­tante plus tard pour dé­ter­mi­ner avec précision les champs.

package tutorial;
import java.io.File;
import java.io.FileFilter;
public class TextFileFilter implements FileFilter {
    @Override
    public boolean accept(File pathname) {
        return pathname.getName().toLowerCase().endsWith(".txt");
    }
}

Avec cela, nous im­plé­men­tons un filtre qui lit cor­rec­te­ment nos documents. À ce stade, vous pouvez voir que notre moteur de recherche ne fonc­tion­nera plus tard que pour les fichiers txt. Tous les autres formats sont ignorés par l’exemple simple.

Image: Fichiers texte comme corpus de recherche pour Apache Lucene
Dans notre exemple, de simples fichiers texte servent de corpus pour la recherche
Note

Pour débuter une classe, vous importez d’abord les autres classes. Celles-ci font déjà partie de votre ins­tal­la­tion Java ou sont dis­po­nibles grâce à l’in­té­gra­tion de bi­blio­thèques externes.

Créez main­te­nant la classe réelle pour l’in­dexa­tion.

package tutorial;
import java.io.File;
import java.io.FileFilter;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Paths;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
public class Indexer {
    private IndexWriter writer;
    public Indexer(String indexDirectoryPath) throws IOException {
        Directory indexDirectory = 
            FSDirectory.open(Paths.get(indexDirectoryPath));
        StandardAnalyzer analyzer = new StandardAnalyzer();
        IndexWriterConfig iwc = new IndexWriterConfig(analyzer);
        writer = new IndexWriter(indexDirectory, iwc);
    }
    public void close() throws CorruptIndexException, IOException {
        writer.close();
    }
    private Document getDocument(File file) throws IOException {
        Document document = new Document();
        TextField contentField = new TextField(LuceneConstants.CONTENTS, new FileReader(file));
        TextField fileNameField = new TextField(LuceneConstants.FILE_NAME,
            file.getName(),TextField.Store.YES);
        TextField filePathField = new TextField(LuceneConstants.FILE_PATH,
            file.getCanonicalPath(),TextField.Store.YES);
        document.add(contentField);
        document.add(fileNameField);
        document.add(filePathField);
        return document;
    }    
    private void indexFile(File file) throws IOException {
        System.out.println("Indexing "+file.getCanonicalPath());
        Document document = getDocument(file);
        writer.addDocument(document);
    }
    public int createIndex(String dataDirPath, FileFilter filter) 
        throws IOException {
        File[] files = new File(dataDirPath).listFiles();
        for (File file : files) {
            if(!file.isDirectory()
                && !file.isHidden()
                && file.exists()
                && file.canRead()
                && filter.accept(file)
            ){
                indexFile(file);
            }
        }
        return writer.numDocs();
    }
}

Diverses étapes sont ef­fec­tuées au cours de l’éla­bo­ra­tion du code : vous dé­fi­nis­sez l’In­dex­Wri­ter à l’aide de Stan­dar­dA­na­ly­zer. Lucene offre dif­fé­rentes classes d’analyse, qui peuvent toutes être trouvées dans la bi­blio­thèque cor­res­pon­dante.

Conseil

Voir la do­cu­men­ta­tion d’Apache Lucene pour toutes les classes incluses dans le té­lé­char­ge­ment.

En outre, le programme lit les fichiers et définit les zones à indexer. À la fin du code, les fichiers index sont créés.

Image: Fichiers index d’Apache Lucene
Lucene crée plusieurs fichiers index à partir des documents sources.

Fonction de recherche

Bien sûr, l’index seul ne vous est d’aucune utilité. Vous devez donc également établir une fonction de recherche.

package tutorial;
import java.io.IOException;
import java.nio.file.Paths;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
public class Searcher {
	
   IndexSearcher indexSearcher;
   QueryParser queryParser;
   Query query;
   
   public Searcher(String indexDirectoryPath) 
      throws IOException {
      Directory indexDirectory = 
         FSDirectory.open(Paths.get(indexDirectoryPath));
      IndexReader reader = DirectoryReader.open(indexDirectory);
      indexSearcher = new IndexSearcher(reader);
      queryParser = new QueryParser(LuceneConstants.CONTENTS,
         new StandardAnalyzer());
   }
   
   public TopDocs search( String searchQuery) 
      throws IOException, ParseException {
      query = queryParser.parse(searchQuery);
      return indexSearcher.search(query, LuceneConstants.MAX_SEARCH);
   }
   public Document getDocument(ScoreDoc scoreDoc) 
      throws CorruptIndexException, IOException {
      return indexSearcher.doc(scoreDoc.doc);	
   }
}

Deux classes Lucene importées sont par­ti­cu­liè­re­ment im­por­tantes dans le code : In­dex­Sear­cher et Que­ry­Par­ser. Pendant que la première effectue une recherche dans l’index créé, Que­ry­Par­ser est res­pon­sable de la tra­duc­tion de la requête de recherche en in­for­ma­tions que la machine peut com­prendre.

Vous disposez main­te­nant d’une classe pour l’in­dexa­tion et d’une classe pour re­cher­cher l’index, mais vous ne pouvez pas encore exécuter une demande de recherche spé­ci­fique avec l’une ou l’autre de ces classes. Par con­sé­quent, vous avez main­te­nant besoin d’une cinquième classe.

package tutorial;
import java.io.IOException;
import org.apache.lucene.document.Document;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
public class LuceneTester {
	
   String indexDir = "/home/Index/";
   String dataDir = "/home/Data/";
   Indexer indexer;
   Searcher searcher;
   public static void main(String[] args) {
      LuceneTester tester;
      try {
         tester = new LuceneTester();
         tester.createIndex();
         tester.search("YourSearchTerm");
      } catch (IOException e) {
         e.printStackTrace();
      } catch (ParseException e) {
         e.printStackTrace();
      }
   }
   private void createIndex() throws IOException {
      indexer = new Indexer(indexDir);
      int numIndexed;
      long startTime = System.currentTimeMillis();	
      numIndexed = indexer.createIndex(dataDir, new TextFileFilter());
      long endTime = System.currentTimeMillis();
      indexer.close();
      System.out.println(numIndexed+" File indexed, time taken: "
         +(endTime-startTime)+" ms");		
   }
   private void search(String searchQuery) throws IOException, ParseException {
      searcher = new Searcher(indexDir);
      long startTime = System.currentTimeMillis();
      TopDocs hits = searcher.search(searchQuery);
      long endTime = System.currentTimeMillis();
   
      System.out.println(hits.totalHits +
         " documents found. Time :" + (endTime - startTime));
      for(ScoreDoc scoreDoc : hits.scoreDocs) {
         Document doc = searcher.getDocument(scoreDoc);
            System.out.println("File: "
            + doc.get(LuceneConstants.FILE_PATH));
      }  
   }
}

Vous devez adapter au moins trois entrées dans ces classes finales, car vous spécifiez ici les chemins d’accès aux documents originaux et aux fichiers index, ainsi que le mot recherché.

  • String indexDir : insérez ici le chemin d’accès au dossier dans lequel vous voulez stocker les fichiers d’index.
  • String dataDir : à ce stade, le code source attend le chemin d’accès au dossier dans lequel sont stockés les documents à re­cher­cher.
  • tester.search : entrez votre terme de recherche ici.

Puisque les trois cas sont des chaînes de ca­rac­tères, vous devez mettre les ex­pres­sions entre guil­le­mets. Sous Windows aussi, vous utilisez des barres obliques normales au lieu des barres obliques inverses pour les chemins.

Pour tester le programme, copiez quelques fichiers en clair dans le ré­per­toire spécifié comme dataDir. Assurez-vous que les ex­ten­sions de fichier sont « .txt » . Vous pouvez main­te­nant démarrer le programme, dans Eclipse par exemple, cliquez sur la flèche verte dans la barre de menu.

Note

Le code de programme présenté n’est qu’un projet de dé­mons­tra­tion pour montrer comment Lucene fonc­tionne. Par exemple, il manque une interface uti­li­sa­teur graphique dans ce programme : vous devez entrer le terme de recherche di­rec­te­ment dans le code source et le résultat n’est dis­po­nible que via la console.

Image: Code source dans Eclipse et résultat d’une recherche Lucene dans la console
Eclipse affiche le résultat de votre recherche dans la console.

Lucene Query Syntax

Les moteurs de recherche, même ceux que vous con­nais­sez sur le Web, ne per­met­tent gé­né­ra­le­ment pas uni­que­ment la recherche d’un seul terme. Avec certaines méthodes, vous pouvez en effet enchaîner des termes, re­cher­cher des phrases ou exclure des mots de manière in­di­vi­duelle. Bien entendu, Apache Lucene offre également ces pos­si­bi­li­tés : avec Lucene Query Syntax, vous pouvez re­cher­cher des ex­pres­sions complexes, même dans plusieurs champs.

  • Single Term : entrez un terme simple tel quel. Con­trai­re­ment à Google et les autres moteurs de recherche célèbres, Lucene suppose que vous savez comment le terme est cor­rec­te­ment écrit. Si vous faites une faute d’or­tho­graphe, vous ob­tien­drez alors un résultat négatif. Exemple : voiture
  • Phrase : les phrases sont des séquences de mots définies. Ce ne sont pas seulement les termes in­di­vi­duels de la phrase qui sont dé­ter­mi­nants, mais aussi l’ordre dans lequel ils ap­pa­rais­sent. Exemple : "Ma voiture est rouge".
  • Wildcard Searches : ils rem­pla­cent un ou plusieurs ca­rac­tères dans votre requête de recherche. Les ca­rac­tères gé­né­riques peuvent être utilisés à la fin et au milieu d’un terme, mais pas au début.
    • ? : Le point d’in­ter­ro­ga­tion remplace exac­te­ment un caractère. Exemple : Au?o
    • * : L’as­té­risque ne remplace aucun caractère ou un nombre infini de ca­rac­tères. Par exemple, d’autres formes d’un terme peuvent également être re­cher­chées, telles que le pluriel. Exemple : Auto*
  • Regular Ex­pres­sion Searches : vous pouvez utiliser des ex­pres­sions ré­gu­lières pour re­cher­cher plusieurs termes en même temps, dont certains ont des si­mi­li­tudes et d’autres diffèrent les uns des autres. Con­trai­re­ment aux ca­rac­tères gé­né­riques, vous dé­fi­nis­sez exac­te­ment les dif­fé­rences à prendre en compte. Pour ce faire, vous utilisez des barres obliques et des crochets. Exemple : /[MS]ein/
  • Fuzzy Searches : vous effectuez une recherche vague si, par exemple, vous voulez avoir une tolérance aux erreurs. Vous utilisez la distance Damerau-Le­ven­sh­tein (une formule qui évalue les si­mi­li­tudes) pour dé­ter­mi­ner l’ampleur de l’écart. Pour ce faire, utilisez le tilde. Des distances de 0 à 2 sont au­to­ri­sées. Exemple : Auto~1
  • Proximity Searches : même si vous voulez permettre une ap­proxi­ma­tion pour les phrases, utilisez le tilde. Par exemple, vous pouvez spécifier que vous voulez re­cher­cher deux termes même s’il y a 5 autres mots entre eux. Exemple : "Auto rouge"~5
  • Range Searches : dans ce type de requête, vous re­cher­chez entre deux termes dans une zone spé­ci­fique. Bien qu’une telle recherche n’ait guère de sens pour le contenu général d’un document, elle peut s’avérer très utile dans le trai­te­ment de certains domaines tels que les auteurs ou les titres. Le tri s’effectue selon un ordre lexi­co­gra­phique. Pendant que vous clarifiez une zone inclusive avec des crochets, vous utilisez des crochets bouclés pour exclure la zone dé­ter­mi­née par les deux termes de recherche de la requête. Utilisez TO pour délimiter les deux termes. Exemple : [Allende TO Borges] ou {Byron TO Shelley}, res­pec­ti­ve­ment
  • Boosting : Lucene vous permet de donner des termes ou des ex­pres­sions plus per­ti­nentes que les autres dans votre recherche. Ceci vous permet d’in­fluen­cer le tri des résultats. Vous dé­fi­nis­sez le facteur d’am­pli­fi­ca­tion avec le cir­con­flexe suivie d’une valeur. Exemple : Auto^2 rouge
  • Boolean Operators : vous utilisez des opé­ra­teurs logiques pour créer des con­nexions entre les termes d’une requête de recherche. Les opé­ra­teurs doivent toujours être écrits en ma­jus­cules afin que Lucene ne les évalue pas comme des termes de recherche normaux.
    • AND : avec l’es­per­luette, les deux termes doivent ap­pa­raitre dans le document pour qu’un résultat ap­pa­raisse. Vous pouvez aussi utiliser deux es­per­luettes con­sé­cu­tives au lieu de l’ex­pres­sion. Exemple : Voiture && rouge
    • OR : le lien « ou » est le cas par défaut lorsque vous insérez sim­ple­ment deux termes l’un après l’autre. L’un des deux termes doit ap­pa­raitre, mais il également possible que les deux soient contenus dans le même document. Vous créez la liaison ou avec OR, || ou en ne sai­sis­sant aucun opérateur. Exemple : Voiture rouge
    • + : avec le signe « plus », vous éta­blis­sez un certain cas du lien « ou ». Si vous placez le caractère di­rec­te­ment devant un mot, ce terme doit ap­pa­raitre, tandis que l’autre est fa­cul­ta­tif. Exemple : +Voiture rouge
    • NOT : le lien « non » exclut certains termes ou ex­pres­sions de la recherche. Vous pouvez remplacer l’opérateur par un point d’ex­cla­ma­tion ou placer un signe moins juste avant le terme à exclure. Vous ne pouvez pas utiliser l’opérateur NOT avec un seul terme ou une seule ex­pres­sion. Exemple : Voiture rouge -bleu
  • Grouping : les pa­ren­thèses peuvent être utilisées pour regrouper les termes dans les requêtes de recherche. Pour créer des entrées plus complexes, par exemple, vous devez lier un terme à l’un des deux termes suivants : Voiture ET (rouge OU bleu).
  • Escaping Special Cha­rac­ters : pour utiliser les ca­rac­tères qui peuvent être utilisés pour la Lucene Query Syntax dans les termes de recherche, combinez-les avec une barre oblique inverse. Par exemple, vous pouvez inclure un point d’in­ter­ro­ga­tion dans une requête de recherche sans que l’analyseur ne l’in­ter­prète comme un caractère de rem­pla­ce­ment : "Où est ma voiture\?"

Apache Lucene : avantages et in­con­vé­nients

Lucene est un outil puissant pour établir une fonction de recherche sur le Web, dans des archives ou sur des ap­pli­ca­tions. Les adeptes de Lucene ap­pré­cient de pouvoir cons­truire un moteur de recherche très rapide grâce à l’in­dexa­tion, qui peut également être adapté dans les moindres détails à leurs propres besoins. Puisqu’il s’agit d’un projet open source, Lucene n’est pas seulement dis­po­nible gra­tui­te­ment, mais il est aussi cons­tam­ment développé par une grande com­mu­nauté.

Vous pouvez donc l’utiliser non seulement en Java mais aussi en PHP, Python et autres langages de pro­gram­ma­tion. Et cela conduit aussi au seul in­con­vé­nient : la con­nais­sance de la pro­gram­ma­tion est ab­so­lu­ment né­ces­saire. La recherche plein texte n’est donc pas la bonne chose pour tout le monde. Si vous n’avez besoin que d’une fonction de recherche pour votre site web, vous êtes mieux servi par d’autres offres.

Avantages In­con­vé­nients
Dis­po­nible pour dif­fé­rents langages de pro­gram­ma­tion Nécessite des con­nais­sances en pro­gram­ma­tion
Open Source  
Rapide et léger  
Ranked Searching  
Requêtes de recherche complexes possibles  
   
Aller au menu principal