贴一个作者代码实现的github仓库:go操作es的全部代码

1.es的连接

导入依赖：go get -u "github.com/olivere/elastic/v7"

var Client *elastic.Client

func EsConnect() {
	client, err := elastic.NewClient(
		elastic.SetURL("http://127.0.0.1:9200"),
		elastic.SetSniff(false),
		elastic.SetBasicAuth("elastic", "123456"))

	if err != nil {
		fmt.Println("连接失败:", err.Error())
		return
	}
	Client = client
}

2.es的认证

• 认证情况：分析
  • 无需认证
    1.云服务器使用docker 搭建es，但是9200,9300端口不开放
    2.本身跑在127.0.0.1上
  • 需要认证：es需要对外提供服务的，比如说本机连接服务器的es
• 给docker的es容器设置密码
  • 进入es容器，修改配置文件:config/elasticsearch.yml,添加下列信息

	http.cors.enabled: true
	http.cors.allow-origin: "*"
	http.cors.allow-headers: Authorization
	xpack.security.enabled: true
	xpack.security.transport.ssl.enabled: true

• 重启es容器生效
  docker restart es
• 进入容器，输入./bin/elasticsearch-setup-passwords interactive,根据提示设置至少六位长度的密码。设置6种密码建议设置一样。
  – 再次重启生效，用户名：elastic

  • 网页访问
    

  • curl访问:curl -u elastic:123456 http://127.0.0.1:9200

  • 

3.索引操作

• 创建索引

  1. 用户实例

     type User struct {
         ID        uint      jsom:"id"
         Name      string    jsom:"name"
         Nickname  string    jsom:"nick_name"
         CreatedAt time.Time jsom:"created_at"
     }
     
     func (u User) Mapping() string {
         return {     
         "mappings":{  
          "properties":{   
             "nick_name":{        
             "type":"text" //分词              
            },                
            "name":{                       
         "type":"keyword" //完全匹配        
              },               
           "id":{                       
       "type":"integer"            
            },               
           "created_at":{        
              "type":"date",         
               "null_value":"null",       
               "format":"[yyyy-MM-dd HH:mm:ss]"  
             }      
          }     
        }        
      }
     }
     

  2. 创建方法：

     func CreateIndex() {
         createIndex, err := utils.Client.CreateIndex("user_index").BodyString(models.User{}.Mapping()).Do(context.Background())
         if err != nil {
            fmt.Println(err)
            return
         }
         fmt.Println(createIndex)
     }
     

     
     

• 查看索引的mapping:

  • url:
    http://127.0.0.1:9200/user_index/_mapping

• 删除索引

  	func DeleteIndex(indexName string) {
  	    deleteindex, err := utils.Client.DeleteIndex("user_index").Do(context.Background())
  	    if err != nil {
  	       fmt.Println("删除索引：", err.Error())
  	       return
  	    }
  	    fmt.Println(deleteindex, "删除索引成功")
  	}
  

  

4.文档CRUD操作

• 添加文档：

  • 单个添加

    func CreateDoc() {
        user := models.User{
           ID:        10,
           Name:      "Zy",
           Nickname:  "Zy爱吃蘑菇和鸡蛋",
           CreatedAt: time.Now(),
        }
    
        IndexResponse, err := utils.Client.Index().Index(user.Index()).BodyJson(user).Do(context.Background())
        if err != nil {
           fmt.Println("创建文档错误：", err)
           return
        }
        fmt.Printf("%#v", IndexResponse)
    }
    

    • 在浏览器上下载elasticsearch head插件，使用即可方便查看索引、文档
      

  • 注意：

    • user结构体属性多于索引库的mapping,则es会自动创建mapping
    • user的属性少于mapping,也可添加
    • text不能排序

  • 批量添加

    func CreateDocs() {
        userList := []models.User{
           {
              ID:        10,
              Name:      "Zy",
              Nickname:  "asdfghjkl;",
              CreatedAt: time.Now(),
           },
           {
              ID:        11,
              Name:      "Sy",
              Nickname:  "qwertyuio",
              CreatedAt: time.Now(),
           },
           {
              ID:        12,
              Name:      "Qz",
              Nickname:  "zxcbnm,",
              CreatedAt: time.Now(),
           },
        }
        bulk := utils.Client.Bulk().Index(models.User{}.Index()).Refresh("true")
        for _, user := range userList {
           req := elastic.NewBulkCreateRequest().Doc(user)
           bulk.Add(req)
        }
        res, err := bulk.Do(context.Background())
        if err != nil {
           fmt.Println("创建文档错误：", err)
           return
        }
        fmt.Println(res.Succeeded())
    } 
    

• 删除文档

  • 根据_id删除

    func DeleteDoc() {
        deleteResponse, err := utils.Client.Delete().Index(models.User{}.Index()).Id("YLUbD48BsTBsV_jmmbJQ").Refresh("true").Do(context.Background())
        if err != nil {
           fmt.Println("创建文档错误：", err)
           return
        }
        fmt.Printf("%#v", deleteResponse)
    }
    refresh（“true”）表示立即删除
      - 根据id批量删除
    func DeleteDocs() {
        idList := []string{
           "YrUeD48BsTBsV_jmhbI5",
           "Y7UeD48BsTBsV_jml7If",
        }
        bulk := utils.Client.Bulk().Index(models.User{}.Index()).Refresh("true")
        for _, s := range idList {
           req := elastic.NewBulkDeleteRequest().Id(s)
           bulk.Add(req)
        }
        res, err := bulk.Do(context.Background())
        if err != nil {
           fmt.Println("创建文档错误：", err)
           return
        }
        fmt.Println(res)
    }
    

单个删除不存在的文档，会返回404,
批量删除不存在的文档不会返回错误。只是成功数量为0

• 查询文档

  • 查询列表：

    func FindDoc() {
        query := elastic.NewBoolQuery()
        reslist, err := utils.Client.Search(models.User{}.Index()).Query(query).From(0).Size(10).Do(context.Background())
        if err != nil {
           fmt.Println("查询文档列表错误：", err)
           return
        }
        count := reslist.Hits.TotalHits.Value
        fmt.Println("查到的数量：", count)
        for _, hit := range reslist.Hits.Hits {
           fmt.Println(string(hit.Source))
        }
    }
    

    

  • 分页查询

    func FindDoc() {
        limit := 2
        page := 4
        from := (page - 1) * limit
        query := elastic.NewBoolQuery()
        reslist, err := utils.Client.Search(models.User{}.Index()).Query(query).From(from).Size(limit).Do(context.Background())
        if err != nil {
           fmt.Println("查询文档列表错误：", err)
           return
        }
        count := reslist.Hits.TotalHits.Value
        fmt.Println("查到的数量：", count)
        for _, hit := range reslist.Hits.Hits {
           fmt.Println(string(hit.Source))
        }
    }
    

  • 精确匹配—>用于keyword字段
    query := elastic.NewTermQuery(“Name.keyword”, “Zy”)

  • 模糊匹配—>查keyword需要完整查询，查text不需要
    query := elastic.NewMatchQuery(“Name”, “蘑菇”)

• 更新文档

  func UpdateDoc() {
          updateRes, err := utils.Client.Update().Index(models.User{}.Index()).Id("ZLUeD48BsTBsV_jmurI9").Doc(map[string]interface{}{
                  "Name": "ty",
          }).Do(context.Background())
          if err != nil {
                  fmt.Println("更新文档错误：", err)
                  return
          }
          fmt.Println(updateRes)
  }