golang 整合es6, es7, xorm

最新推荐文章于 2024-07-13 15:08:35 发布
最新推荐文章于 2024-07-13 15:08:35 发布
阅读量713 收藏 1
点赞数
分类专栏： golang 文章标签： elasticsearch golang xorm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29323645/article/details/110431045
版权

1. 新建项目

项目git代码
相关学习网址

2.初始化go.mod

3.编写配置

package config

import (
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	xorm "github.com/go-xorm/xorm"
	elastic6 "github.com/olivere/elastic"
	elastic7 "github.com/olivere/elastic/v7"
	"log"
)

var GlobalConfig *Config

type Config struct {
	Xm        *xorm.Engine
	EsClient6 *elastic6.Client
	EsClient7 *elastic7.Client
}

// 初始化 client
func InitConfig() {
	// 初始化 Mysql
	initMysql()
	// 初始化 es6
	initEs6()
	// 初始化 es7
	initEs7()
}

// 初始化 Mysql
func initMysql() {
	// 初始化 MysqlDB
	var err error
	xm, err := xorm.NewEngine("mysql", "root:123456@tcp(127.0.0.1:3306)/test?charset=utf8")
	if err != nil {
		log.Fatal("数据库连接失败:", err)
		return
	}
	fmt.Println("mysql 连接成功")
	GlobalConfig = &Config{
		Xm: xm,
	}
}

// 初始化 es6
func initEs6() {
	// 此处链接的是 docker 的es,索引不能使用 localhost,必须用 本机ip
	host6 := "http://10.31.1.123:9300/"
	client6, err := elastic6.NewClient(
		elastic6.SetSniff(false),
		// 设置ES服务地址，支持多个地址
		elastic6.SetURL(host6),
		// 设置基于http base auth验证的账号和密码
		//elastic.SetBasicAuth("user", "secret"),
	)
	if err != nil {
		// Handle error
		fmt.Printf("Es6 连接失败: %v\n", err)
		return
	} else {
		GlobalConfig.EsClient6 = client6
		fmt.Println("Es6 连接成功")
	}
}

// 初始化 es7
func initEs7() {
	// 此处链接的是 docker 的es,索引不能使用 localhost,必须用 本机ip
	host7 := "http://10.31.1.123:9200/"
	client7, err := elastic7.NewClient(
		elastic7.SetSniff(false),
		// 设置ES服务地址，支持多个地址
		elastic7.SetURL(host7),
		// 设置基于http base auth验证的账号和密码
		//elastic.SetBasicAuth("user", "secret"),
	)
	if err != nil {
		// Handle error
		fmt.Printf("Es7 连接失败: %v\n", err)
		return
	} else {
		GlobalConfig.EsClient7 = client7
		fmt.Println("Es7 连接成功")
	}
}

编写main， 使用gin

package main

import (
	"github.com/gin-gonic/gin"
	"main/config"
	"main/controller"
)

func main() {
	// 初始化
	config.InitConfig()
	// start http server
	router := gin.Default()
	router.GET("/sync", controller.Sync)
	router.POST("/add", controller.Add)
	router.POST("/update", controller.Update)
	router.GET("/delete/:id", controller.Delete)
	router.GET("/getById/:id", controller.GetById)
	router.GET("/getList", controller.GetList)

	// es 6
	router.GET("/createIndex6", controller.CreateCmsIndex6)
	router.GET("/deleteIndex6", controller.DeleteCmsIndex6)
	router.GET("/rebuildIndex6", controller.RebuildCmsIndex6)
	router.GET("/searchDate6/:keyword", controller.SearchDate6)

	// es 7
	router.GET("/createIndex7", controller.CreateCmsIndex7)
	router.GET("/deleteIndex7", controller.DeleteCmsIndex7)
	router.GET("/rebuildIndex7", controller.RebuildCmsIndex7)
	router.GET("/searchDate7/:keyword", controller.SearchDate7)

	router.Run(":10000")

}

