Al pensar hoy en día en un motor de búsqueda, el primero que viene a la mente es Google. Los ope­ra­do­res de sitios web recurren también al motor de búsqueda pe­r­so­na­li­za­da (CSE, del inglés Custom Search Engine) del gigante de Internet para ofrecer a los usuarios una función de búsqueda de su propio contenido rápida y sencilla. Claro está que esta no es la única opción existente y para muchos ni siquiera la mejor. Una al­te­r­na­ti­va es Lucene: un proyecto gratuito de código abierto de Apache, que ofrece a los vi­si­ta­n­tes una función de búsqueda de texto completo.

Numerosas compañías han integrado Apache Lucene tanto online como offline. Hasta hace unos años, Wikipedia utilizaba Lucene como función de búsqueda, si bien ahora ha pasado a Solr, que a su vez se basa en el primero. Asimismo la búsqueda en Twitter funciona co­m­ple­ta­me­n­te a través de Apache Lucene. El proyecto de Doug Cutting, que comenzó a finales de la década de 1990 como un pa­sa­tie­m­po, se ha co­n­ve­r­ti­do en un software del que millones de personas se be­ne­fi­cian a diario.

¿Qué es Lucene?

Lucene es una bi­blio­te­ca de programas gratuita y de código abierto que cualquier persona puede utilizar y modificar y que está publicada por la Apache Software Fou­n­da­tion. Aunque en sus inicios Lucene estaba escrito co­m­ple­ta­me­n­te en Java, ahora también se puede usar en otros lenguajes de pro­gra­ma­ción. Además Apache Solr y Ela­s­ti­c­sea­r­ch sirven como poderosas ex­te­n­sio­nes que dotan a la función de búsqueda de más po­si­bi­li­da­des.

Lucene permite la búsqueda de texto completo, es decir, se trata de un programa que busca en un conjunto de do­cu­me­n­tos de texto uno o más términos definidos por el usuario. De este hecho se deduce que Lucene no solo se utiliza en el contexto de la World Wide Web, si bien en este las funciones de búsqueda co­n­s­ti­tu­yen un elemento om­ni­pre­se­n­te. También se puede recurrir a Lucene en la búsqueda de archivos, bi­blio­te­cas o incluso en el ordenador de sobremesa y, además de aplicarse en do­cu­me­n­tos HTML, también trabaja con correo ele­c­tró­ni­co o incluso con archivos PDF.

El índice es un elemento decisivo en el proceso de búsqueda con Lucene y se considera el corazón del programa: en él se almacenan todos los términos de todos los do­cu­me­n­tos. Este tipo de índice invertido consiste pri­n­ci­pa­l­me­n­te en una tabla donde se guarda la posición de cada término. No obstante, para poder crear un índice, primero es necesaria la ex­tra­c­ción de todos los términos de todos los do­cu­me­n­tos, proceso que cada usuario puede co­n­fi­gu­rar in­di­vi­dua­l­me­n­te. En la co­n­fi­gu­ra­ción, los de­sa­rro­lla­do­res es­ta­ble­cen qué campos quieren incluir en el índice. Pero ¿a qué se refieren estos campos?

Los objetos con los que Lucene trabaja son do­cu­me­n­tos de cualquier tipo. Estos, desde el punto de vista del propio programa, contienen una serie de campos y estos incluyen, por ejemplo, el nombre del autor, el título del documento o el nombre del archivo. Cada campo tiene una de­sig­na­ción y un valor únicos. Por ejemplo, el campo llamado title puede tener el valor "Manual de usuario de Apache Lucene". Al crear el índice, el usuario puede decidir qué metadatos quiere incluir.

En la in­de­xa­ción de los do­cu­me­n­tos, tiene lugar también lo que se conoce como to­ke­ni­za­tion. Para una máquina, un documento es ante todo un conjunto de in­fo­r­ma­ción. Incluso cuando se pasa del nivel de los bits al de contenido legible para los humanos, un documento sigue estando compuesto por una serie de signos: letras, pu­n­tua­ción, espacios, etc.

