lucene é uma biblioteca de mecanismo de pesquisa de texto completo .NET que contém APIs poderosas para criar índices de texto completo e implementar tecnologias de pesquisa avançadas e precisas em seus programas. O Lucene oferece muito mais do que você esperaria de outros mecanismos de pesquisa de texto, pois as opções dadas ao usuário são múltiplas. Possui um poderoso algoritmo de pesquisa e suporta uma ampla gama de consultas para pesquisa.
Embora tão poderoso quanto o Lucene por si só, não é sem limitações. O Lucene é executado em processo no aplicativo cliente e os aplicativos Lucene normalmente gravam dados em um arquivo e os armazenam no disco, resultando em uma enorme alocação de memória. No entanto, é uma solução autônoma que não é dimensionada à medida que seus dados crescem, você precisa reconstruir índices inteiros do Lucene para pesquisar dados, o que é uma tarefa cara e lenta, que pode resultar em um gargalo de desempenho. Isso significa que o Lucene não é escalável e tem um único ponto de falha.
NCache Adicionar ao carrinho Download NCache NCache Docs
Como o Lucene distribuído ajuda você
NCache fornece uma implementação distribuída do Lucene que torna os aplicativos Lucene escaláveis. NCache ser distribuído na natureza com o Lucene fornece escalabilidade de gravação linear, pois os documentos indexados pelos aplicativos são distribuídos automaticamente entre os nós de cache onde são indexados separadamente.
Da mesma forma, o Distributed Lucene também fornece escalabilidade de leitura linear, pois as consultas são propagadas em cada partição e os resultados são mesclados. Um número maior de partições fornece uma quantidade maior de escalabilidade de leitura e gravação. Os índices Lucene são persistidos na unidade física. Quanto mais nós, maior a escalabilidade, desempenho e capacidade de armazenamento para acomodar um grande número de documentos Lucene e dados indexados.
NCache Adicionar ao carrinho Baixar NCache Documentos distribuídos do Lucene
Como o Lucene distribuído funciona
Lucene distribuído contém vários nós de servidor, cada servidor de NCache tem um módulo Lucene dedicado. Os comportamentos e o funcionamento do Lucene e do Distributed Lucene são semelhantes, exceto por algumas mudanças.
O diagrama abaixo mostra como o modelo Distributed Lucene funciona.
O aplicativo cliente pode querer indexar documentos ou consultar documentos indexados existentes usando a API do Lucene. Essas interações com a API agem como chamadas de procedimento remoto (RPCs) entre o cliente e o servidor. As chamadas de API são encaminhadas diretamente para os módulos Lucene anexados a cada nó do servidor. Os módulos Lucene executam essas chamadas e, dependendo da natureza das chamadas, uma das seguintes ações ocorre:
- Caso seja uma chamada de consulta, os módulos Distributed Lucene retornam os resultados para o lado do cliente, onde todos esses resultados são mesclados e processados.
- Caso seja uma chamada para indexar um documento, os Módulos Distributed Lucene persistem esse documento em uma unidade de disco.
NCache Adicionar ao carrinho Documentos distribuídos do Lucene Cache Lucene distribuído
Distribuição de dados
Um mapa de distribuição é gerado em relação ao NCache cluster para Lucene Distribuído. Este mapa contém informações sobre a distribuição do bucket em relação aos nós de cache. Esses buckets (existem 100 buckets no mapa) são distribuídos no cluster usando uma estratégia específica. A adição ou remoção de um nó do cluster alterará o mapa de distribuição e acionará a transferência de estado para os nós do servidor em execução, que transferem buckets com dados indexados no respectivo nó.
Ter 100 buckets significa que um índice Lucene é dividido em 100 subíndices ao longo do NCache conjunto. Um único bucket contém um subíndice, que é o mesmo que um índice Lucene no Lucene.Net. Um nó de servidor pode conter vários índices e cada índice desse nó de servidor contém buckets que são atribuídos a ele de acordo com a estratégia de distribuição do cluster. Os dados dentro dos índices são distribuídos uniformemente por meio desses buckets.
Como começar com o Lucene distribuído
O Lucene distribuído funciona exatamente como o Lucene. Um grande conforto de usar o Lucene distribuído é que ele oferece a mesma API que lucene. Como usuário do Lucene, você obtém a escalabilidade que deseja com um complemento de alteração de código de linha única. Você só tem que usar NCache Directory e seu aplicativo estão prontos. Existem muito poucas mudanças comportamentais e de API no Lucene distribuído que estão listadas no documentação.
Vamos dar uma olhada mais de perto nessas etapas de um aspecto técnico, e a etapa principal é substituir o pacote Lucene.NET Nuget da sua biblioteca pelo pacote Distributed Lucene Nuget Lucene.Net.NCache.
Conectando à NCache Diretório
NCache Directory, como o nome sugere, é uma classe base para armazenar os índices para torná-los escaláveis. Então, o primeiro passo é conectar com o NCache Diretório.
Abaixo está o código que conecta você a um cache chamado luceneCache e abre o diretório fornecido em todos os servidores.
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 Adicionar ao carrinho API geoespacial distribuída do Lucene Inicializar o Lucene distribuído
Dados de índice no Lucene distribuído
Uma vez que o diretório é inicializado, IndexWriter
cria documentos no índice com o mesmo mecanismo do Lucene.NET usando AddDocument
método. Quando o documento é escrito, IndexWriter.Commit
é chamado para persistir o documento e torná-lo pesquisável.
O Lucene distribuído permite que você abra vários gravadores no mesmo diretório para indexação paralela. O exemplo de código abaixo demonstra como você pode indexar seus documentos com o 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 Adicionar ao carrinho Facetas Distribuídas de Lucene Indexação Distribuída de Lucene
Pesquisando no Lucene Distribuído
Busca pode ser realizada após a indexação dos dados. o IndexSearcher
utiliza o IndexReader
para buscar os resultados. o IndexSearcher
é responsável por pesquisar os dados de acordo com as consultas fornecidas. O Lucene fornece uma ampla variedade de consultas, e o Lucene Distribuído suporta todas as consultas do Lucene.
O exemplo de código abaixo demonstra como você pode pesquisar seus documentos indexados com o 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 Adicionar ao carrinho Contadores Lucene Distribuídos Pesquisa Distribuída de Lucene
Use índices Lucene nativos com Lucene distribuído
Se você já tem um aplicativo .NET usando o Lucene, é provável que tenha um grande índice do Lucene construído. NCache fornece o Importação-LuceneIndex cmdlet, que permite aos usuários importar um índice Lucene existente para NCache Distribuiu o Lucene sem a necessidade de recompilar índices.
Este comando de exemplo carrega o índice Lucene nativo de C:\Índice para uma loja Distributed Lucene demoCache.
1 |
Import-LuceneIndex -CacheName demoCache -Path C:\Index -Server 20.200.21.11 |
NCache Adicionar ao carrinho Documentos distribuídos do Lucene Importar Índices de Lucene
Conclusão
O Lucene é um mecanismo de pesquisa altamente eficiente para realizar pesquisas de texto completo em seus dados, mas carece de escalabilidade. NCache pode ser usado com o Lucene para torná-lo escalável com muito pouco esforço. O Lucene distribuído escalável torna seu aplicativo não apenas mais rápido, mas também o ajuda a lidar com o grande revés de um único ponto de falha. NCache pode ser facilmente conectado ao seu aplicativo .NET com uma alteração de código de linha única, portanto, considere-a a melhor opção possível para seu aplicativo Lucene escalável.
NCache Adicionar ao carrinho Baixar NCache Comparação de edições