编写controller

  • xorm
package controller

import (
	"github.com/gin-gonic/gin"
	"main/common"
	"main/model"
	"time"
)

// 创建table
func Sync(ctx *gin.Context) {
	err := model.Sync()
	if err != nil {
		common.JSONResp(ctx, 500, err.Error(), nil)
		return
	}
	common.JSONResp(ctx, 200, "create table ok", nil)
}

// add
func Add(ctx *gin.Context) {
	ctx.PostForm("title")
	cms := &model.Cms{
		Id:      time.Now().Unix(),
		Title:   ctx.PostForm("title"),
		Tags:    ctx.PostForm("tags"),
		Content: ctx.PostForm("content"),
	}
	err := model.Add(cms)
	if err != nil {
		common.JSONResp(ctx, 500, err.Error(), nil)
		return
	}
	common.JSONResp(ctx, 200, "add ok", nil)
}

// 更新 暂无实现
func Update(ctx *gin.Context) {
	err := model.Update()
	if err != nil {
		common.JSONResp(ctx, 500, err.Error(), nil)
		return
	}
	common.JSONResp(ctx, 200, "update ok", nil)
}

// 删除
func Delete(ctx *gin.Context) {
	id, err := model.Delete(ctx.Param("id"))
	if err != nil {
		common.JSONResp(ctx, 500, err.Error(), nil)
		return
	}
	common.JSONResp(ctx, 200, "delete ok", id)
}

// getById
func GetById(ctx *gin.Context) {
	cms, err := model.GetById(ctx.Param("id"))
	if err != nil {
		common.JSONResp(ctx, 500, err.Error(), nil)
		return
	}
	common.JSONResp(ctx, 200, "getById ok", cms)
}

// 查询列表
func GetList(ctx *gin.Context) {
	limit := ctx.Query("limit")
	cmsList, err := model.GetList(limit)
	if err != nil {
		common.JSONResp(ctx, 500, err.Error(), nil)
		return
	}
	common.JSONResp(ctx, 200, "getById ok", cmsList)
}
  • elasticsearch6 实现
package controller

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/olivere/elastic"
	"main/common"
	"main/config"
	"main/model"
	"strconv"
)

const mapping6_cms = `
{
    "mappings": {
        "cms": {
            "properties": {
                "id": {
                    "type": "keyword"
                },
                "tags": {
                    "type": "text"
                },
                "title": {
                    "type": "keyword"
                },
                "content": {
                    "type": "text"
                },
                "createTime": {
                    "type": "keyword"
                },
                "updateTime": {
                    "type": "keyword"
                }
            }
        }
    }
}`

const mapping6_cms_no_type = `
{
    "mappings": {
		"properties": {
			"id": {
				"type": "keyword"
			},
			"tags": {
				"type": "text"
			},
			"title": {
				"type": "keyword"
			},
			"content": {
				"type": "text"
			},
			"createTime": {
				"type": "keyword"
			},
			"updateTime": {
				"type": "keyword"
			}
		}
    }
}`

const mapping6_cms_ik_comma = `
{
    "settings": {
        "index": {
            "number_of_shards": 5,
            "number_of_replicas": 0
        },
        "analysis": {
            "analyzer": {
                "comma": {
                    "type": "pattern",
                    "pattern": ","
                }
            }
        }
    },
    "mappings": {
        "cms": {
            "properties": {
                "id": {
                    "type": "keyword"
                },
                "tags": {
                    "type": "text",
					"analyzer": "comma",
                    "search_analyzer": "comma"
                },
                "title": {
                    "type": "text",
                    "analyzer": "ik_max_word",
                    "search_analyzer": "ik_max_word"
                },
                "content": {
                    "type": "text",
                    "analyzer": "ik_max_word",
                    "search_analyzer": "ik_max_word"
                },
                "createTime": {
                    "type": "keyword"
                },
                "updateTime": {
                    "type": "keyword"
                }
            }
        }
    }
}`