A partir de estos datos, se crean con los segmentos de to­ke­ni­za­tion los términos (en su mayoría palabras) que fi­na­l­me­n­te van a poder buscarse. La forma más sencilla de ejecutar este tipo de to­ke­ni­za­ción es mediante el método de espacio en blanco: un término termina cuando se encuentra un espacio en blanco. Sin embargo, este método pierde su utilidad cuando un término está compuesto por varias palabras separadas, como puede ser el caso de "sin embargo". Para so­lu­cio­nar­lo, se recurre a di­c­cio­na­rios adi­cio­na­les que se pueden im­ple­me­n­tar también en el código Lucene.

Al analizar los datos de los que forma parte el proceso de to­ke­ni­za­tion, Lucene también ejecuta un proceso de no­r­ma­li­za­ción. Esto significa que los términos se co­n­vie­r­ten a una forma es­ta­n­da­ri­za­da, de modo que, por ejemplo, todas las ma­yú­s­cu­las se escriben en mi­nú­s­cu­las. Además, Apache Lucene introduce una cla­si­fi­ca­ción mediante una serie de al­go­ri­t­mos, por ejemplo, a través de la medida tf-idf. Como usuario, es probable que primero desees obtener los re­su­l­ta­dos más re­le­va­n­tes o recientes, lo que es posible gracias a los al­go­ri­t­mos del motor de búsqueda.

Para que los usuarios puedan encontrar lo que buscan, deben in­tro­du­cir un término o términos de búsqueda en una línea de texto. Dicho término recibe el nombre de query (consulta) en el contexto de Apache Lucene. Esta entrada no solo debe estar formada por una palabra o conjunto de ellas, sino que también puede contener comodines y ope­ra­do­res boleanos como AND, OR o + y -, entre otros. El de­no­mi­na­do Que­r­y­Pa­r­ser, una clase dentro de la bi­blio­te­ca del programa, traduce la entrada en una solicitud de búsqueda concreta para el motor de búsqueda. Los de­sa­rro­lla­do­res también pueden co­n­fi­gu­rar el Que­r­y­Pa­r­ser de modo que se adapte exac­ta­me­n­te a las ne­ce­si­da­des del usuario.

Lo que ca­ra­c­te­ri­zó al la­n­za­mie­n­to de Lucene fue la in­de­xa­ción in­cre­me­n­tal. Antes de este programa solo era posible la in­de­xa­ción por bloques, que permitía indexar úni­ca­me­n­te índices completos. No obstante, con la in­de­xa­ción in­cre­me­n­tal es posible ac­tua­li­zar un índice, de modo que se pueden añadir o eliminar entradas in­di­vi­dua­les.

Imagen: Representación esquemática de los procesos dentro de Apache Lucene
En Lucene el índice ocupa el lugar central.

¿Apache Lucene vs. Google y cía.?

La pregunta parece lógica: ¿para qué crear tu propio motor de búsqueda cuando ya hay otros como Google o Bing di­s­po­ni­bles? Por supuesto, esta pregunta no tiene fácil respuesta y, en de­fi­ni­ti­va, depende de la apli­ca­ción que cada usuario quiera hacer de un motor. Pero una cosa hay que tenerla clara: cuando hablamos de Lucene como motor de búsqueda, se está haciendo uso solo de una de­no­mi­na­ción si­m­pli­fi­ca­da.

De hecho, Apache Lucene es una bi­blio­te­ca de re­cu­pe­ra­ción de in­fo­r­ma­ción. Lucene es, por lo tanto, un sistema con el que se puede encontrar in­fo­r­ma­ción. También lo son Google y otros motores de búsqueda, si bien estos se limitan a la in­fo­r­ma­ción en Internet. Lucene se puede usar en cualquier escenario y es posible co­n­fi­gu­rar­lo para que se adapte a las ne­ce­si­da­des de cada usuario, por ejemplo, al in­te­grar­lo en otras apli­ca­cio­nes.

En resumen

Apache Lucene no es, al contrario que los bu­s­ca­do­res web, un software listo para usar: para obtener un beneficio de las opciones del sistema, primero es necesario programar el propio buscador. En nuestro tutorial de Lucene te mo­s­tra­re­mos los primeros pasos.

