Go搜索引擎Elasticsearch与Meilisearch的实现

package search

import (
	"context"
	"encoding/json"
	"errors"
	"log"
	"strconv"
	"time"

	"github.com/olivere/elastic/v7"
)

// Product 商品结构体
type Product struct {
	ID        int64   `json:"id"`         // 商品ID
	Name      string  `json:"name"`       // 商品名称，全文搜索
	Brand     string  `json:"brand"`      // 品牌，精确匹配
	Category  string  `json:"category"`   // 分类，聚合
	Price     float64 `json:"price"`      // 价格，范围过滤
	Sales     int     `json:"sales"`       // 销量，排序
	CreatedAt string  `json:"created_at"` // 创建时间
}

// ESClient Elasticsearch客户端封装
type ESClient struct {
	client *elastic.Client // olivere/elastic客户端
}

// NewESClient 创建ES客户端
// url: ES地址，如"http://127.0.0.1:9200"
func NewESClient(url string) (*ESClient, error) {
	// 创建客户端，设置超时和重试
	client, err := elastic.NewClient(
		elastic.SetURL(url),
		// 请求超时10秒
		elastic.SetTimeout(10*time.Second),
		// 健康检查
		elastic.SetSniff(false),
		// 错误日志
		elastic.SetErrorLog(log.Default()),
	)
	if err != nil {
		return nil, err
	}
	return &ESClient{client: client}, nil
}

// CreateIndex 创建商品索引
// indexName: 索引名，如"products"
func (c *ESClient) CreateIndex(ctx context.Context, indexName string) error {
	// 先检查索引是否已存在
	exists, err := c.client.IndexExists(indexName).Do(ctx)
	if err != nil {
		return err
	}
	if exists {
		return errors.New("索引已存在: " + indexName)
	}

	// 定义mapping，指定每个字段的类型
	mapping := `{
		"mappings": {
			"properties": {
				"id":        { "type": "long" },
				"name":      { "type": "text", "analyzer": "ik_max_word", "search_analyzer": "ik_smart" },
				"brand":     { "type": "keyword" },
				"category":  { "type": "keyword" },
				"price":     { "type": "double" },
				"sales":     { "type": "integer" },
				"created_at":{ "type": "date" }
			}
		}
	}`

	// 创建索引并应用mapping
	_, err = c.client.CreateIndex(indexName).Body(mapping).Do(ctx)
	return err
}

// IndexDoc 写入单个文档
// indexName: 索引名
// doc: 商品文档
func (c *ESClient) IndexDoc(ctx context.Context, indexName string, doc *Product) error {
	// 用商品ID作为文档ID，保证幂等
	_, err := c.client.Index().
		Index(indexName).
		Id(strconv.FormatInt(doc.ID, 10)).
		BodyJson(doc).
		Do(ctx)
	return err
}

// BulkIndex 批量写入文档
// 批量写入比逐条写入快很多，减少网络往返
func (c *ESClient) BulkIndex(ctx context.Context, indexName string, docs []*Product) error {
	// 创建批量处理器
	bulk := c.client.Bulk()
	for _, doc := range docs {
		// 每个文档一个Index请求
		req := elastic.NewBulkIndexRequest().
			Index(indexName).
			Doc(doc)
		bulk = bulk.Add(req)
	}
	// 一次性提交
	_, err := bulk.Do(ctx)
	return err
}

// SearchResult 搜索结果
type SearchResult struct {
	Total int64      `json:"total"` // 总匹配数
	Items []*Product `json:"items"` // 商品列表
	Brands map[string]int64 `json:"brands"` // 品牌聚合
}

// SearchProducts 搜索商品
// keyword: 搜索关键词
// minPrice, maxPrice: 价格区间
// brand: 品牌过滤，空则不过滤
// from, size: 分页
func (c *ESClient) SearchProducts(ctx context.Context, indexName, keyword string,
	minPrice, maxPrice float64, brand string, from, size int) (*SearchResult, error) {
	// 构造bool查询
	boolQuery := elastic.NewBoolQuery()

	// 关键词全文搜索，放在must里参与评分
	if keyword != "" {
		matchQuery := elastic.NewMatchQuery("name", keyword)
		boolQuery = boolQuery.Must(matchQuery)
	}

	// 价格区间过滤，放在filter里不参与评分
	priceRange := elastic.NewRangeQuery("price").
		Gte(minPrice).
		Lte(maxPrice)
	boolQuery = boolQuery.Filter(priceRange)

	// 品牌精确匹配
	if brand != "" {
		brandTerm := elastic.NewTermQuery("brand", brand)
		boolQuery = boolQuery.Filter(brandTerm)
	}

	// 构造搜索请求
	search := c.client.Search().
		Index(indexName).
		Query(boolQuery).
		From(from). // 分页起始位置
		Size(size). // 每页数量
		// 按销量降序，销量相同按价格升序
		Sort("sales", false).
		Sort("price", true)

	// 添加品牌聚合，统计每个品牌的商品数量
	brandAgg := elastic.NewTermsAggregation().Field("brand")
	search = search.Aggregation("brands", brandAgg)

	// 执行搜索
	res, err := search.Do(ctx)
	if err != nil {
		return nil, err
	}

	// 解析结果
	result := &SearchResult{
		Total: res.TotalHits(),
		Items: make([]*Product, 0),
		Brands: make(map[string]int64),
	}

	// 遍历命中文档
	for _, hit := range res.Hits.Hits {
		var p Product
		if err := json.Unmarshal(hit.Source, &p); err != nil {
			continue
		}
		result.Items = append(result.Items, &p)
	}

	// 解析聚合结果
	if brands, found := res.Aggregations.Terms("brands"); found {
		for _, bucket := range brands.Buckets {
			result.Brands[bucket.Key.(string)] = bucket.DocCount
		}
	}

	return result, nil
}