// 创建索引
func CreateCmsIndex6(ctx *gin.Context) {
	// 首先检测下weibo索引是否存在
	client := config.GlobalConfig.EsClient6
	exists, err := client.IndexExists("cms_index").Do(ctx)
	if err != nil {
		// Handle error
		common.JSONResp(ctx, 500, err.Error(), nil)
		return
	}
	if !exists {
		// weibo索引不存在，则创建一个
		//_, err := client.CreateIndex("cms_index").BodyString(mapping6_cms_no_type).Do(ctx)
		_, err := client.CreateIndex("cms_index").BodyString(mapping6_cms_ik_comma).Do(ctx)
		if err != nil {
			common.JSONResp(ctx, 500, err.Error(), nil)
			return
		}
	}
	common.JSONResp(ctx, 200, "create 6 cms_index ok", nil)
}

// 删除索引
func DeleteCmsIndex6(ctx *gin.Context) {
	client := config.GlobalConfig.EsClient6
	// 首先检测下weibo索引是否存在
	deleteIndex, err := client.DeleteIndex("cms_index").Do(ctx)
	if err != nil {
		common.JSONResp(ctx, 500, err.Error(), nil)
		return
	}
	if !deleteIndex.Acknowledged {
		// Not acknowledged
		common.JSONResp(ctx, 500, "delete 6 cms_index fail", nil)
	}
	common.JSONResp(ctx, 200, "delete 6 cms_index ok", nil)
}

// 重建索引数据（此处可以分批进行）
func RebuildCmsIndex6(ctx *gin.Context) {
	client := config.GlobalConfig.EsClient6
	cmsList, err := model.GetList("")
	if err != nil {
		common.JSONResp(ctx, 500, err.Error(), nil)
		return
	}
	if len(cmsList) > 0 {
		bulkRequest := client.Bulk()
		for _, cms := range cmsList {
			req := elastic.NewBulkIndexRequest().
				Index("cms_index").
				Type("cms").
				Id(strconv.FormatInt(cms.Id, 10)).
				Doc(cms)
			bulkRequest = bulkRequest.Add(req)
		}
		bulkResponse, err := bulkRequest.Do(context.Background())
		if err != nil {
			common.JSONResp(ctx, 500, err.Error(), nil)
			return
		}
		fmt.Println("耗时：", bulkResponse.Took, "索引了：", len(bulkResponse.Items))
	}
	common.JSONResp(ctx, 200, "add elastic 6,"+strconv.Itoa(len(cmsList))+"条数据", nil)
}

// 查询
func SearchDate6(ctx *gin.Context) {
	client := config.GlobalConfig.EsClient6
	//接收参数
	pageNo := 1
	pageSize := 10
	keyword := ctx.Param("keyword")
	pageNoStr := ctx.Query("pageNo")
	pageSizeStr := ctx.Query("pageSize")
	if pageNoStr != "" && pageSizeStr == "" {
		pageNo, _ = strconv.Atoi(pageNoStr)
		pageSize, _ = strconv.Atoi(pageSizeStr)
	}
	//where数组
	qList := make([]elastic.Query, 0)
	//加入图书名搜索条件
	if keyword != "" {
		machQuery := elastic.NewMatchQuery("title", keyword)
		qList = append(qList, machQuery)
		pressQuery := elastic.NewMatchQuery("tags", keyword)
		qList = append(qList, pressQuery)
	}

	//处理排序
	sortList := make([]elastic.Sorter, 0)
	{
		//以匹配度从高到低
		//sortList=append(sortList,elastic.NewScoreSort().Desc())
		sortList = append(sortList, elastic.NewFieldSort("id").Desc())
	}
	//must 相当于 where ... and ...
	boolMustQuery := elastic.NewBoolQuery().Should(qList...)
	jsons, errs := json.Marshal(boolMustQuery)
	if errs == nil {
		fmt.Println(string(jsons))
	}
	//分页
	rsp, err := client.Search().
		Query(boolMustQuery).SortBy(sortList...).
		From((pageNo - 1) * pageSize).Size(pageSize).
		Index("cms_index").Do(ctx)
	if err != nil {
		common.JSONResp(ctx, 500, err.Error(), nil)
		return
	}
	common.JSONResp(ctx, 200, "", rsp)
}
  • elasticsearch7 实现