Lucene, Solr y Ela­s­ti­c­sea­r­ch ¿en qué se di­fe­re­n­cian?

Sobre todo los menos expertos suelen pre­gu­n­tar­se cuáles son las di­fe­re­n­cias entre Apache Lucene, Apache Solr y Ela­s­ti­c­sea­r­ch. Los dos últimos se basan en Lucene: el producto original es un motor de búsqueda. Solr y Ela­s­ti­c­sea­r­ch se presentan como se­r­vi­do­res de búsqueda completos que amplían aún más el alcance de Lucene.

Nota

Si úni­ca­me­n­te necesitas una función de búsqueda para tu sitio web, es mejor recurrir a Solr o Ela­s­ti­c­sea­r­ch, pues estos sistemas están es­pe­cí­fi­ca­me­n­te diseñados para su apli­ca­ción en la web.

Apache Lucene: tutorial de in­s­ta­la­ción y co­n­fi­gu­ra­ción

En la versión original, Lucene está basado en Java, lo que permite utilizar el motor de búsqueda para di­fe­re­n­tes pla­ta­fo­r­mas online y offline siempre que sepas cómo hacerlo. A co­n­ti­nua­ción, te ex­pli­ca­mos cómo crear paso a paso tu propio motor de búsqueda con Apache Lucene.

Nota

Este tutorial utiliza Lucene basado en Java. El código se probó en la versión 7.3.1 de Lucene y la versión 8 de JDK. Se trabaja con Eclipse en Ubuntu. Cada uno de estos pasos puede cambiar si se utilizan otros entornos de de­sa­rro­llo o sistemas ope­ra­ti­vos di­fe­re­n­tes.

In­s­ta­la­ción

Para poder trabajar con Apache Lucene, has de tener Java instalado en tu sistema. Al igual que Lucene, es posible descargar el software Java De­ve­lo­p­me­nt Kit (JDK) de forma gratuita desde la página web oficial de Oracle. También debes instalar un entorno de de­sa­rro­llo que te permita trabajar con el código de Lucene. Muchos de­sa­rro­lla­do­res utilizan Eclipse, si bien hay otras ofertas di­s­po­ni­bles de código abierto. Fi­na­l­me­n­te puedes descargar Lucene de la página del proyecto. Elige la versión principal del programa.

Con todo, no es necesario que instales Lucene, basta con abrir el archivo de­s­ca­r­ga­do en la ubicación deseada. A co­n­ti­nua­ción, crea un nuevo proyecto en Eclipse o en otro entorno de de­sa­rro­llo y añade Lucene como bi­blio­te­ca. Para este ejemplo, uti­li­za­mos tres bi­blio­te­cas, todas ellas incluidas en el paquete de in­s­ta­la­ción:

  • …/lucene-7.3.1/core/lucene-core-7.3.1.jar
  • …/lucene-7.3.1/que­r­y­pa­r­ser/lucene-que­r­y­pa­r­ser-7.3.1.jar
  • …/lucene-7.3.1/analysis/common/lucene-analyzers-common-7.3.1.jar

Si estás uti­li­za­n­do una versión diferente o has mo­di­fi­ca­do la es­tru­c­tu­ra de los di­re­c­to­rios, debes adaptar la in­fo­r­ma­ción en co­n­se­cue­n­cia.

Imagen: Agrega las bibliotecas en Eclipse
Añade a tu proyecto las bi­blio­te­cas que necesites.
Consejo

Si careces de los co­no­ci­mie­n­tos básicos de Java y de pro­gra­ma­ción en general, los si­guie­n­tes pasos pueden re­su­l­tar­te difíciles. Sin embargo, si ya cuentas con ex­pe­rie­n­cia en este lenguaje de pro­gra­ma­ción, trabajar con Lucene es una buena forma de de­sa­rro­llar tus ha­bi­li­da­des.

In­de­xa­ción

El núcleo de un motor de búsqueda basado en Lucene es el índice. Sin un índice no se puede ofrecer una función de búsqueda. Es por eso que el primer paso es crear una clase en Java para la in­de­xa­ción.

