Verwendung von Solr für die Volltextsuche in der Java-API-Entwicklung

Mit der Entwicklung des Internets und dem explosionsartigen Wachstum der Informationen ist die Menge an Informationen, auf die wir jetzt zugreifen und die wir erhalten können, sehr groß. Unabhängig davon, ob es sich um Informationen aus Webseiten, Dokumenten oder dem täglichen Leben handelt, ist eine effiziente Verarbeitung und Verarbeitung erforderlich schaffe es. Die Volltextsuche ist eine sehr effiziente und häufig verwendete Methode zum Auffinden und Extrahieren der benötigten Informationen mithilfe von Schlüsselwörtern oder Phrasen. Solr ist ein Tool, das sich sehr gut für die Entwicklung der Volltextsuche eignet.

In diesem Artikel werden die Grundkonzepte von Solr und die Verwendung von Solr für die Volltextsuche in der Java-API-Entwicklung vorgestellt.

1. Einführung in Solr

Solr ist im Wesentlichen eine Open-Source-Unternehmenssuchplattform, die auf der Java-Bibliothek von Apache Lucene basiert und einige praktische REST-APIs bereitstellt. Laut der offiziellen Einführung von Solr umfasst es hauptsächlich die folgenden Funktionen:

• Volltextsuche
• Echtzeitsuche
• Website-Suche
• Verteilte Suche
• Datenbankintegration
• Analyse mehrerer Dateiformate
• Export von Mehrere Dateiformate
• Externe Konfiguration

Als Suchplattform auf Unternehmensebene bietet Solr sehr vollständige Suchfunktionen und flexible Konfigurationsmethoden, was es uns erleichtert, Suchmodule in der tatsächlichen Entwicklung zu entwickeln. Im Folgenden konzentrieren wir uns auf die Verwendung von Solr für die Volltextsuche in der Java-API-Entwicklung.

2. Verwenden Sie Solr für die Volltextsuche

2.1 Installieren Sie Solr

Zuerst müssen wir Solr in der lokalen Umgebung oder auf dem Server installieren. Solr bietet offiziell eine sehr bequeme Möglichkeit, Solr zu installieren und auszuführen:

• Solr-Adresse herunterladen: https://lucene.apache.org/solr/downloads.html.
• Entpacken Sie die Datei: tar -zxvf solr-x.x.x.zip.
• Geben Sie den dekomprimierten Ordner ein: cd solr-x.x.x.
• Solr starten: Bin/Solr-Start.

2.2 Solr Core erstellen und Schema definieren

Solr Core ist ein Kernkonzept in Solr. Es entspricht einer unabhängigen Suchumgebung, einschließlich Datenindizierung und Suchanfragenverarbeitung. In Solr können wir mehrere Kerne erstellen und jeder Kern kann über unabhängige Konfigurationen und Datensätze verfügen.

In Solr müssen wir zuerst einen Kern erstellen und dann das Schema für die Suche definieren. Das Schema definiert Datenfelder, Typen, Indizes und andere Attribute, die sich auf die Effizienz und Genauigkeit der Suche auswirken.

Sie können das integrierte Schema von Solr oder das benutzerdefinierte Schema verwenden, um die für die Suche erforderlichen Feldattribute zu definieren. Hier stellen wir die Verwendung des Standardschemas von Solr vor.

Verwenden Sie Solrs eigenes Standardschema:

1. Kern erstellen:

   bin/solr create_core -c <core name>

2. Alle erstellten Felder löschen:

   curl http://localhost:8983/solr/<core name>/schema -H 'Content-type:application/json' -d '{"delete-all-fields":{}}'

3. Felder hinzufügen:

   curl http://localhost:8983/solr/<core name>/schema -H 'Content-type:application/json' -d '
    {
      "add-field":{
         "name":"field_name",
         "type":"string",
         "stored":true
       }
    }'

4. Solr-Dienst neu starten

Benutzeranpassungsschema verwenden:

Benutzer können das Schema an unterschiedliche Anwendungsanforderungen anpassen. Solr bietet eine Schema-API. Bietet Erstellern eine einfache Schema-Hinzufügung.

1. Kern erstellen:

   bin/solr create_core -c <core name>