package controller

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/olivere/elastic"
	elastic7 "github.com/olivere/elastic/v7"
	"main/common"
	"main/config"
	"main/model"
	"strconv"
)

const mapping7_cms = `
{
    "mappings": {
        "cms": {
            "properties": {
                "id": {
                    "type": "keyword"
                },
                "tags": {
                    "type": "text"
                },
                "title": {
                    "type": "keyword"
                },
                "content": {
                    "type": "text"
                },
                "createTime": {
                    "type": "keyword"
                },
                "updateTime": {
                    "type": "keyword"
                }
            }
        }
    }
}`

const mapping7_cms2 = `
{
    "mappings": {
		"properties": {
			"id": {
				"type": "keyword"
			},
			"tags": {
				"type": "text"
			},
			"title": {
				"type": "keyword"
			},
			"content": {
				"type": "text"
			},
			"createTime": {
				"type": "keyword"
			},
			"updateTime": {
				"type": "keyword"
			}
		}
    }
}`

const mapping7_cms_ik_comma = `
{
    "settings": {
        "index": {
            "number_of_shards": 5,
            "number_of_replicas": 0
        },
        "analysis": {
            "analyzer": {
                "comma": {
                    "type": "pattern",
                    "pattern": ","
                }
            }
        }
    },
    "mappings": {
		"properties": {
			"id": {
				"type": "keyword"
			},
			"tags": {
				"type": "text",
				"analyzer": "comma",
				"search_analyzer": "comma"
			},
			"title": {
				"type": "text",
				"analyzer": "ik_max_word",
				"search_analyzer": "ik_max_word"
			},
			"content": {
				"type": "text",
				"analyzer": "ik_max_word",
				"search_analyzer": "ik_max_word"
			},
			"createTime": {
				"type": "keyword"
			},
			"updateTime": {
				"type": "keyword"
			}
		}
    }
}`

// 创建索引
func CreateCmsIndex7(ctx *gin.Context) {
	// 首先检测下weibo索引是否存在
	client := config.GlobalConfig.EsClient7
	exists, err := client.IndexExists("cms_index").Do(ctx)
	if err != nil {
		// Handle error
		common.JSONResp(ctx, 500, err.Error(), nil)
		return
	}
	if !exists {
		// weibo索引不存在，则创建一个
		_, err := client.CreateIndex("cms_index").BodyString(mapping7_cms_ik_comma).Do(ctx)
		if err != nil {
			common.JSONResp(ctx, 500, err.Error(), nil)
			return
		}
	}
	common.JSONResp(ctx, 200, "create 7 cms_index ok", nil)
}

// 删除索引
func DeleteCmsIndex7(ctx *gin.Context) {
	client := config.GlobalConfig.EsClient7
	// 首先检测下weibo索引是否存在
	deleteIndex, err := client.DeleteIndex("cms_index").Do(ctx)
	if err != nil {
		common.JSONResp(ctx, 500, err.Error(), nil)
		return
	}
	if !deleteIndex.Acknowledged {
		// Not acknowledged
		common.JSONResp(ctx, 500, "delete 7 cms_index fail", nil)

	}
	common.JSONResp(ctx, 200, "delete 7 cms_index ok", nil)
}

