So entwickeln Sie eine Anwendung für den ES-Abruf mit Golang

Mit der rasanten Entwicklung von Internetanwendungen sind riesige Datenmengen zur Norm geworden, und eine effiziente Speicherung und Abfrage dieser Daten ist sehr wichtig geworden. Search Engine ist eine effiziente und skalierbare verteilte Suchmaschine für große verteilte Datenspeicherumgebungen. Es handelt sich um eine Technologie, die auf den Bereich der Textsuche ausgerichtet ist.

ElasticSearch (ES) ist eine auf der Lucene-Bibliothek basierende Suchmaschine. Es handelt sich um eine verteilte Volltextsuchmaschine auf Basis einer RESTful-Architektur, die Echtzeitsuche, Datenanalyse und andere Funktionen unterstützen kann. Aufgrund seines Open-Source-Charakters und seiner Benutzerfreundlichkeit wird ElasticSearch von Entwicklern zunehmend bevorzugt. In diesem Artikel wird erläutert, wie Sie mit Golang Anwendungen für den ES-Abruf entwickeln.

Zuerst müssen wir den ES-Client in der Programmiersprache Go installieren. Der Client von ES verwendet eine RESTful-Architektur, sodass wir die HTTP-Anforderungsbibliothek von Go für die Interaktion mit ES verwenden können. Dann können wir die ES RESTful API aufrufen, um eine einfache Suche unter Bezugnahme auf das folgende Codebeispiel zu implementieren:

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "bytes"
)

type SearchResult struct {
    Hits struct {
        Total int `json:"total"`
        Hits []struct {
            Source interface{} `json:"_source"`
        } `json:"hits"`
    } `json:"hits"`
}

func main() {
    query := "hello"
    url := fmt.Sprintf("http://localhost:9200/_search?q=%s", query)
    resp, _ := http.Get(url)
    defer resp.Body.Close()
    var result SearchResult
    json.NewDecoder(resp.Body).Decode(&result)
    b, _ := json.Marshal(result.Hits.Hits)
    fmt.Println(string(b))
}

Zuerst definieren wir eine Struktur namens SearchResult, um ES-Suchergebnisse zu speichern. Dann haben wir die Funktion fmt.Sprintf verwendet, um die Such-URL zu erstellen, die Anfrage über die Funktion http.Get an ES gesendet und das Ergebnis in die Struktur analysiert.

Abschließend serialisieren wir die Ergebnisse in das JSON-Format und drucken sie auf der Konsole aus. Auf diese Weise können wir die Go-Sprache ganz einfach zum Durchsuchen von Dokumenten in ES verwenden.

Diese Methode eignet sich jedoch nur für einfache Suchanwendungen, die umfangreichere Funktionen wie die Suche nach Bedingungen oder die Aggregation erfordern. Wir müssen den offiziell von ES bereitgestellten Golang-Client verwenden: go-elasticsearch.

Zuerst müssen wir die offiziell bereitgestellte go-elasticsearch-Bibliothek installieren. Zur Installation können Sie den folgenden Befehl verwenden:

go get github.com/elastic/go-elasticsearch/v8

Als nächstes implementieren wir die ES-Abfrage mithilfe des folgenden Codebeispiels:

package main

import (
    "context"
    "fmt"
    "github.com/elastic/go-elasticsearch/v8"
    "github.com/elastic/go-elasticsearch/v8/esapi"
    "encoding/json"
    "bytes"
)

type SearchResult struct {
    Hits struct {
        Total int `json:"total"`
        Hits []struct {
            Source interface{} `json:"_source"`
        } `json:"hits"`
    } `json:"hits"`
}

func main() {
    es, err := elasticsearch.NewDefaultClient()
    if err != nil {
        fmt.Println("Error creating Elasticsearch client:", err)
        return
    }

    query := "hello"

    var buf bytes.Buffer
    queryMap := map[string]interface{}{
        "query": map[string]interface{}{
            "match": map[string]interface{}{
                "message": query,
            },
        },
    }
    if err := json.NewEncoder(&buf).Encode(queryMap); err != nil {
        fmt.Println("Error encoding query:", err)
        return
    }

    req := esapi.SearchRequest{
        Index: []string{"my_index"},
        Body:  &buf,
        Pretty: true,
    }

    res, err := req.Do(context.Background(), es)
    if err != nil {
        fmt.Println("Error searching for documents:", err)
        return
    }
    defer res.Body.Close()

    var result SearchResult
    json.NewDecoder(res.Body).Decode(&result)
    b, _ := json.Marshal(result.Hits.Hits)
    fmt.Println(string(b))
}

Zuerst erstellen wir einen Elasticsearch-Client und definieren dann die Abfrageschlüsselwörter. Als Nächstes erstellen wir eine Karte im JSON-Format, die Abfragebedingungen enthält, und kodieren sie über die Funktion json.NewEncoder in buf.

Schließlich verwenden wir die von der go-elasticsearch-Bibliothek bereitgestellte ES-API, um Abfrageanfragen an ES zu senden und die Anfrageantworten zu lesen und zu analysieren.

Mit der go-elasticsearch-Bibliothek können komplexe ES-Suchfunktionen problemlos implementiert und der Code eleganter und einfacher gestaltet werden. Die Verwendung von Golang für die ES-Suche verbessert die Suchgeschwindigkeit erheblich und behält gleichzeitig die Codeeffizienz bei.

Kurz gesagt, Golang ist eine prägnante und effiziente Programmiersprache und lässt sich sehr einfach zur Implementierung der ES-Suche verwenden. Ich hoffe, dieser Artikel kann Ihnen helfen, die Verwendung der ES-Suche und der go-elasticsearch-Bibliothek zu verstehen.

Das obige ist der detaillierte Inhalt vonSo entwickeln Sie eine Anwendung für den ES-Abruf mit Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!