Después de unos días de trabajo intenso, finalmente implementé una búsqueda simple de texto completo. Permítanme revisar y resumir
este artículo. ¿Qué es Lucene.Net? ¿Qué puede hacer Lucene.Net? ¿Y la pregunta de cómo hacerlo? Finalmente, se proporciona un ejemplo de Lucene.Net que implementa la búsqueda de texto completo.
1. ¿Qué es Lucene.Net?
Lucene.net fue originalmente un proyecto de código abierto y luego se lanzó a la comercialización. Lucene.net 2.0 también se lanzó, pero por dinero D. El destino de Lucene.net es algo similar al de FreeTextBox, que comenzó con 2.0 lanzado después de la versión 1.6. 5. Ruta comercial, 2.0 proporciona una versión gratuita en forma de DLL, y la versión del código fuente debe comprar una licencia comercial; sin embargo, deja el código fuente de la versión 1.6.5 y aún puede ver la mayoría de los detalles internos; , pero en la versión 2.0 el soporte agregado para el navegador Mozilla solo es visible a través de los scripts HTML y JavaScript que genera.
Lucene es una API de indexación comúnmente utilizada en el mundo Java. Utilizando los métodos que proporciona, puede crear índices para materiales de texto y proporcionar recuperación. (Referencia: NLucene y Lucene .NET) NLucene es el primer port .net y una versión estilo .net que utiliza convenciones de nomenclatura y diseño de biblioteca de clases .net. Sin embargo, por motivos energéticos, el líder del proyecto NLucene sólo lanzó la versión 1.2beta. Después de que surgió el proyecto Lucene.NET, no había nuevos planes para NLucene.
Lucene.NET originalmente afirmó ser un trasplante de .net Lucene actualizado. Solo adoptó las sugerencias de .net en términos de nombres. Su objetivo principal tendía a ser compatible con Java Lucene: uno era hacer que el formato de índice fuera compatible. podrían trabajar juntos. El propósito es que los nombres sean similares (con solo algunas diferencias, como mayúsculas y minúsculas, etc.), y el propósito es facilitar a los desarrolladores el uso de código e información relacionados con Java Lucene.
No sé cuándo el proyecto Lucene.NET abandonó su plan de código abierto y se dedicó al negocio. De hecho, eliminó los archivos de código abierto en SourceForge. Al mismo tiempo, el proyecto dotLucene apareció en SourceForge En protesta contra Lucene.NET, dotLucene casi puso el código de Lucene.NET intacto como punto de partida. ( https://sourceforge.net/forum/forum.php?thread_id=1153933&forum_id=408004 ).
Para decirlo sin rodeos, Lucene.Net es una biblioteca de funciones de recuperación de información (Biblioteca). Puede usarla para agregar funciones de indexación y búsqueda a su aplicación.
Los usuarios de Lucene no necesitan tener un conocimiento profundo sobre la recuperación de texto completo. Solo aprenda a usar la biblioteca si sabe cómo llamar a las funciones en la Biblioteca, puede implementar la función de búsqueda de texto completo para su aplicación,
pero no espere que Lucene sea un motor de búsqueda como Google y Baidu. una herramienta, una biblioteca. También puede considerarla como una API simple y fácil de usar que encapsula funciones de indexación y búsqueda. Puede hacer muchas cosas relacionadas con la búsqueda con esta API, y es muy conveniente. Satisfacer sus necesidades. Una aplicación realiza una búsqueda simple de texto completo. Como desarrollador de aplicaciones (desarrollador de motores de búsqueda no profesional), sus funciones son suficientes para satisfacer sus necesidades.
2. ¿Qué puede hacer Lucene.Net?
Lucene puede indexar y buscar cualquier dato, independientemente del formato de la fuente de datos, siempre que se pueda convertir a texto, Lucene puede analizarlo y utilizarlo. En otras palabras, ya sea MS Word, HTML, PDF o. other Lucene puede utilizar cualquier formato de archivo siempre que pueda extraer contenido de texto. Puede utilizar Lucene para indexarlos y buscarlos.
3. ¿Cómo utilizar Lucene.Net?
Simplemente se reduce a: crear un índice y usar un índice. Crear un índice es almacenar o analizar la información de la fuente de datos a buscar como nuestra información clave, y dejar una marca para la búsqueda es como crear una tabla de. Contenido en Word (comprensión personal), usar el índice es analizar la fuente de datos en función de la información del índice durante la búsqueda y extraer la información que necesitamos.
Mire el ejemplo:
clase pública IntranetIndexer
para crear un índice
{
/**/////Escritor de índice
escritor privado IndexWriter
// El directorio raíz del archivo que se escribirá en el índice;
cadena privada docRootDirectory
//Formato de archivo que coincida
patrón de cadena privada []
/**//// <resumen>
/// Inicializar un escritor de índice. El directorio es el directorio donde se crea el índice. verdadero significa que si el archivo de índice no existe, el archivo de índice se volverá a crear. Si el archivo de índice ya existe, se creará el archivo de índice. sobrescrito.
/// </summary>
/// <param name="directory">Se pasa el directorio que se va a indexar. Tenga en cuenta que es un valor de cadena. Si el directorio no existe, se creará automáticamente</param>.
publicIntranetIndexer (directorio de cadenas)
{
escritor = nuevo IndexWriter(directorio, nuevo StandardAnalyzer(), verdadero);
escritor.SetUseCompoundFile(verdadero);
}
AddDirectory público vacío (directorio DirectoryInfo, patrón de cadena [])
{
this.docRootDirectory = directorio.FullName;
this.pattern = patrón;
addSubDirectory(directorio);
}
addSubDirectory vacío privado (directorio DirectoryInfo)
{
for(int i=0;i<patrón.Longitud;i++)
{
foreach (FileInfo fi en el directorio.GetFiles(patrón[i]))
{
AddHtmlDocument(fi.NombreCompleto);
}
}
foreach (DirectoryInfo di en directorio.GetDirectories())
{
agregarSubDirectorio(di);
}
}
AddHtmlDocument público vacío (ruta de cadena)
{
cadena exname=Path.GetExtension (ruta);
Documento doc = nuevo documento();
cadena html;
if(exnombre.ToLower ()==".html" ||exnombre .ToLower ()==".htm"||exnombre .ToLower ()==".txt")
{
usando (StreamReader sr = nuevo StreamReader (ruta, Sistema. Texto. Codificación. Predeterminado))
{
html = sr.ReadToEnd();
}
}
demás
{
usando (StreamReader sr = nuevo StreamReader (ruta, System.Text.Encoding.Unicode))
{
html = sr.ReadToEnd();
}
}
int relatedPathStartsAt = this.docRootDirectory.EndsWith("\") ? this.docRootDirectory.Length: this.docRootDirectory.Length + 1;
cadena relativaPath = ruta.Substring(relativePathStartsAt);
título de cadena = Ruta.GetFileName (ruta);
//Determina si es una página web, elimina la etiqueta, de lo contrario no la uses
if(exnombre.ToLower ()==".html" ||exnombre .ToLower ()==".htm")
{
doc.Add(Field.UnStored("texto", parseHtml(html)));
}
demás
{
doc.Add (campo .UnStored ("texto",html));
}
doc.Add(Field.Keyword("ruta", ruta relativa));
//doc.Add(Field.Text("título", getTitle(html)));
doc.Add (Campo .Texto ("título",título));
escritor.AddDocument(doc);
}
/**//// <resumen>
/// Eliminar etiquetas de páginas web
/// </summary>
/// <param name="html">Página web</param>
/// <returns>Devuelve el texto de la página web eliminada</returns>
parseHtml de cadena privada (cadena html)
{
temperatura de cadena = Regex.Replace(html, "<[^>]*>", "");
return temp.Replace(" ", " ");
}
/**//// <resumen>
/// Obtener el título de la página
/// </summary>
/// <param nombre="html"></param>
/// <devoluciones></devoluciones>
cadena privada getTitle (cadena html)
{
Coincidencia m = Regex.Match(html, "<título>(.*)</título>");
si (m.Grupos.Count == 2)
devolver m.Grupos[1].Valor;
devolver "Título del documento desconocido";
}
/**//// <resumen>
/// Optimizar el índice y cerrar el escritor
/// </summary>
cierre público vacío()
{
escritor.Optimize();
escritor.Close();
}
}
Primero cree un objeto Documento y luego agregue algunos atributos Campo al objeto Documento. Puede considerar el objeto Documento como un archivo virtual, del cual se obtendrá información en el futuro. El campo se considera como metadatos que describen este archivo virtual. Entre ellos, el campo incluye cuatro tipos: Trabajo clave
Los datos de este tipo no se analizarán, pero se indexarán y guardarán en el índice.
Sin indexar
Los datos de este tipo no serán analizados ni indexados, sino que quedarán almacenados en el índice.
Sin almacenar
Todo lo contrario de UnIndexed, se analiza e indexa, pero no se guarda.
Texto
Similar a UnStored. Si el tipo de valor es una cadena, se guardará. Si el tipo de valor es Reader, no se guardará, al igual que UnStored.
Finalmente, cada Documento se agrega al índice.
La siguiente es una búsqueda del índice.
//Crear un indexador
Buscador IndexSearcher = nuevo IndexSearcher(indexDirectory);
//Analiza el campo de texto del índice para la búsqueda
Consulta de consulta = QueryParser.Parse(this.Q, "texto", nuevo StandardAnalyzer());
//Pon los resultados de la búsqueda en resultados
Visitas visitas = buscador.Buscar(consulta);
//Estadísticas sobre el número total de registros buscados
this.total = hits.Longitud();
//Destacar
Resaltador de QueryHighlightExtractor = nuevo QueryHighlightExtractor(consulta, nuevo StandardAnalyzer(), "<font color=red>", "</font>");
El primer paso es usar IndexSearcher para abrir el archivo de índice para búsquedas posteriores, y el parámetro es la ruta del archivo de índice.
El segundo paso es usar QueryParser para convertir declaraciones de consulta más legibles (como la palabra de consulta lucene y algunas). métodos avanzados lucene AND. net) en un objeto de consulta utilizado internamente por Lucene.
El tercer paso realiza la búsqueda y devuelve los resultados a la colección de visitas. Cabe señalar que Lucene no coloca todos los resultados en visitas a la vez, sino que los coloca. parte a la vez Por consideraciones de espacio,
los resultados de la búsqueda se procesan y se muestran en la página:
for (int i = startAt; i < resultsCount; i++)
{
Documento doc = hits.Doc(i);
ruta de cadena = doc.Get("ruta");
ubicación de cadena =Server.MapPath("documentos")+" \"+ruta ;
cadena exname=Path.GetExtension (ruta);
cadena de texto sin formato;
cadena str=doc.Get ("título");
if(exnombre==".html" || exnombre ==".htm" || exnombre ==".txt")
{
usando (StreamReader sr = nuevo StreamReader (ubicación, System.Text.Encoding.Default))
{
texto plano = parseHtml(sr.ReadToEnd());
}
}
demás
{
usando (StreamReader sr = nuevo StreamReader (ubicación, System.Text.Encoding.Unicode))
{
texto plano = sr.ReadToEnd();
}
}
//Tabla de datos agrega filas
Fila DataRow = this.Results.NewRow();
fila["título"] = doc.Get("título");
string IP=Request.Url.Host;//Obtener la IP del servidor
//Solicitud.Url.Puerto;
fila["ruta"]=@" http://"+IP+"/WebUI/Search/documents/"+ruta ;
fila["muestra"] = resaltador.GetBestFragments(plainText, 80, 2, "");
this.Results.Rows.Add(fila);
}
searcher.Close();//Cierre el buscador. Si desea tener una comprensión más avanzada, completa y profunda de Lucene.Net, consulte el sitio web:
http: //blog.tianyacn/blogger/view_blog.asp?BlogName=aftaft.