Pero antes de construir el mecanismo de in­de­xa­ción real, creamos dos clases que pueden servir de ayuda con el resto, pues po­s­te­rio­r­me­n­te tanto la clase de índice como la clase de búsqueda recurren a ellas.

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;
}

Estos datos serán im­po­r­ta­n­tes más adelante cuando se trate de definir los campos con exactitud.

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");
    }
}

Con ello se im­ple­me­n­ta un filtro que lee los do­cu­me­n­tos co­rre­c­ta­me­n­te. Ya aquí se puede ver que este motor de búsqueda solo va a funcionar con los archivos txt. Este ejemplo ignorará el resto de formatos.

Imagen: Archivos de texto a modo de corpus de búsqueda para Apache Lucene
En este ejemplo, se utilizan archivos de texto simples como corpus para la búsqueda con Lucene.
Nota

Para empezar con una clase, importa primero otras clases, que bien forman ya parte de la in­s­ta­la­ción de Java o están di­s­po­ni­bles a través de la in­te­gra­ción de bi­blio­te­cas externas.

Es ahora cuando puedes crear la clase real para la in­de­xa­ción.

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();
    }
}

En el tra­n­s­cu­r­so del código se ejecutan varios pasos: el In­de­x­W­ri­ter se configura con el Sta­n­da­r­dA­na­l­y­zer. Lucene ofrece di­fe­re­n­tes clases para análisis, todas ellas se en­cue­n­tran en la bi­blio­te­ca co­rre­s­po­n­die­n­te.

Consejo

En la do­cu­me­n­ta­ción de Apache Lucene puedes encontrar todas las clases que se incluyen en la descarga.

Además, el programa lee los archivos y establece los campos para la in­de­xa­ción. Al final del código, se crean los archivos de índice.

Imagen: Archivos de índice de Apache Lucene
Lucene crea varios archivos de índice a partir de los do­cu­me­n­tos de origen.

Función de búsqueda

Claro está que el índice por sí solo no sirve de nada. Es por eso que también es necesario es­ta­ble­cer una función de búsqueda.

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);	
   }
}

En el código hay dos clases im­po­r­ta­das por Lucene que cuentan con una im­po­r­ta­n­cia pa­r­ti­cu­lar: In­de­x­Sea­r­cher y Que­r­y­Pa­r­ser. Mientras la primera realiza la búsqueda en el índice, Que­r­y­Pa­r­ser es re­s­po­n­sa­ble de tra­n­s­fo­r­mar la consulta de búsqueda a un tipo de in­fo­r­ma­ción que la máquina pueda entender.

Es ahora cuando dispones tanto de una clase para indexar como de otra clase para realizar búsquedas en el índice, pero todavía no puedes realizar una consulta es­pe­cí­fi­ca con ninguna de ellas. Por esto motivo requieres una quinta clase.

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));
      }  
   }
}

En estas clases finales has de adaptar al menos tres entradas, ya que aquí se es­pe­ci­fi­can las rutas que llevan a los do­cu­me­n­tos ori­gi­na­les y a los archivos de índice y se indica la palabra o palabras de búsqueda.

  • String indexDir: aquí se inserta la ruta al di­re­c­to­rio donde se desean almacenar los archivos de índice.
  • String dataDir: el código fuente exige la ruta al di­re­c­to­rio en el que se almacenan los do­cu­me­n­tos a buscar.
  • tester.search: introduce el término de búsqueda.

Dado que en los tres casos se trata de una cadena de ca­ra­c­te­res (strings), las ex­pre­sio­nes han de incluirse entre comillas. Para indicar las rutas se usan barras oblicuas normales en lugar de barras inversas, también en Windows.

Para testar el programa, copia algunos archivos de texto plano en el di­re­c­to­rio es­ta­ble­ci­do como dataDir. Tienes que ase­gu­rar­te de que los archivos se­le­c­cio­na­dos tienen la extensión ".txt". A co­n­ti­nua­ción inicia el programa: en Eclipse, por ejemplo, clica en el botón con la flecha verde en la barra de menú.

Nota

