ZincSearch电商搜索实现

发布时间: 2025-04-08 10:47

↑

# ZincSearch电商搜索实现

本文将详细介绍如何使用ZincSearch构建电商搜索系统，包括商品搜索、分类筛选、排序等核心功能的实现。

## 系统架构

### 1. 核心组件

- 数据采集层：商品数据同步
- 搜索引擎层：ZincSearch服务
- 应用服务层：搜索API
- 前端展示层：搜索界面

### 2. 数据流程

1. 数据同步
   - 商品数据更新
   - 实时同步
   - 批量导入

2. 搜索处理
   - 查询解析
   - 结果排序
   - 数据聚合

## 索引设计

### 1. 商品索引创建

```bash
curl -X PUT -H "Content-Type: application/json" \
  http://localhost:4080/api/index -d '{
  "name": "products",
  "mappings": {
    "properties": {
      "id": { "type": "keyword" },
      "name": { "type": "text" },
      "description": { "type": "text" },
      "category": { "type": "keyword" },
      "brand": { "type": "keyword" },
      "price": { "type": "float" },
      "stock": { "type": "integer" },
      "sales": { "type": "integer" },
      "rating": { "type": "float" },
      "tags": { "type": "keyword" },
      "attributes": { "type": "object" },
      "created_at": { "type": "date" },
      "updated_at": { "type": "date" }
    }
  }
}'
```

### 2. 数据导入

```python
class ProductImporter:
    def __init__(self, zinc_url):
        self.zinc_url = zinc_url
    
    def import_products(self, products):
        batch = []
        for product in products:
            batch.extend([
                {"index": {"_index": "products", "_id": product['id']}},
                {
                    "name": product['name'],
                    "description": product['description'],
                    "category": product['category'],
                    "brand": product['brand'],
                    "price": float(product['price']),
                    "stock": int(product['stock']),
                    "sales": int(product['sales']),
                    "rating": float(product['rating']),
                    "tags": product['tags'],
                    "attributes": product['attributes'],
                    "created_at": product['created_at'],
                    "updated_at": product['updated_at']
                }
            ])
        
        response = requests.post(
            f"{self.zinc_url}/api/_bulk",
            json=batch,
            headers={'Content-Type': 'application/json'}
        )
        return response.json()
```

## 搜索功能实现

### 1. 基础搜索

```python
def search_products(query, page=1, size=20):
    search_body = {
        "search_type": "match",
        "query": {
            "term": query,
            "field": "name"
        },
        "from": (page - 1) * size,
        "size": size
    }
    
    response = requests.post(
        "http://localhost:4080/api/products/_search",
        json=search_body
    )
    return response.json()
```

### 2. 高级筛选

```python
def advanced_search(params):
    search_body = {
        "search_type": "bool",
        "query": {
            "must": [],
            "filter": []
        }
    }
    
    # 关键词搜索
    if params.get('keyword'):
        search_body['query']['must'].append({
            "match": {
                "name": params['keyword']
            }
        })
    
    # 分类筛选
    if params.get('category'):
        search_body['query']['filter'].append({
            "term": {
                "category": params['category']
            }
        })
    
    # 价格区间
    if params.get('price_min') or params.get('price_max'):
        price_range = {
            "range": {
                "field": "price",
                "gte": params.get('price_min'),
                "lte": params.get('price_max')
            }
        }
        search_body['query']['filter'].append(price_range)
    
    return requests.post(
        "http://localhost:4080/api/products/_search",
        json=search_body
    ).json()
```

### 3. 排序功能

```python
def sort_products(query, sort_field, sort_order='desc'):
    search_body = {
        "search_type": "match",
        "query": {
            "term": query,
            "field": "name"
        },
        "sort": [
            {
                "field": sort_field,
                "order": sort_order
            }
        ]
    }
    
    return requests.post(
        "http://localhost:4080/api/products/_search",
        json=search_body
    ).json()
```

## 性能优化

### 1. 索引优化

```python
def optimize_index():
    # 合并段文件
    requests.post("http://localhost:4080/api/products/_forcemerge")
    
    # 刷新索引
    requests.post("http://localhost:4080/api/products/_refresh")
```

### 2. 查询优化

