Utilisation d'Apache Lucene pour le traitement de la recherche en texte intégral dans le développement d'API Java

Alors que la quantité de données Internet continue d'augmenter, la recherche rapide et précise des données est devenue un problème important. En réponse à ce problème, des moteurs de recherche en texte intégral ont émergé. Apache Lucene est l'une des bibliothèques de moteurs de recherche en texte intégral open source, adaptée aux applications intégrées au langage de programmation Java. Cet article explique comment utiliser Apache Lucene pour le traitement de la recherche en texte intégral dans le développement d'API Java.

1. Introduction à Apache Lucene

Apache Lucene est une bibliothèque de moteur de recherche en texte intégral. Il s'agit d'une recherche hautes performances, complète et facile à utiliser. bibliothèque de moteurs basée sur Java. Il peut indexer de grandes quantités de données textuelles et fournir des résultats de récupération efficaces, précis et rapides. Lucene utilise une technologie d'indexation sur disque pour diviser les données texte en plusieurs mots, puis les stocker dans une table d'index inversée. La table d'index inversé utilise la relation entre les mots et les documents pour pointer les mots vers le document où se trouve le mot. Pendant le processus de requête, la table d'index inversé recherche les documents par mot et les renvoie sous forme de résultats de requête.

2. Les composants de base de Lucene

Lucene est composé de plusieurs composants de base. Ces composants fonctionnent ensemble pour mettre en œuvre un moteur de recherche en texte intégral hautes performances, notamment :

1. Analyzer Les données textuelles sont divisées en plusieurs mots. En plus de diviser le texte en mots, l'analyseur. peut également être utilisé pour filtrer les mots vides, effectuer une conversion de casse, etc.

IndexWriter (écrivain d'index)

2. IndexWriter est utilisé pour convertir des données texte en une table d'index, créer une table d'index inversée, et c'est persisté sur le disque. Lorsque des données doivent être recherchées, elles peuvent être rapidement recherchées à partir de la table d'index.

IndexReader (lecteur d'index)

3. IndexReader est utilisé pour lire la table d'index à partir du disque et la charger en mémoire. Les données sont chargées à partir de la mémoire, les requêtes sur les données sont donc très rapides.

Query (Query)

4. Query est utilisé pour convertir les chaînes saisies par l'utilisateur en conditions de recherche et les rechercher rapidement dans la table d'index Lucene Rechercher données.

3. Utilisez Lucene pour implémenter la recherche en texte intégral

Présentation des dépendances Lucene

1. Maven est couramment utilisé dans Outil de gestion des dépendances de développement Java. Il nous suffit d'ajouter les dépendances Lucene suivantes dans Maven :

<dependency>
  <groupId>org.apache.lucene</groupId>
  <artifactId>lucene-core</artifactId>
  <version>8.8.2</version>
</dependency>

Create index

2. Utilisez IndexWriter pour convertir les données en table d'index. Ici, nous supposons que les données recherchées proviennent d’une base de données ou d’une autre source. Nous devons le convertir sous forme de texte et l'ajouter à IndexWriter. Voici un exemple d'article :

import org.apache.lucene.analysis.cn.smart.SmartChineseAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.FieldType;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.Term;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import java.nio.file.Paths;

public class Indexer {

    private IndexWriterConfig indexWriterConfig = new IndexWriterConfig(new SmartChineseAnalyzer());
    private IndexWriter indexWriter;

    public Indexer(String indexPath) {
        try {
            Directory directory = FSDirectory.open(Paths.get(indexPath));
            indexWriter = new IndexWriter(directory, indexWriterConfig);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void add(String field, String value) {
        try {
            Document doc = new Document();
            FieldType fieldType = new FieldType();
            fieldType.setIndexOptions(FieldInfo.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS);
            fieldType.setStored(true);
            fieldType.setTokenized(true);
            doc.add(new Field(field, value, fieldType));
            indexWriter.addDocument(doc);
            indexWriter.commit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void delete(String field, String value) {
        try {
            indexWriter.deleteDocuments(new Term(field, value));
            indexWriter.commit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void close() {
        try {
            indexWriter.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

Dans cette classe :

Dans le constructeur Indexer, nous initialisons l'IndexWriter et le Directory. Le répertoire représente l'emplacement de la bibliothèque d'index. La méthode

add() est utilisée pour ajouter des données texte à la bibliothèque d'index. La méthode
• delete() est utilisée pour supprimer les données texte de la bibliothèque d'index. La méthode
• close() est utilisée pour fermer enfin l'IndexWriter.
• Recherche

3. Utilisez Query et IndexReader pour les opérations de recherche. Voici l'exemple de code :

import org.apache.lucene.analysis.cn.smart.SmartChineseAnalyzer;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryparser.classic.MultiFieldQueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

public class Searcher {

    private String[] fields = new String[] {"title", "content"};
    private Query query;
    private IndexReader indexReader;
    private IndexSearcher indexSearcher;

    public Searcher(String indexPath) {
        try {
            Directory directory = FSDirectory.open(Paths.get(indexPath));
            indexReader = DirectoryReader.open(directory);
            indexSearcher = new IndexSearcher(indexReader);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private Query getQuery(String keyword) {
        try {
            if (query == null) {
                query = new MultiFieldQueryParser(fields, new SmartChineseAnalyzer()).parse(keyword);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return query;
    }

    public List<String> search(String keyword) {
        List<String> result = new ArrayList<String>();
        try {
            TopDocs topDocs = indexSearcher.search(getQuery(keyword), 10);
            ScoreDoc[] scoreDocs = topDocs.scoreDocs;
            for (ScoreDoc scoreDoc : scoreDocs) {
                result.add(indexSearcher.doc(scoreDoc.doc).get("title"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    public void close() {
        try {
            indexReader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

Dans cette classe :

Searcher Dans le constructeur, on initialise IndexReader et IndexSearcher. La méthode

getQuery() est utilisée pour convertir les conditions de recherche saisies par l'utilisateur en type de requête.
• La méthode search() est utilisée pour la recherche et renvoie les résultats après avoir effectué l'opération de recherche. La méthode
• close() est utilisée pour fermer enfin l'IndexReader.
• 4. Résumé

Cet article présente comment implémenter la fonction de recherche en texte intégral via Apache Lucene, impliquant principalement les composants principaux de Lucene, l'utilisation de Lucene et les fonctions de Lucene Quelques méthodes de classe courantes. En plus des classes et des méthodes abordées dans cet article, Lucene existe de nombreuses autres fonctions qui peuvent être ajustées et utilisées de manière appropriée en fonction de différents besoins. Apache Lucene est une bibliothèque de moteur de recherche en texte intégral très fiable en langage Java, adaptée à de nombreux domaines. Grâce à l'apprentissage et à la pratique, je pense que tout le monde peut mieux utiliser Apache Lucene dans des applications pratiques pour obtenir des fonctions de recherche efficaces, précises et rapides.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!