Phenquestions
¿Por qué se necesita Lucene??
La búsqueda es una de las operaciones más comunes que realizamos varias veces al día. Esta búsqueda puede realizarse en varias páginas web que existen en la Web o una aplicación de música o un repositorio de código o una combinación de todos estos. Uno podría pensar que una base de datos relacional simple también puede apoyar la búsqueda. Esto es correcto. Las bases de datos como MySQL admiten la búsqueda de texto completo. Pero, ¿qué pasa con la Web o una aplicación de música o un repositorio de código o una combinación de todos estos? La base de datos no puede almacenar estos datos en sus columnas. Incluso si lo hiciera, tomará una cantidad de tiempo inaceptable para ejecutar la búsqueda tan grande.
Un motor de búsqueda de texto completo es capaz de ejecutar una consulta de búsqueda en millones de archivos a la vez. La velocidad a la que se almacenan los datos en una aplicación hoy en día es enorme. Ejecutar la búsqueda de texto completo en este tipo de volumen de datos es una tarea difícil. Esto se debe a que la información que necesitamos puede existir en un solo archivo de entre miles de millones de archivos guardados en la web.
Cómo funciona Lucene?
La pregunta obvia que debería venir a su mente es, ¿cómo es Lucene tan rápido en la ejecución de consultas de búsqueda de texto completo?? La respuesta a esto, por supuesto, es con la ayuda de los índices que crea. Pero en lugar de crear un índice clásico, Lucene hace uso de Índices invertidos.
En un índice clásico, para cada documento, recopilamos la lista completa de palabras o términos que contiene el documento. En un índice invertido, para cada palabra en todos los documentos, almacenamos en qué documento y posición se puede encontrar esta palabra / término. Este es un algoritmo de alto estándar que facilita la búsqueda. Considere el siguiente ejemplo de creación de un índice clásico:
Doc1 -> "Esto", "es", "simple", "Lucene", "muestra", "clásico", "invertido", "índice"Doc2 -> "En ejecución", "Elasticsearch", "Ubuntu", "Actualización"
Doc3 -> "RabbitMQ", "Lucene", "Kafka", "", "Spring", "Boot"
Si usamos índice invertido, tendremos índices como:
Esto -> (2, 71)Lucene -> (1, 9), (12,87)
Apache -> (12, 91)
Marco -> (32, 11)
Los índices invertidos son mucho más fáciles de mantener. Supongamos que si queremos encontrar Apache en mis términos, tendré respuestas inmediatas con índices invertidos, mientras que con la búsqueda clásica se ejecutará en documentos completos que podrían no haber sido posibles de ejecutar en escenarios en tiempo real.
Flujo de trabajo de Lucene
Antes de que Lucene pueda buscar realmente los datos, debe realizar los pasos. Visualicemos estos pasos para una mejor comprensión:
Flujo de trabajo de Lucene
Como se muestra en el diagrama, esto es lo que sucede en Lucene:
- Lucene se alimenta de los documentos y otras fuentes de datos
- Para cada documento, Lucene primero convierte estos datos en texto sin formato y luego los analizadores convierten esta fuente en texto sin formato
- Para cada término del texto sin formato, se crean los índices invertidos
- Los índices están listos para ser buscados
Con este flujo de trabajo, Lucene es un motor de búsqueda de texto completo muy potente. Pero esta es la única parte que Lucene cumple. Necesitamos realizar el trabajo nosotros mismos. Veamos los componentes necesarios de la indexación.
Componentes de Lucene
En esta sección, describiremos los componentes básicos y las clases básicas de Lucene utilizadas para crear índices:
- Directorios: Un índice de Lucene almacena datos en directorios del sistema de archivos normales o en la memoria si necesita más rendimiento. Es completamente la elección de las aplicaciones para almacenar datos donde quiera, una base de datos, la RAM o el disco.
- Documentos: Los datos que alimentamos al motor Lucene deben convertirse a texto sin formato. Para hacer esto, creamos un objeto Documento que representa esa fuente de datos. Más tarde, cuando ejecutamos una consulta de búsqueda, como resultado, obtendremos una lista de objetos Documento que satisfacen la consulta que pasamos.
- Campos: Los documentos se completan con una colección de campos. Un campo es simplemente un par de (nombre, valor) artículos. Entonces, al crear un nuevo objeto de documento, debemos llenarlo con ese tipo de datos emparejados. Cuando un campo se indexa de forma inversa, el valor del campo se convierte en token y está disponible para la búsqueda. Ahora, mientras usamos Fields, no es importante almacenar el par real sino solo el indexado invertido. De esta manera, podemos decidir qué datos solo se pueden buscar y no es importante guardarlos. Veamos un ejemplo aquí:
Indexación de campo
En la tabla anterior, decidimos almacenar algunos campos y otros no se almacenan. El campo del cuerpo no se almacena sino que se indexa. Esto significa que el correo electrónico se devolverá como resultado cuando se ejecute la consulta de uno de los Términos para el contenido del cuerpo.
- Condiciones: Los términos representan una palabra del texto. Los términos se extraen del análisis y la tokenización de los valores de Fields, por lo que El término es la unidad más pequeña en la que se ejecuta la búsqueda.
- Analizadores: Un analizador es la parte más importante del proceso de indexación y búsqueda. Es el Analizador el que convierte el texto sin formato en Tokens y Términos para que puedan ser buscados. Bueno, esa no es la única responsabilidad de un analizador. Un analizador usa un Tokenizer para hacer tokens. Un analizador también realiza las siguientes tareas:
- Stemming: un analizador convierte la palabra en un Stem. Esto significa que 'flores' se convierte en la palabra del tallo 'flor'. Entonces, cuando se ejecuta una búsqueda de 'flor', se devolverá el documento.
- Filtrado: un analizador también filtra las palabras vacías como 'El', 'es', etc. ya que estas palabras no atraen consultas para su ejecución y no son productivas.
- Normalización: este proceso elimina los acentos y otras marcas de caracteres.
Esta es solo la responsabilidad normal de StandardAnalyzer.
Aplicación de ejemplo
Usaremos uno de los muchos arquetipos de Maven para crear un proyecto de muestra para nuestro ejemplo. Para crear el proyecto, ejecute el siguiente comando en un directorio que usará como espacio de trabajo:
arquetipo mvn: generate -DgroupId = com.linuxhint.ejemplo -DartifactId = LH-LuceneExample -DarchetypeArtifactId = maven-archetype-quickstart -DinteractiveMode = falseSi está ejecutando maven por primera vez, llevará unos segundos completar el comando generate porque maven tiene que descargar todos los complementos y artefactos necesarios para realizar la tarea de generación. Así es como se ve el resultado del proyecto:
Configuración del proyecto
Una vez que haya creado el proyecto, no dude en abrirlo en su IDE favorito. El siguiente paso es agregar las dependencias de Maven apropiadas al proyecto. Aquí está el pom.xml archivo con las dependencias adecuadas:
Finalmente, para comprender todos los JAR que se agregan al proyecto cuando agregamos esta dependencia, podemos ejecutar un comando simple de Maven que nos permite ver un árbol de dependencias completo para un proyecto cuando le agregamos algunas dependencias. Aquí hay un comando que podemos usar:
dependencia de mvn: árbolCuando ejecutamos este comando, nos mostrará el siguiente árbol de dependencias:
Finalmente, creamos una clase SimpleIndexer que se ejecuta
importar java.io.Archivo;
importar java.io.FileReader;
importar java.io.IOException;
importar org.apache.lucene.análisis.Analizador;
importar org.apache.lucene.análisis.estándar.StandardAnalyzer;
importar org.apache.lucene.documento.Documento;
importar org.apache.lucene.documento.StoredField;
importar org.apache.lucene.documento.Campo de texto;
importar org.apache.lucene.índice.IndexWriter;
importar org.apache.lucene.índice.IndexWriterConfig;
importar org.apache.lucene.Tienda.FSDirectory;
importar org.apache.lucene.util.Versión;
public class SimpleIndexer
Cadena final estática privada indexDirectory = "/ Usuarios / shubham / en algún lugar / LH-LuceneExample / Index";
Cadena final estática privada dirToBeIndexed = "/ Usuarios / shubham / algún lugar / LH-LuceneExample / src / main / java / com / linuxhint / example";
public static void main (String [] args) arroja Exception
Archivo indexDir = nuevo archivo (indexDirectory);
Archivo dataDir = nuevo archivo (dirToBeIndexed);
Indexador SimpleIndexer = nuevo SimpleIndexer ();
int numIndexed = indexador.índice (indexDir, dataDir);
Sistema.fuera.println ("Total de archivos indexados" + numIndexed);
private int index (File indexDir, File dataDir) lanza IOException
Analizador analizador = nuevo StandardAnalyzer (Versión.LUCENE_46);
IndexWriterConfig config = new IndexWriterConfig (Versión.LUCENE_46,
analizador);
IndexWriter indexWriter = nuevo IndexWriter (FSDirectory.abierto (indexDir),
config);
Archivo [] archivos = dataDir.listFiles ();
para (Archivo f: archivos)
Sistema.fuera.println ("Archivo de indexación" + f.getCanonicalPath ());
Documento doc = nuevo documento ();
Doc.agregar (nuevo TextField ("contenido", nuevo FileReader (f)));
Doc.agregar (new StoredField ("fileName", f.getCanonicalPath ()));
indexWriter.addDocument (doc);
int numIndexed = indexWriter.maxDoc ();
indexWriter.cerca();
return numIndexed;
En este código, acabamos de crear una instancia de documento y agregamos un nuevo campo que representa el contenido del archivo. Aquí está el resultado que obtenemos cuando ejecutamos este archivo:
Archivo de indexación / Usuarios / shubham / algún lugar / LH-LuceneExample / src / main / java / com / linuxhint / example / SimpleIndexer.JavaTotal de archivos indexados 1
Además, se crea un nuevo directorio dentro del proyecto con el siguiente contenido:
Datos de índice
Analizaremos todos los archivos que se crean en este índice en más lecciones por venir en Lucene.
Conclusión
En esta lección, analizamos cómo funciona Apache Lucene y también creamos una aplicación de ejemplo simple que se basó en Maven y Java.