package search

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

// MeiliClient Meilisearch客户端
type MeiliClient struct {
	url   string // Meilisearch地址
	key   string // API密钥
	http  *http.Client // HTTP客户端
}

// NewMeiliClient 创建Meilisearch客户端
// url: 地址，如"http://127.0.0.1:7700"
// key: API密钥，无鉴权可传空
func NewMeiliClient(url, key string) *MeiliClient {
	return &MeiliClient{
		url:  url,
		key:  key,
		http: &http.Client{Timeout: 10 * time.Second},
	}
}

// AddDocuments 批量添加文档
// index: 索引名
// docs: 文档列表，自动序列化JSON
func (c *MeiliClient) AddDocuments(ctx context.Context, index string, docs interface{}) error {
	// 序列化文档列表
	body, err := json.Marshal(docs)
	if err != nil {
		return err
	}

	// 构造请求
	url := fmt.Sprintf("%s/indexes/%s/documents", c.url, index)
	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(body))
	if err != nil {
		return err
	}
	req.Header.Set("Content-Type", "application/json")
	if c.key != "" {
		req.Header.Set("Authorization", "Bearer "+c.key)
	}

	// 发送请求
	resp, err := c.http.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	return nil
}

// Search 执行搜索
// query: 搜索关键词
// filter: 过滤表达式，如"price >= 50 AND price <= 200"
// limit: 返回数量
func (c *MeiliClient) Search(ctx context.Context, index, query, filter string, limit int) (map[string]interface{}, error) {
	// 构造搜索请求体
	searchReq := map[string]interface{}{
		"q": query,
		"limit": limit,
	}
	if filter != "" {
		searchReq["filter"] = filter
	}

	body, _ := json.Marshal(searchReq)
	url := fmt.Sprintf("%s/indexes/%s/search", c.url, index)
	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(body))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")
	if c.key != "" {
		req.Header.Set("Authorization", "Bearer "+c.key)
	}

	resp, err := c.http.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	// 解析响应
	var result map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&result)
	return result, nil
}

// UpdateSearchableAttributes 设置可搜索字段
// 默认所有字段都可搜索，指定后只搜索指定字段
func (c *MeiliClient) UpdateSearchableAttributes(ctx context.Context, index string, fields []string) error {
	body, _ := json.Marshal(map[string]interface{}{"searchableAttributes": fields})
	url := fmt.Sprintf("%s/indexes/%s/settings", c.url, index)
	req, _ := http.NewRequestWithContext(ctx, "PATCH", url, bytes.NewReader(body))
	req.Header.Set("Content-Type", "application/json")
	if c.key != "" {
		req.Header.Set("Authorization", "Bearer "+c.key)
	}
	resp, err := c.http.Do(req)
	if err != nil {
		return err
	}
	resp.Body.Close()
	return nil
}

// 错误的mapping，price设成了text
badMapping := `{
	"mappings": {
		"properties": {
			"name":  { "type": "text" },
			"price": { "type": "text" }
		}
	}
}`

// 修复步骤: 删除旧索引，用正确mapping重建
func (c *ESClient) FixMapping(ctx context.Context, indexName string) error {
	// 删除旧索引
	_, err := c.client.DeleteIndex(indexName).Do(ctx)
	if err != nil {
		// 索引不存在不算错误
		log.Printf("删除索引: %v", err)
	}

	// 用正确的mapping重建
	// price必须是double或scaled_float类型
	mapping := `{
		"mappings": {
			"properties": {
				"name":  { "type": "text", "analyzer": "ik_max_word" },
				"price": { "type": "double" },
				"brand": { "type": "keyword" }
			}
		}
	}`
	_, err = c.client.CreateIndex(indexName).Body(mapping).Do(ctx)
	return err
}

// multi-field: name既能全文搜索又能精确匹配
multiMapping := `{
	"mappings": {
		"properties": {
			"name": {
				"type": "text",
				"analyzer": "ik_max_word",
				"fields": {
					"keyword": { "type": "keyword" }
				}
			}
		}
	}
}`