go 操作es

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	elasticsearch "github.com/elastic/go-elasticsearch/v7"
	"github.com/elastic/go-elasticsearch/v7/esapi"
	"github.com/google/uuid"
	"log"
	"strings"
	"time"
)

var es *elasticsearch.Client
var esIndex string = "apis"

const (
	mapping = `
	{
		 "mappings": {
            "properties": {
                "v": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
							"normalizer": "lowercase"
                        }
                    }
                }
            }
        }
	}`
)

/*
*
创建es客户端
*/
func CheckESClient() error {
	if es == nil {
		count := 0
		var err error
		for {
			count++
			if count > 60 {
				return errors.New("es connect failed")
			}
			if count%10 == 0 {
				log.Print("Try to connect ES, count:", count)
			}
			es, err = elasticsearch.NewClient(elasticsearch.Config{
				Addresses: []string{"http://***:9200/"},
				Username:  "elastic",
				Password:  "es123456789",
			})
			if err != nil {
				time.Sleep(1 * time.Second)
				continue
			}

			if _, err := es.Ping(); err != nil {
				time.Sleep(1 * time.Second)
				continue
			}
			break
		}
	}
	return nil
}

/*
*
创建索引
*/
func CreateNewIndex(indexName string) bool {
	if err := CheckESClient(); err != nil {
		log.Fatal(err)
	}

	exists, err := es.Indices.Exists([]string{indexName})
	if err != nil {
		fmt.Printf("indexName Existed ! err is %s\n", err)
		return false
	}
	/**
	不存在就创建
	*/
	if exists.StatusCode != 200 {
		res, err := es.Indices.Create(indexName, es.Indices.Create.WithBody(strings.NewReader(mapping)))
		if err != nil {
			log.Fatal(err)
			return false
		}
		defer res.Body.Close()

		var createRes map[string]interface{}
		if err := json.NewDecoder(res.Body).Decode(&createRes); err != nil {
			log.Fatal(err)
			return false
		}

		if acknowledged, ok := createRes["acknowledged"].(bool); ok && acknowledged {
			fmt.Printf("indexName create success: %s\n", res.String())
		} else {
			fmt.Printf("indexName create fail: %s\n", res.String())
			return false
		}
	}
	return true
}

/*
*
创建文档
*/
func createDoc() {
	// 准备要插入的文档数据
	doc := map[string]int{
		"v": '1',
	}

	jsonData, err := json.Marshal(doc)
	if err != nil {
		log.Fatal(err)
	}
	//生成es请求
	req := esapi.IndexRequest{
		Index:        esIndex,
		DocumentID:   uuid.New().String(), //uuid生成一个随机的唯一ID
		DocumentType: "_doc",
		Body:         bytes.NewReader(jsonData),
	}
	res, err := req.Do(context.Background(), es)
	if err != nil {
		log.Fatal(err)
	}
	defer res.Body.Close()
	if res.IsError() {
		// 处理索引失败的情况
		log.Fatalf("failed to append data to index: %s", res.String())
	} else {
		// 处理索引成功的情况
		log.Printf("data appended to index successfully: %s", res.String())
	}
}

type ApiData struct {
	ID  string `json:"id"`
	Val string `json:"val"`
}

func SearchAPIData() ([]ApiData, error) {
	if err := CheckESClient(); err != nil {
		log.Fatal(err)
	}

	// 构建搜索请求
	req := esapi.SearchRequest{
		Index: []string{esIndex},
	}

	// 设置搜索请求的查询条件
	query := map[string]interface{}{
		"query": map[string]interface{}{
			"match_all": map[string]interface{}{},
		},
	}
	reqBody, err := json.Marshal(query)
	if err != nil {
		return nil, err
	}
	req.Body = strings.NewReader(string(reqBody))

	// 发送搜索请求
	res, err := req.Do(context.Background(), es)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()

	// 检查响应结果
	if res.IsError() {
		return nil, fmt.Errorf("search request failed: %s", res.String())
	}

	// 解析响应结果
	var searchData struct {
		Hits struct {
			Hits []struct {
				Source ApiData `json:"_source"`
			} `json:"hits"`
		} `json:"hits"`
	}
	err = json.NewDecoder(res.Body).Decode(&searchData)
	if err != nil {
		return nil, err
	}
	// 返回搜索结果
	var apiDataList []ApiData
	for _, hit := range searchData.Hits.Hits {
		apiDataList = append(apiDataList, hit.Source)

	}

	return apiDataList, nil
}

func main() {
	// 创建索引
	//CreateNewIndex(esIndex)
	createDoc()

	results, err := SearchAPIData()
	if err != nil {
		log.Fatal(err)
	}

	for _, result := range results {
		fmt.Printf("ID: %s, Val: %s\n", result.ID, result.Val)
	}
}