El código de programa pre­se­n­ta­do es solo una demo del fu­n­cio­na­mie­n­to de Lucene. Por ejemplo, en este programa falta una interfaz gráfica de usuario: has de in­tro­du­cir el término de búsqueda di­re­c­ta­me­n­te en el código fuente y solo puedes obtener el resultado a través de la consola.

Imagen: Vista del código fuente en Eclipse y resultado de una consulta de búsqueda de Lucene en la consola
Eclipse re­pre­se­n­ta el resultado de la búsqueda en la consola.

Sintaxis de las consultas en Lucene

La mayoría de los motores de búsqueda, también los más conocidos de la web, no solo se limitan a la búsqueda de un solo término. Con de­te­r­mi­na­dos métodos es posible encadenar términos, buscar frases o excluir palabras concretas. Apache Lucene también ofrece estas po­si­bi­li­da­des: Lucene Query Syntax permite buscar ex­pre­sio­nes complejas, incluso en di­fe­re­n­tes campos.

  • Un solo término: se introduce sin más mo­di­fi­ca­cio­nes. A di­fe­re­n­cia de Google, Lucene asume que el término in­tro­du­ci­do está escrito co­rre­c­ta­me­n­te, por lo que si el usuario introduce un error or­to­grá­fi­co, obtendrá un resultado negativo. Ejemplo: “Coche”.
  • Frase: las frases son se­cue­n­cias de palabras es­ta­ble­ci­das. En este caso, no solo son im­po­r­ta­n­tes los términos in­di­vi­dua­les in­tro­du­ci­dos, sino también el orden en que aparecen. Ejemplo: "Mi coche es rojo".
  • Consulta con comodines: en la consulta puedes re­em­pla­zar uno o más ca­ra­c­te­res con di­fe­re­n­tes ma­r­ca­do­res de posición. Los ca­ra­c­te­res comodines pueden usarse tanto al final como en la mitad de un término, pero nunca al principio.
    • ?: El signo de in­te­rro­ga­ción re­pre­se­n­ta un carácter. Ejemplo: co?he.
    • *: El asterisco sustituye a un número infinito de ca­ra­c­te­res. Por ejemplo, puedes buscar otras formas de un término, como el plural. Ejemplo: Coche*.
  • Consulta de ex­pre­sio­nes regulares: con las ex­pre­sio­nes regulares puedes buscar al mismo tiempo varios términos que comparten una serie de si­mi­li­tu­des. A di­fe­re­n­cia de los comodines, con estos ma­r­ca­do­res se definen exac­ta­me­n­te las di­ve­r­ge­n­cias que hay tener en cuenta. Para ello, se recurre a las barras oblicuas y a los corchetes. Ejemplo: /[mp]adre/.
  • Consulta fuzzy searches: este tipo de consulta se utiliza cuando se quiere tener to­le­ra­n­cia a errores. Se utiliza la distancia de Damerau-Le­ve­n­sh­tein, fórmula que evalúa las si­mi­li­tu­des, para es­ta­ble­cer cómo de grande puede ser la de­s­via­ción. Usa la vi­r­gu­li­lla para indicarlo. Se admiten di­s­ta­n­cias de 0 a 2. Ejemplo: Coche~1.
  • Búsquedas de pro­xi­mi­dad: cuando quieras permitir una apro­xi­ma­ción en las frases, utiliza también la vi­r­gu­li­lla. Por ejemplo, puedes es­pe­ci­fi­car que deseas buscar dos términos incluso si hay otras 5 palabras entre ellos. Ejemplo: "Auto rojo"~5.
  • Búsquedas por rango: en este tipo de consulta se busca entre dos términos en un área concreta. Si bien esta búsqueda no tiene mucho sentido para contenido general, puede ser muy útil para consultar ciertos campos, como los autores o los títulos. La cla­si­fi­ca­ción funciona de acuerdo con un orden le­xi­co­grá­fi­co. Se recurre a los corchetes para indicar un área de inclusión y a las llaves para indicar un área de exclusión, en ambos casos de­te­r­mi­na­das por los dos términos indicados en la búsqueda. Estos términos están de­li­mi­ta­dos con “TO” (a, hacia). Ejemplo: [Allende TO Borges] o {Byron TO Shelley}
  • Boosting: Lucene brinda la opo­r­tu­ni­dad de dar más re­le­va­n­cia en la búsqueda a de­te­r­mi­na­dos términos o frases, lo que influye en la cla­si­fi­ca­ción de los re­su­l­ta­dos. Para indicar este parámetro de búsqueda se utiliza el acento ci­r­cu­n­fle­jo seguido del valor al que se le quiera dar más re­le­va­n­cia. Ejemplo: Coche^2 rojo.
  • Ope­ra­do­res booleanos: los ope­ra­do­res lógicos sirven para es­ta­ble­cer co­ne­xio­nes entre términos en una consulta. Los ope­ra­do­res han de estar siempre escritos en ma­yú­s­cu­las para que Lucene no los considere términos de búsqueda normales.
    • AND: con AND, ambos términos deben estar presentes en el documento para que este se muestre como resultado. En lugar del término AND se puede usar también dos signos et (&&). Ejemplo: Coche && rojo.
    • OR: con OR, situado entre dos términos de búsqueda, se indica que para que se muestre un documento como resultado al menos uno de los términos indicados ha de aparecer en él. Además de OR, se puede usar||, si bien también es posible no in­tro­du­cir operador alguno. Al fin y al cabo, la consulta con OR es una búsqueda estándar formada por dos o más términos. Ejemplo: Coche rojo.
    • +: el signo más se utiliza para es­ta­ble­cer un caso es­pe­cí­fi­co de conector OR. Si colocas el símbolo di­re­c­ta­me­n­te delante de una palabra, se establece que dicho término debe aparecer, mientras que el otro es opcional. Ejemplo: +Auto rojo
    • NOT: La aso­cia­ción con NOT excluye ciertos términos o frases de la búsqueda. También puedes recurrir a un signo de ex­cla­ma­ción o emplazar un signo menos justo antes del término que desea excluir. No debes utilizar el operador NOT con un solo término o frase. Ejemplo: Auto rojo – azul
  • Grouping: Utiliza los pa­ré­n­te­sis para agrupar términos dentro de una consulta. Es de gran utilidad para crear entradas más complejas, por ejemplo, para vincular un término con otros dos que se rijan por un criterio de búsqueda diferente: Auto AND (rojo OR azul).
  • Escaping Special Cha­ra­c­te­rs: para utilizar como términos de búsqueda aquellos ca­ra­c­te­res que se emplean en la sintaxis de Lucene, co­m­bí­na­los mediante barra invertida. Así, puedes insertar, por ejemplo, un signo de in­te­rro­ga­ción en una consulta de búsqueda sin que el ana­li­za­dor lo in­te­r­pre­te como un comodín: "¿Dónde está mi coche\?".

