Un ejemplo mas concreto de Lucene. Es solo copiar y pegar

Lucene: Un ejemplo

A continuación vamos a ver un sencillo ejemplo de indexación (LuceneCreateIndexApp.java) y consulta (LuceneSearchApp.java) sobre los archivos con extensión .txt de un directorio.

Indexación de información: LuceneCreateIndexApp.java

 

Codigo Fuente

package com.autentia.tutoriales.lucene;

import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;

import java.io.*;

/**
 * El siguiente ejemplo crea un índice a partir de todos los documentos con extensión .txt de un directorio c:/lucene_dir_to_index
  */
public class LuceneCreateIndexApp {

    /**
     * Punto de entrada a la aplicación
     */
    public static void main(String[] args)  {
      IndexWriter    writer   = null;
      File            dir         = new File("c:/lucene_dir_to_index");
      Document        doc         = null;
     
      try {
          // Creamos el indice si no existe almacenandolo en un directorio del HDD 
          writer = new IndexWriter(new File("c:/lucene_output_dir_index"), new StandardAnalyzer(), true);

          // Recorremos todos los archivos del directorio (No sus subdirectorios)
          File[] files = dir.listFiles();
          for (File file : files){
                if (file.isFile() && file.canRead() && file.getName().endsWith(".txt")) {
                    System.out.println("Indexando el archivo: " + file.getAbsolutePath());
               
                    // Cremos e inicializamos el Document con los datos del archivo que queremos guardar
                    doc = new Document();
                    doc.add(new Field("path",      file.getPath(), Field.Store.YES, Field.Index.UN_TOKENIZED));
                    doc.add(new Field("contents", new FileReader(file)));
                   
                    // Añadimos el documento al indice.
                    writer.addDocument(doc);
                }
          }         
         
          // Organizamos y guardamos los datos.
          writer.optimize();
          writer.close();
         
         
          System.out.println("OK");
      } catch (Exception ex){
         System.out.println(ex);
      }
    }
}

Fin de Codigo Fuente

 

 

Introducción a las clases más comunes durante el proceso de indexación.

• IndexWriter:

  Es el corazón del proceso de indexación. Encapsula el índice y contiene entre otras cosas cierta información de documentos que lo componen.
  

• Directory:

  Es una clase abstracta que representa la ubicación del índice: memoria RAM, archivo, etc. En el ejemplo se usa FSDirectory, que es la implementación de la clase para guardar el índice en un archivo.
  

• Analizer:

  Es una clase Abstracta cuya función es filtrar la información relevante con la cual se creará el índice y eliminar el resto. Por ejemplo, elimiminar las palabras cortas (stop word) o que aparecen con mucha frecuencia. Por ejemplo, eliminaría palabras (dependiendo del idioma) del tipo: en, la, los, etc.
  

• Document:

  Es una clase que almacena campos (Field) con la meta información que queremos indexar y/o guardar en el índice (emails, rutas, autor, fecha, etc.).
  

• Field:

  Son las fragmentos de información de cada documento que deseamos almacenar en el Document.
  
  Codigo Fuente
  

package com.autentia.tutoriales.lucene;

import org.apache.lucene.document.Document;
import org.apache.lucene.search.*;
import org.apache.lucene.store.*;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import java.io.File;

/**
 * El siguiente ejemplo realiza una búsqueda sobre el índice
  */
public class LuceneSearchApp {
    /**
     * Punto de entrada a la aplicación
     */
    public static void main(String[] args) {
        try {
            // Ubicación del índice
            FSDirectory        directory = FSDirectory.getDirectory(new File("c:/lucene_output_dir_index"));
           
            // Creamos un búscador
            IndexSearcher    searcher  = new IndexSearcher(directory);
           

            // Palaba a búscar dentro del índice aquellos documentos que contentan la palabra "Carlos" y no la palabra "Avanzado"
            String            textToSearch = "+Carlos -Avanzado";
           
            // Creamos la consulta
            QueryParser        parser      = new QueryParser("contents", new StandardAnalyzer());
            Query            query      = parser.parse(textToSearch);
           
            // Realizamos la búsqueda
            Hits            hits      = searcher.search(query);
            Document        doc          = null;
           
            // Mostramos los resultados
            if (hits.length() == 0){
                System.out.println("No se han encontrado coincidencias.");
            } else {
                for (int i = 0; i < hits.length(); i++) {
                    doc = hits.doc(i);
                    System.out.println(doc.get("path"));
                }
            }
        } catch (Exception ex){
            System.out.println(ex);
        }   
    }
}
   
Fin  Codigo fuente
     

Introducción a las clases más comunes durante el proceso de búsqueda.

• IndexSeacher:

  Es el corazón del proceso de búsqueda a través del cual se pueden realizar consultas (Query) que devuelven resultados (Hits).
  

• Term:

  Cuando querermos realizar una consulta definimos las condiciones de búsqueda a través de Term, es decir, una consulta es un conjunto de Term.
  

• Query:

  Es una clase abstracta que permite definir la consulta sobre la que queremos realizar la búsqueda. TermQuery, es una de las muchas implementaciones de Query y que nos permite búscar consultando los Field.
  

• Hits:

  Contiene los documentos (Document) que cumplen las condiciones de la búsqueda realiza.