Luceno è una libreria di motori di ricerca full-text .NET che contiene potenti API per la creazione di indici full-text e l'implementazione di tecnologie di ricerca avanzate e precise nei tuoi programmi. Lucene offre molto di più di quello che ti aspetteresti da altri motori di ricerca di testo in quanto le scelte offerte all'utente sono molteplici. Ha un potente algoritmo di ricerca e supporta un'ampia gamma di query per la ricerca.
Sebbene potente come Lucene da solo, non è privo di limitazioni. Lucene viene eseguito in-process nell'applicazione client e le applicazioni Lucene in genere scrivono dati su un file e li archiviano sul disco, determinando un'enorme allocazione di memoria. Tuttavia, è una soluzione autonoma che non si adatta alla crescita dei dati, è necessario ricostruire interi indici Lucene per cercare i dati, un'attività costosa e lenta, che può comportare un collo di bottiglia delle prestazioni. Ciò significa che Lucene non è scalabile e presenta un singolo punto di errore.
NCache Dettagli Scarica NCache NCache Docs
In che modo Lucene distribuita ti aiuta
NCache fornisce un'implementazione distribuita di Lucene che rende scalabili le applicazioni Lucene. NCache essendo distribuito in natura con Lucene fornisce una scalabilità di scrittura lineare poiché i documenti indicizzati dalle applicazioni vengono automaticamente distribuiti tra i nodi della cache dove vengono indicizzati separatamente.
Allo stesso modo, Distributed Lucene fornisce anche una scalabilità di lettura lineare poiché le query vengono propagate su ciascuna partizione ei risultati vengono uniti. Un numero maggiore di partizioni fornisce una maggiore quantità di scalabilità in lettura e scrittura. Gli indici Lucene vengono mantenuti sull'unità fisica. Maggiore è il numero di nodi, maggiore è la scalabilità, le prestazioni e la capacità di archiviazione per ospitare un gran numero di documenti Lucene e dati indicizzati.
NCache Dettagli Scaricare NCache Lucene Docs distribuito
Come funziona Lucene distribuita
Lucene distribuita contiene più nodi server, ogni server di NCache dispone di un modulo Lucene dedicato. I comportamenti e il funzionamento di Lucene e Distributed Lucene sono simili, a parte alcune modifiche.
Il diagramma seguente mostra come funziona il modello Distributed Lucene.
L'applicazione client potrebbe voler indicizzare documenti o interrogare documenti indicizzati esistenti utilizzando l'API Lucene. Queste interazioni con l'API agiscono come chiamate di procedura remota (RPC) tra il client e il server. Le chiamate API vengono inoltrate direttamente ai moduli Lucene collegati a ciascun nodo del server. I moduli Lucene eseguono queste chiamate e, a seconda della natura delle chiamate, viene eseguita una delle seguenti azioni:
- Nel caso si trattasse di una chiamata di query, i moduli Distributed Lucene restituiscono i risultati sul lato client, dove tutti questi risultati vengono uniti ed elaborati.
- Nel caso si trattasse di una chiamata per indicizzare un documento, i moduli Distributed Lucene mantengono quel documento su un'unità disco.
NCache Dettagli Lucene Docs distribuito Lucene Cache distribuita
Distribuzione dei dati
Viene generata una mappa di distribuzione rispetto a NCache cluster per Lucene distribuita. Questa mappa contiene informazioni sulla distribuzione del bucket rispetto ai nodi della cache. Questi bucket (nella mappa esistono 100 bucket) vengono distribuiti nel cluster utilizzando una strategia specifica. L'aggiunta o la rimozione di un nodo dal cluster cambierà la mappa di distribuzione e attiverà il trasferimento dello stato per i nodi del server in esecuzione, che trasferiscono i bucket con i dati indicizzati sul rispettivo nodo.
Avere 100 bucket significa che un indice Lucene è suddiviso in 100 sottoindici in tutto il NCache grappolo. Un singolo bucket contiene un sottoindice, che è lo stesso di un indice Lucene in Lucene.Net. Un nodo server può contenere più indici e ogni indice all'interno di quel nodo server contiene bucket che gli vengono assegnati in base alla strategia di distribuzione del cluster. I dati all'interno degli indici sono distribuiti uniformemente tramite questi bucket.
Come iniziare con Lucene distribuito
Distributed Lucene funziona esattamente come Lucene. Uno dei principali vantaggi dell'utilizzo di Lucene distribuito è che offre la stessa API di Luceno. Come utente Lucene, ottieni la scalabilità che desideri con un componente aggiuntivo di una modifica del codice a riga singola. Devi solo usare NCache Directory e la tua applicazione sono a posto. Ci sono pochissime modifiche comportamentali e API in Lucene distribuita elencate nel file documentazione.
Diamo un'occhiata più da vicino a questi passaggi da un aspetto tecnico e il passaggio principale consiste nel sostituire il pacchetto Lucene.NET Nuget dalla tua libreria con il pacchetto Distributed Lucene Nuget Lucene.Net.NCache.
Connessione a NCache elenco
NCache Directory, come suggerisce il nome, è una classe base per la memorizzazione degli indici per rendere scalabili gli indici. Quindi, il primo passo è connettersi con il NCache elenco.
Di seguito è riportato il codice che ti connette a una cache denominata luceneCache e apre la directory fornita su tutti i server.
1 2 3 4 5 6 7 8 9 |
// Specify the cache name that is used for Lucene string cache = "LuceneCache"; // Specify the index name to create the indexes string indexName = "ProductIndex"; // Create a directory and open it on the cache and the index path NCacheDirectory ncacheDirectory = NCacheDirectory.Open(cache, indexName); |
NCache Dettagli API distribuita di Lucene geospaziale Inizializza Lucene distribuita
Dati indice in Lucene distribuita
Una volta inizializzata la directory, IndexWriter
crea documenti sull'indice con lo stesso meccanismo di Lucene.NET utilizzando AddDocument
metodo. Quando il documento è scritto, IndexWriter.Commit
viene chiamato per rendere persistente il documento e renderlo ricercabile.
Distributed Lucene consente di aprire più writer sulla stessa directory per l'indicizzazione parallela. L'esempio di codice riportato di seguito mostra come indicizzare i documenti con Distributed Lucene.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
// Create an instance of the writer IndexWriter indexWriter = new IndexWriter(ncacheDirectory, new IndexWriterConfig(LuceneVersion.LUCENE_48, new WhitespaceAnalyzer(LuceneVersion.LUCENE_48))); // Indexing // Add the products information that is to be indexed Product[] products = FetchProductsFromDB(); foreach (var prod in products) { // Create a document and add fields to it Document doc = new Document(); doc.Add(new TextField("ProductID", prod.ProductID, Field.Store.YES)); doc.Add(new TextField("ProductName", prod.ProductName, Field.Store.NO)); doc.Add(new TextField("Category", prod.Category, Field.Store.YES)); doc.Add(new TextField("Description", prod.Description, Field.Store.YES)); // Writer is created previously indexWriter.AddDocument(doc); } // Calling commit on the writer saves all the write operations indexWriter.Commit(); // Dispose the objects after indexing indexWriter?.Dispose(); ncacheDirectory?.Dispose(); |
NCache Dettagli Sfaccettature di lucene distribuite Indicizzazione lucene distribuita
Ricerca in Lucene distribuita
Ricerca può essere eseguita dopo l'indicizzazione dei dati. Il IndexSearcher
utilizza l' IndexReader
per il recupero dei risultati. Il IndexSearcher
è responsabile della ricerca dei dati in base alle query fornite. Lucene fornisce un'ampia gamma di query e Distributed Lucene supporta tutte le query Lucene.
L'esempio di codice riportato di seguito mostra come eseguire ricerche nei documenti indicizzati con Distributed Lucene.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
// Open a new reader instance IndexReader reader = DirectoryReader.Open(ncacheDirectory); // A searcher is open to perform searching IndexSearcher indexSearcher = new IndexSearcher(reader); // Specify analyzer type Analyzer analyzer = new WhitespaceAnalyzer(version); // Create a query parser and parse the query with the parser //Specify the searchTerm and the fieldName QueryParser parser = new QueryParser(LuceneVersion.LUCENE_48, "Category", analyzer); Query query = parser.Parse("Beverages"); // Returns the top 10000 hits from the result set ScoreDoc[] docsFound = indexSearcher.Search(query, 10000).ScoreDocs; indexSearcher?.Dispose(); reader?.Dispose(); |
NCache Dettagli Contatori Lucene Distribuiti Ricerca Lucene distribuita
Usa gli indici Lucene nativi con Lucene distribuito
Se hai già un'applicazione .NET che utilizza Lucene, è probabile che tu possa creare un indice Lucene di grandi dimensioni. NCache fornisce il Import-LuceIndex cmdlet, che consente agli utenti di importare un indice Lucene esistente in NCache Lucene distribuito senza dover ricostruire gli indici.
Questo comando di esempio carica l'indice Lucene nativo da C:\Indice a un punto vendita Distributed Lucene demoCache.
1 |
Import-LuceneIndex -CacheName demoCache -Path C:\Index -Server 20.200.21.11 |
NCache Dettagli Lucene Docs distribuito Importa indici Lucene
Conclusione
Lucene è un motore di ricerca altamente efficiente per eseguire ricerche full-text sui tuoi dati ma manca di scalabilità. NCache può essere utilizzato con Lucene per renderlo scalabile con il minimo sforzo. Lucene distribuito scalabile rende la tua applicazione non solo più veloce, ma ti aiuta anche a gestire la grave battuta d'arresto di un singolo punto di errore. NCache può essere facilmente inserito nella tua applicazione .NET con una modifica del codice a riga singola, quindi considerala la migliore opzione possibile per la tua applicazione Lucene scalabile.