```python
def optimize_search(query):
    # 使用缓存
    search_body = {
        "search_type": "match",
        "query": {
            "term": query,
            "field": "name"
        },
        "cache": True,
        "cache_ttl": "5m"
    }
    
    return requests.post(
        "http://localhost:4080/api/products/_search",
        json=search_body
    ).json()
```

## 搜索API实现

### 1. FastAPI示例

```python
from fastapi import FastAPI, Query
from typing import Optional

app = FastAPI()

@app.get("/api/search")
async def search(
    q: str = Query(..., description="搜索关键词"),
    category: Optional[str] = None,
    price_min: Optional[float] = None,
    price_max: Optional[float] = None,
    sort: Optional[str] = None,
    page: int = 1,
    size: int = 20
):
    search_params = {
        "keyword": q,
        "category": category,
        "price_min": price_min,
        "price_max": price_max,
        "page": page,
        "size": size
    }
    
    results = advanced_search(search_params)
    
    if sort:
        results = sort_products(q, sort)
    
    return results
```

### 2. 搜索建议

```python
@app.get("/api/suggest")
async def suggest(q: str = Query(..., description="搜索前缀")):
    suggest_body = {
        "search_type": "prefix",
        "query": {
            "prefix": q,
            "field": "name"
        },
        "size": 5
    }
    
    response = requests.post(
        "http://localhost:4080/api/products/_search",
        json=suggest_body
    )
    
    suggestions = [hit['name'] for hit in response.json()['hits']['hits']]
    return {"suggestions": suggestions}
```

## 前端实现

### 1. 搜索组件

```javascript
// SearchBox.js
import React, { useState } from 'react';

const SearchBox = ({ onSearch }) => {
  const [query, setQuery] = useState('');
  const [suggestions, setSuggestions] = useState([]);

const handleSearch = async () => {
    const response = await fetch(`/api/search?q=${query}`);
    const results = await response.json();
    onSearch(results);
  };

return (
    <div className="search-box">
      <input
        type="text"
        value={query}
        onChange={(e) => {
          setQuery(e.target.value);
          handleSuggest(e.target.value);
        }}
        placeholder="搜索商品"
      />
      <button onClick={handleSearch}>搜索</button>
      {suggestions.length > 0 && (
        <ul className="suggestions">
          {suggestions.map((suggestion, index) => (
            <li
              key={index}
              onClick={() => {
                setQuery(suggestion);
                setSuggestions([]);
                handleSearch();
              }}
            >
              {suggestion}
            </li>
          ))}
        </ul>
      )}
    </div>
  );
};

export default SearchBox;
```

### 2. 筛选组件

```javascript
// FilterPanel.js
import React from 'react';

const FilterPanel = ({ categories, onFilter }) => {
  const [filters, setFilters] = useState({
    category: '',
    priceMin: '',
    priceMax: ''
  });

const handleFilter = () => {
    onFilter(filters);
  };

return (
    <div className="filter-panel">
      <select
        value={filters.category}
        onChange={(e) => setFilters({ ...filters, category: e.target.value })}
      >
        <option value="">所有分类</option>
        {categories.map(category => (
          <option key={category} value={category}>{category}</option>
        ))}
      </select>

<div className="price-range">
        <input
          type="number"
          placeholder="最低价"
          value={filters.priceMin}
          onChange={(e) => setFilters({ ...filters, priceMin: e.target.value })}
        />
        <span>-</span>
        <input
          type="number"
          placeholder="最高价"
          value={filters.priceMax}
          onChange={(e) => setFilters({ ...filters, priceMax: e.target.value })}
        />
      </div>

<button onClick={handleFilter}>应用筛选</button>
    </div>
  );
};

export default FilterPanel;
```

## 最佳实践

1. 索引设计
   - 合理设计字段类型
   - 优化分词器配置
   - 控制索引大小

2. 查询优化
   - 使用合适的查询类型
   - 实施查询缓存
   - 控制返回字段

3. 用户体验
   - 实现搜索建议
   - 优化响应速度
   - 提供筛选功能

## 常见问题

1. 性能问题
   - 优化索引结构
   - 使用查询缓存
   - 控制数据量

2. 准确性问题
   - 改进分词策略
   - 优化相关性算法
   - 增加同义词支持

元素码农