// 重建索引数据（此处可以分批进行）
func RebuildCmsIndex7(ctx *gin.Context) {
	client := config.GlobalConfig.EsClient7
	cmsList, err := model.GetList("")
	if err != nil {
		common.JSONResp(ctx, 500, err.Error(), nil)
		return
	}
	if len(cmsList) > 0 {
		bulkRequest := client.Bulk()
		for _, cms := range cmsList {
			req := elastic.NewBulkIndexRequest().
				Index("cms_index").
				//Type("cms").
				Id(strconv.FormatInt(cms.Id, 10)).
				Doc(cms)
			bulkRequest = bulkRequest.Add(req)
		}
		bulkResponse, err := bulkRequest.Do(context.Background())
		if err != nil {
			common.JSONResp(ctx, 500, err.Error(), nil)
			return
		}
		fmt.Println("耗时：", bulkResponse.Took, "索引了：", len(bulkResponse.Items))
	}
	common.JSONResp(ctx, 200, "add 7 elastic"+strconv.Itoa(len(cmsList))+"条数据", nil)
}

// 搜索
func SearchDate7(ctx *gin.Context) {
	client := config.GlobalConfig.EsClient7
	//接收参数
	pageNo := 1
	pageSize := 10
	keyword := ctx.Param("keyword")
	pageNoStr := ctx.Query("pageNo")
	pageSizeStr := ctx.Query("pageSize")
	if pageNoStr != "" && pageSizeStr == "" {
		pageNo, _ = strconv.Atoi(pageNoStr)
		pageSize, _ = strconv.Atoi(pageSizeStr)
	}
	//where数组
	qList := make([]elastic7.Query, 0)
	//加入图书名搜索条件
	if keyword != "" {
		machQuery := elastic7.NewMatchQuery("title", keyword)
		qList = append(qList, machQuery)
		pressQuery := elastic7.NewMatchQuery("tags", keyword)
		qList = append(qList, pressQuery)
	}

	//处理排序
	sortList := make([]elastic7.Sorter, 0)
	{
		//以匹配度从高到低
		//sortList=append(sortList,elastic.NewScoreSort().Desc())
		sortList = append(sortList, elastic7.NewFieldSort("id").Desc())
	}
	//must 相当于 where ... and ...
	boolMustQuery := elastic7.NewBoolQuery().Should(qList...)
	jsons, errs := json.Marshal(boolMustQuery)
	if errs == nil {
		fmt.Println(string(jsons))
	}
	//分页
	rsp, err := client.Search().
		Query(boolMustQuery).SortBy(sortList...).
		From((pageNo - 1) * pageSize).Size(pageSize).
		Index("cms_index").Do(ctx)
	if err != nil {
		common.JSONResp(ctx, 500, err.Error(), nil)
		return
	}
	common.JSONResp(ctx, 200, "", rsp)
}

xorm model操作数据库

package model

import (
	"fmt"
	"main/config"
)

type Cms struct {
	Id         int64  `xorm:"pk autoincr" json:"id"` //指定主键并自增
	Title      string `xorm:"unique" json:"title"`   //唯一的
	Tags       string `json:"tags"`
	Content    string `json:"content"`
	UpdateTime int64  `xorm:"updated" json:"updateTime"` //修改后自动更新时间
	CreatTime  int64  `xorm:"created"  json:"creatTime"` //创建时间
}

// 创建table
func Sync() error {
	if err := config.GlobalConfig.Xm.Sync(new(Cms)); err != nil {
		return err
	}
	return nil
}

// 保存
func Add(cms *Cms) error {
	cmsA := new(Cms)
	cmsA.Id = cms.Id
	cmsA.Title = cms.Title
	cmsA.Tags = cms.Tags
	id, err := config.GlobalConfig.Xm.Insert(cmsA)
	fmt.Println("id:", id)
	if err != nil {
		return err
	}
	return nil
}

// 更新
func Update() error {
	return nil
}

// 删除
func Delete(id string) (int64, error) {
	rt, err := config.GlobalConfig.Xm.Id(id).Delete(new(Cms))
	if err != nil {
		return rt, err
	}
	return rt, nil
}