2. Feld hinzufügen:

   • Feldtyp hinzufügen:
     POST-Anfrage an Solr-Server senden, content_type ist auf application/json gesetzt

   {   
        "add-field-type": {   
          "name":"test_fieldType","class":"solr.TextField","indexAnalyzer":{   
             "tokenizer":{   
                "class":"solr.StandardTokenizerFactory"   
             },"filters":[  
             {   
                 "class":"solr.StopFilterFactory",   
                 "ignoreCase":true,   
                 "words":"stopword.txt",   
                 "format":"snowball",   
                 "enablePositionIncrements":true   
             },{   
                 "class":"solr.SnowballPorterFilterFactory",   
                 "language":"English"   
             }   
            ],   
            "queryAnalyzer":{   
                "tokenizer":{   
                   "class":"solr.StandardTokenizerFactory"   
                 },"filters":[  
                 {   
                    "class":"solr.StopFilterFactory",   
                    "ignoreCase":true,   
                    "words":"stopword.txt",   
                    "format":"snowball",   
                    "enablePositionIncrements":true   
                 },{   
                    "class":"solr.SnowballPorterFilterFactory",   
                    "language":"English"   
                  }   
                ]   
             }   
          }   
   }

   • Feld (Titel) hinzufügen:

   {
        "add-field": {
            "name": "title",
            "type": "text_en",
            "stored": true
        }
   }

   Eine Antwort wird zurückgegeben, nachdem das Feld erfolgreich hinzugefügt wurde.

3. Geben Sie dieses Schema in der Solr-Konfiguration an:

   Geben Sie das Verzeichnis ${core}/conf ein, um solrconfig.xml zu ändern, und fügen Sie den folgenden Code hinzu:

   <schemaFactory class="ClassicIndexSchemaFactory"/>
   <schema name="schema_name" version="1.5">
       <field name="title" type="text_en" indexed="true" stored="true" />
   </schema>

2. Verwenden Sie Solr in der Java-API für Volltext Suche

Als nächstes besprechen wir, wie man die Java-API von Solr für die Volltextsuche in einer Java-Webanwendung verwendet.

1. SolrJ-Abhängigkeit hinzufügen

Im Maven-Projekt müssen wir eine SolrJ-Abhängigkeit hinzufügen. Solr bietet offiziell eine sehr praktische Abhängigkeit:

<dependency>
    <groupId>org.apache.solr</groupId>
    <artifactId>solr-solrj</artifactId>
    <version>8.2.0</version>
</dependency>

2. Verwenden Sie SolrJ, um im Code zu suchen.

In Java-Code können wir verwenden QueryResponse und SolrClient werden von SolrJ bereitgestellt, um Suchvorgänge durchzuführen. Die abgefragten Daten können als Schlüssel-Wert-Paare angezeigt werden.

Zuerst müssen wir eine Instanz von SolrClient erstellen. In SolrJ ist SolrClient der Client von Solr und stellt eine Methode zum direkten Aufrufen der Solr-REST-API bereit.

String solrUrl = "http://localhost:8983/solr/core_name";
SolrClient solr = new HttpSolrClient.Builder(solrUrl).build();

Dann müssen wir ein SolrQuery-Objekt erstellen, das zum Festlegen von Suchparametern verwendet wird, einschließlich Suchschlüsselwörtern, Sortierregeln, Filterbedingungen usw.

SolrQuery query = new SolrQuery();
query.setQuery("keyword");
query.setStart(0);
query.setRows(10);
query.setSort("sort_field", SolrQuery.ORDER.asc);
query.addFilterQuery("filter_field:filter_value");

Schließlich können wir die Suche über die Methode solr.query(query) durchführen und die zurückgegebene QueryResponse enthält die Suchergebnisse und zugehörigen Metadateninformationen. Wir müssen die Suchergebnisliste über die Methode „response.getResults()“ abrufen.

QueryResponse response = solr.query(query);
SolrDocumentList results = response.getResults();

In der tatsächlichen Entwicklung können wir bei Bedarf auch eine sekundäre Verarbeitung der Suchergebnisse durchführen, z. B. die Konvertierung der Ergebnisse in das JSON-Format oder Java-Objekte.

for (SolrDocument result : results) {
    String id = (String) result.getFieldValue("id");
    String title = (String) result.getFieldValue("title");
    String content = (String) result.getFieldValue("content");
    
    // 将搜索结果转换为 Java 实体类
    SearchResult item = new SearchResult(id, title, content);
    
    // 或将搜索结果转换为 JSON 字符串
    String json = new ObjectMapper().writeValueAsString(result);
}

Das Obige ist der grundlegende Prozess der Verwendung von Solr für die Volltextsuche in der Java-API-Entwicklung. Solr bietet sehr umfassende Suchfunktionen und Java-API-Unterstützung, sodass wir auf einfache Weise effiziente und genaue Suchmodule entwickeln können, um Benutzern ein besseres Sucherlebnis zu bieten.

Das obige ist der detaillierte Inhalt vonVerwendung von Solr für die Volltextsuche in der Java-API-Entwicklung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!