Apache Lucene: ventajas y de­s­ve­n­ta­jas

Lucene es una potente he­rra­mie­n­ta para co­n­fi­gu­rar una función de búsqueda en la web, en archivos o en apli­ca­cio­nes. Los se­gui­do­res de Lucene prefieren utilizar el programa para crear mediante in­de­xa­ción motores de búsqueda de gran velocidad, que además pueden adaptarse a sus ne­ce­si­da­des. Al ser un proyecto de código abierto, Lucene no solo está di­s­po­ni­ble de forma gratuita, sino que también dispone de una gran comunidad que lo de­sa­rro­lla sin pausa.

Puedes usarlo en Java, pero también en PHP, Python y otros lenguajes de pro­gra­ma­ción. De ello se deduce una única de­s­ve­n­ta­ja: es necesario contar con co­no­ci­mie­n­tos en pro­gra­ma­ción. Es por eso que Apache Lucene no es apto para todos. Si solo necesitas una función de búsqueda para tu web, po­si­ble­me­n­te prefieras optar por otras ofertas.

Ventajas De­s­ve­n­ta­jas
Di­s­po­ni­ble para di­fe­re­n­tes lenguajes de pro­gra­ma­ción Requiere co­no­ci­mie­n­tos en pro­gra­ma­ción
Código abierto
Rápido y ligero
Búsqueda cla­si­fi­ca­da
Po­si­bi­li­dad de búsquedas complejas
Muy flexible
Ir al menú principal