// getById
func GetById(id string) (*Cms, error) {
	cms := &Cms{}
	flag, err := config.GlobalConfig.Xm.SQL("select * from cms where id=" + id).Get(cms)
	if !flag || err != nil {
		return nil, err
	}
	return cms, nil
}

// 查询列表
func GetList(limit string) ([]*Cms, error) {
	var cmsList = make([]*Cms, 0)
	var sql = "select * from cms"
	if limit != "" {
		sql = sql + " limit " + limit
	}
	err := config.GlobalConfig.Xm.SQL(sql).Find(&cmsList)
	if err != nil {
		return nil, err
	}
	return cmsList, nil
}
转身那一瞬
关注
专栏目录
golang elasticsearch v7版本最全接口封装
tian828的博客
12-21 1296
golang elasticsearch v7版本搜索封装
Golang操作ES
qq_39280718的博客
09-24 2650
Golang操作ES
Go 切片的类 js es6 数组操作封装
m0_46172278的博客
06-22 436
最近由于工作上的原因学习了 Go 语言，由于写前端写习惯了，所以感觉 Go 中切片的相关操作有点别扭，于是趁着 1.18 发布了泛型之后，照着 js 中的数组操作写了一套 Go 的切片工具库，特此分享一下~~运行命令下载代码包 在项目中导入 操作类函数 Foreach 遍历切片中的元素 Map 切片内元素转换 Filter 切片元素过滤器 Reduce 切片元素累加器（未实现初始值） 查找类函数 Find 查找切片内第一个满足条件的元素 FindIndex 查找切片内第一个满足条件元素的索引值
golang入门笔记—ES
qq_43716830的博客
04-16 3537
ES参考网站 ES的介绍： Elasticsearch（ES）是一个基于Lucene构建的开源、分布式、RESTful接口的全文搜索引擎。Elasticsearch还是一个分布式文档数据库，其中每个字段均可被索引，而且每个字段的数据均可被搜索，ES能够横向扩展至数以百计的服务器存储以及处理PB级的数据。可以在极短的时间内存储、搜索和分析大量的数据。通常作为具有复杂搜索场景情况下的核心发动机。 ES的基本概念： 1.当你经营一家网上商店，你可以让你的客户搜索你卖的商品。在这种情况下，你可以使用Elastic
Golang操作ES全系列（olivere & curl操作es）
最新发布
weixin_45565886的博客
07-13 703
Golang操作ES全系列（olivere & curl操作es）
golang学习之go连接ElasticSearch
weixin_56349119的博客
11-23 3093
go 连接es
6、golang 的ORM之xorm案例
qq_41971768的博客
11-18 492
0 环境准备 安装xorm驱动 go get github.com/go-xorm/xorm 安装MySQL驱动 go get github.com/go-sql-driver/mysql 1 创建数据库连接 database.go /** * @Author: songlin.lu * @Date: 2020/11/18 12:47 */ package model import ( "fmt" _ "github.com/go-sql-driver/mysql" "
golang实战使用gin+xorm搭建go语言web框架详解.rar
05-23
在本文中，我们将深入探讨如何使用Gin和XORM这两个流行的开源库来构建Go语言的Web应用程序框架。Gin是一个高效、简洁的Web框架，它提供了丰富的中间件支持，而XORM则是一个轻量级的ORM（对象关系映射）库，能够简化...
golang 执行sql语句_xorm执行sql语句
weixin_39565777的博客
12-22 1646
package mainimport ("fmt"_ "github.com/go-sql-driver/mysql""github.com/go-xorm/xorm")var (engine *xorm.Engine)func main() {//数据库连接参数params := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8&parseTime=t...
golang. xorm中文手册
01-10
xorm是一个简单而强大的Go语言ORM库. 通过它可以使数据库操作非常简便。xorm的目标并不是让你完全不去学习SQL，我 们认为SQL并不会为ORM所替代，但是ORM将可以解决绝大部分的简单SQL需求。xorm支持两种风格的混用。
Golang XORM实现分布式链路追踪（源码分析，分布式CRUD必学）
Avtionの秘密房间
08-13 1206
使用XORM和Opentracing，让你彻彻底底摆脱繁琐的CRUD的阴影，将工作重心转移至业务逻辑
goja:纯Go中的ECMAScriptJavaScript引擎
04-28
戈雅 Go中的ECMAScript 5.1（+）实现。 Goja是纯Go中ECMAScript 5.1的实现，着重于标准合规性和性能。 这个项目很大程度上是受启发的。 最低要求的Go版本是1.14。 特征 全面的ECMAScript 5.1支持（包括正则表达式和严格模式）。 通过几乎所有带有es5id标签的。 目标是通过所有这些。 请注意，当前的工作提交是 。 下一次提交删除了大多数es5id标记，这使得无法区分要运行的测试。 能够运行Babel，Typescript编译器以及几乎所有用ES5编写的内容。 源图。 一些ES6功能仍在进行中，请参阅 已知的不兼容性和警告 弱地图 WeakMap是通过将对值的引用嵌入键中来实现的。 这意味着，只要密钥可访问，任何弱映射中与该密钥关联的所有值也将保持可访问状态，因此即使在WeakMap消失之后，即使未进行其他引用也无法对其进行垃圾回
golang 使用 elasticsearch ik 分词器
转身那一瞬
12-01 1897
golang 使用 elasticsearch https://github.com/olivere/elastic/wiki https://github.com/olivere/elastic ik分词器 https://github.com/medcl/elasticsearch-analysis-ik 安装 参照词表找对应的 ik 版本 IK version ES version master 7.x -> master 6.x 6.x 5.x 5.x 1.10
Go最新ES实战--mapping，Golang入门基础
2401_84925558的博客
05-16 403
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！curl -s -XPUT "ADDRESS/get−together"−H"Content−Type:application/json"−d@ADDRESS/
57.Go操作ES（官方提供github.com/elastic/go-elasticsearch库）
YouMing_Li的博客
12-16 2114
是官方提供的Go客户端。每个版本会有一个对应的版本。官方会维护最近的两个主要版本。提供了Low-level和两套API。本文以为例介绍的常用方法。本文接下来将以电商平台 “用户评价” 数据为例，演示Go语言客户端的相关操作。
发现一个高逼格的golang“构造函数”写法
嘿嘿
07-11 8795
1.最近看grpc的源码，发现了里面一种高逼格的构造函数的写法，表示震惊，学到了新姿势。package main import ( "fmt" ) type options struct { a int64 b string c map[int]string } func NewOption(opt ...ServerOption) *options { ...
golang操作ES
Man_ge的博客
12-06 1206
目前golang操作elasticsearch的第三方包中最流行的是：https://github.com/olivere/elastic7.x 7.0 github.com/olivere/elastic/v7 6.x 6.0 github.com/olivere/elastic 5.x 5.0 gopkg.in/olivere/elastic.v5 例如：ES版本是7.0以后的版本，就使用github.com/olivere/elastic/v7这个包地址。
Go操作Elasticsearch总结
xmcy001122的专栏
09-28 1571
Go操作Elasticsearch总结 安装 参见：CentOS 7 RPM安装 Elasticsearch 7.14.1和常用插件 官方入门例子 《Elasticsearch：权威指南》“适应新环境” 通过一个例子，介绍了ES的核心概念。 我们受雇于 Megacorp 公司，作为 HR 部门新的 “热爱无人机” （“We love our drones!”）激励项目的一部分，我们的任务是为此创建一个员工目录。该目录应当能培养员工认同感及支持实时、高效、动态协作，因此有一些业务需求： 支持包含多值标签
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值