Elasticsearch在优惠券APP搜索中的性能优化实践

1. 优惠券省钱APP的搜索性能挑战

在优惠券省钱类应用中，搜索功能是用户最核心的使用场景之一。用户期望能够通过关键词、价格区间、佣金比例、销量排序、是否包邮等多维度条件快速筛选出最优商品。然而，传统的MySQL LIKE模糊查询在面对千万级甚至亿级商品库时，性能表现往往不尽如人意。

1.1 传统方案的局限性

使用MySQL进行商品搜索存在几个明显的问题：

1. 模糊查询效率低下：LIKE '%keyword%'这种查询无法利用索引，会导致全表扫描
2. 分词能力缺失：无法支持中文分词，搜索结果不精准
3. 复杂查询性能差：多条件组合查询时，即使每个字段都有索引，MySQL的查询优化器也难以高效执行
4. 排序性能瓶颈：当需要对大量数据进行排序时，性能急剧下降

1.2 业务需求分析

我们的优惠券省钱APP需要满足以下核心搜索需求：

• 支持中文分词搜索，能够理解"苹果手机"这样的复合关键词
• 支持多条件组合筛选（平台、价格区间、佣金比例、是否有券等）
• 支持多种排序方式（按销量、价格、佣金比例等）
• 响应时间控制在毫秒级，即使在海量数据下也要保持稳定
• 搜索结果实时更新，新上架商品或价格变动要立即反映在搜索结果中

2. 技术选型与架构设计

2.1 为什么选择Elasticsearch

Elasticsearch作为分布式搜索引擎，完美解决了我们面临的性能问题：

1. 倒排索引：基于词项的索引结构，支持毫秒级全文检索
2. 分词能力：内置多种分词器，支持中文分词（如IK分词器）
3. 复杂查询：支持布尔查询、范围查询、聚合查询等多种查询方式
4. 分布式架构：天然支持水平扩展，可以处理海量数据
5. 排序性能：基于doc_values的列式存储，排序性能优异

2.2 整体架构设计

我们采用以下架构实现高性能搜索：

code复制MySQL(主数据存储) → Canal(Binlog监听) → RocketMQ/Kafka(消息队列) → 数据同步服务 → Elasticsearch(搜索引擎) → 应用服务

这种架构的优势在于：

1. 实时性：通过监听MySQL的Binlog变化，实现数据的准实时同步
2. 解耦：引入消息队列作为缓冲，避免直接对MySQL造成压力
3. 弹性：各组件都可以独立扩展，应对流量增长

3. Elasticsearch索引设计与优化

3.1 索引映射设计

合理的索引设计是搜索性能的基础。我们为商品数据设计了如下映射：

json复制PUT /juwatech_products
{
  "settings": {
    "number_of_shards": 5,
    "number_of_replicas": 1,
    "analysis": {
      "analyzer": {
        "ik_max_word_analyzer": {
          "type": "custom",
          "tokenizer": "ik_max_word"
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "productId": { "type": "keyword" },
      "title": { 
        "type": "text", 
        "analyzer": "ik_max_word_analyzer",
        "search_analyzer": "ik_smart"
      },
      "platform": { "type": "keyword" }, 
      "currentPrice": { "type": "double", "doc_values": true },
      "originalPrice": { "type": "double" },
      "commissionRate": { "type": "double", "doc_values": true },
      "monthlySales": { "type": "integer", "doc_values": true },
      "couponAmount": { "type": "double" },
      "hasCoupon": { "type": "boolean" },
      "createTime": { "type": "date" },
      "tags": { "type": "keyword" }
    }
  }
}

设计要点说明：

1. 扁平化结构：将所有搜索需要的字段冗余存储在一个文档中，避免关联查询
2. 分词配置：使用IK分词器进行中文分词，搜索时使用ik_smart模式提高精准度
3. doc_values：为需要排序和聚合的字段启用doc_values，提升排序性能
4. 分片策略：根据数据量预估设置合适的分片数（我们设置为5个主分片）

3.2 索引性能优化

为了提升索引性能，我们做了以下优化：

1. 批量写入：通过Canal收集变更后批量写入ES，减少IO次数
2. Refresh Interval调整：将默认的1秒调整为30秒，减少Segment合并压力
3. 禁用_all字段：在ES 7.x版本后，_all字段已被移除，我们明确指定需要搜索的字段
4. 合理设置副本数：在写入压力大时，可以暂时减少副本数甚至设为0，写入完成后再恢复

4. 实时数据同步实现

4.1 Canal工作原理

Canal是阿里开源的一款基于MySQL数据库增量日志解析的工具，其核心原理是：

1. 模拟MySQL Slave的交互协议，伪装自己为MySQL Slave
2. 向MySQL Master发送dump协议
3. MySQL Master接收到dump请求，开始推送binary log给Slave(也就是Canal)
4. Canal解析binary log对象(原始为byte流)

4.2 数据同步实现

我们通过以下Java代码实现Canal消息的处理：

java复制package juwatech.cn.search.sync.consumer;

import com.alibaba.otter.canal.protocol.CanalEntry;
import com.fasterxml.jackson.databind.ObjectMapper;
import juwatech.cn.search.model.ProductDocument;
import juwatech.cn.search.service.ElasticsearchService;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.common.message.MessageExt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class CanalSyncConsumer implements MessageListenerConcurrently {

    @Autowired
    private ElasticsearchService esService;
    
    private final ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext context) {
        for (MessageExt msg : msgs) {
            try {
                // 解析Canal协议数据
                CanalEntry.Entry entry = CanalEntry.Entry.parseFrom(msg.getBody());
                if (entry.getEntryType() != CanalEntry.EntryType.ROWDATA) {
                    continue;
                }
                
                CanalEntry.RowChange rowChange = CanalEntry.RowChange.parseFrom(entry.getStoreValue());
                String tableName = entry.getHeader().getTableName();
                
                if ("t_product".equals(tableName)) {
                    if (rowChange.getEventType() == CanalEntry.EventType.INSERT || 
                        rowChange.getEventType() == CanalEntry.EventType.UPDATE) {
                        
                        // 构建ES文档
                        ProductDocument doc = buildProductDocument(rowChange.getRowDatasList().get(0).getAfterColumnsList());
                        esService.indexProduct(doc);
                        
                    } else if (rowChange.getEventType() == CanalEntry.EventType.DELETE) {
                        String productId = extractId(rowChange.getRowDatasList().get(0).getBeforeColumnsList());
                        esService.deleteProduct(productId);
                    }
                }
            } catch (Exception e) {
                // juwatech.cn.log.ErrorLogger.error("Canal sync failed", e);
                return ConsumeConcurrentlyStatus.RECONSUME_LATER;
            }
        }
        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
    }

    private ProductDocument buildProductDocument(List<CanalEntry.Column> columns) {
        ProductDocument doc = new ProductDocument();
        // 解析列映射逻辑略，需遍历columns设置doc属性
        // juwatech.cn.search.util.ColumnMapper.map(columns, doc);
        return doc;
    }
    
    private String extractId(List<CanalEntry.Column> columns) {
        // 提取主键逻辑
        return "123456";
    }
}

4.3 同步方案对比

我们对比了几种常见的数据同步方案：

最终选择Canal+MQ方案的原因：

1. 对业务代码无侵入
2. 性能影响小
3. 实时性好
4. 支持失败重试

5. 复杂查询实现与优化

5.1 多条件组合查询

在APP端，用户可能组合多个条件进行搜索，例如："查找京东平台、价格在50-100元、佣金率大于20%、有优惠券的商品，并按销量降序排列"。我们通过以下Java代码实现：

java复制package juwatech.cn.search.service;

import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.SortOrder;
import co.elastic.clients.elasticsearch._types.query_dsl.Query;
import co.elastic.clients.elasticsearch.core.SearchRequest;
import co.elastic.clients.elasticsearch.core.SearchResponse;
import co.elastic.clients.json.JsonData;
import juwatech.cn.search.model.ProductDocument;
import juwatech.cn.search.model.SearchCriteria;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@Service
public class ElasticsearchService {

    @Autowired
    private ElasticsearchClient esClient;

    /**
     * 执行多维度复合查询
     */
    public List<ProductDocument> searchProducts(SearchCriteria criteria) throws IOException {
        List<Query> mustQueries = new ArrayList<>();
        List<Query> filterQueries = new ArrayList<>();

        // 1. 全文检索（关键词）
        if (criteria.getKeyword() != null && !criteria.getKeyword().isEmpty()) {
            mustQueries.add(Query.of(q -> q.match(m -> m.field("title").query(criteria.getKeyword()))));
        }

        // 2. 精确过滤（平台、是否有券）
        if (criteria.getPlatform() != null) {
            filterQueries.add(Query.of(q -> q.term(t -> t.field("platform").value(criteria.getPlatform()))));
        }
        if (Boolean.TRUE.equals(criteria.getHasCoupon())) {
            filterQueries.add(Query.of(q -> q.term(t -> t.field("hasCoupon").value(true))));
        }

        // 3. 范围过滤（价格、佣金率）
        if (criteria.getMinPrice() != null || criteria.getMaxPrice() != null) {
            filterQueries.add(Query.of(q -> q.range(r -> r.field("currentPrice")
                .gte(JsonData.of(criteria.getMinPrice() != null ? criteria.getMinPrice() : 0))
                .lte(JsonData.of(criteria.getMaxPrice() != null ? criteria.getMaxPrice() : Double.MAX_VALUE))
            )));
        }

        if (criteria.getMinCommissionRate() != null) {
            filterQueries.add(Query.of(q -> q.range(r -> r.field("commissionRate")
                .gte(JsonData.of(criteria.getMinCommissionRate()))
            )));
        }

        // 构建Bool查询
        Query boolQuery = Query.of(q -> q.bool(b -> {
            if (!mustQueries.isEmpty()) b.must(mustQueries);
            if (!filterQueries.isEmpty()) b.filter(filterQueries);
            return b;
        }));

        // 4. 排序
        var sortOptions = new ArrayList<co.elastic.clients.elasticsearch._types.SortOptions>();
        if ("sales".equals(criteria.getSortBy())) {
            sortOptions.add(co.elastic.clients.elasticsearch._types.SortOptions.of(s -> s.field(f -> f.field("monthlySales").order(SortOrder.Desc))));
        } else if ("price_asc".equals(criteria.getSortBy())) {
            sortOptions.add(co.elastic.clients.elasticsearch._types.SortOptions.of(s -> s.field(f -> f.field("currentPrice").order(SortOrder.Asc))));
        } else {
            // 默认按相关性或时间排序
            sortOptions.add(co.elastic.clients.elasticsearch._types.SortOptions.of(s -> s.field(f -> f.field("createTime").order(SortOrder.Desc))));
        }

        SearchRequest request = SearchRequest.of(s -> s
            .index("juwatech_products")
            .query(boolQuery)
            .sort(sortOptions)
            .from((criteria.getPageNum() - 1) * criteria.getPageSize())
            .size(criteria.getPageSize())
        );

        SearchResponse<ProductDocument> response = esClient.search(request, ProductDocument.class);
        
        // juwatech.cn.log.SearchLogger.info("Search executed in {} ms", response.took());
        
        return response.hits().hits().stream()
            .map(h -> h.source())
            .toList();
    }
    
    public void indexProduct(ProductDocument doc) throws IOException {
        esClient.index(i -> i.index("juwatech_products").id(doc.getProductId()).document(doc));
    }
    
    public void deleteProduct(String id) throws IOException {
        esClient.delete(d -> d.index("juwatech_products").id(id));
    }
}

5.2 查询性能优化

为了提升查询性能，我们采取了以下措施：

1. 合理使用查询类型：

   • 对于精确匹配使用term查询
   • 对于全文检索使用match查询
   • 对于范围查询使用range查询
   • 对于多条件组合使用bool查询

2. 区分must和filter：

   • must子句参与相关性评分
   • filter子句不参与评分，可以利用缓存

3. 分页优化：

   • 避免使用深度分页（from+size方式）
   • 对于深度分页需求，使用search_after方式

4. 路由优化：

   • 对于特定大V推广的商品，使用自定义Routing Key
   • 将相关数据集中在特定分片，减少查询时需要访问的分片数

6. 高可用与缓存策略

6.1 高可用保障

为了确保搜索服务的高可用性，我们实施了以下措施：

1. ES集群部署：

   • 至少3个master节点，防止脑裂
   • 多个data节点，根据数据量和查询负载动态扩展
   • 每个索引配置至少1个副本，防止数据丢失

2. 故障转移：

   • 配置多个ES客户端节点，自动重试失败的请求
   • 监控集群健康状态，自动剔除问题节点

3. 限流保护：

   • 在应用层实现查询限流，防止突发流量打垮集群
   • 对于复杂查询限制并发数

6.2 缓存策略

为了进一步提升性能，我们实现了多级缓存：

1. 应用层缓存：使用Caffeine缓存热门查询结果

java复制package juwatech.cn.search.cache;

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import juwatech.cn.search.model.ProductDocument;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Component
public class SearchCache {
    private final Cache<String, List<ProductDocument>> cache = Caffeine.newBuilder()
        .maximumSize(10000)
        .expireAfterWrite(1, TimeUnit.MINUTES)
        .build();

    public List<ProductDocument> get(String key) {
        return cache.getIfPresent(key);
    }

    public void put(String key, List<ProductDocument> data) {
        cache.put(key, data);
    }
}

2. ES查询缓存：利用ES自身的查询缓存
3. 请求合并：对于短时间内相同的查询请求进行合并

缓存更新策略：

• 定时过期：设置合理的过期时间（如1分钟）
• 失效通知：当商品数据变更时，主动清除相关缓存

7. 监控与调优

7.1 关键指标监控

我们建立了完善的监控体系，重点关注以下指标：

1. 查询性能：

   • 平均响应时间
   • 慢查询比例
   • 查询错误率

2. 索引性能：

   • 索引延迟
   • 索引错误率
   • 索引队列积压

3. 系统资源：

   • CPU使用率
   • 内存使用情况
   • 磁盘IO

7.2 性能调优经验

在实际运行中，我们总结了一些调优经验：

1. JVM调优：

   • ES的JVM堆内存设置为物理内存的50%，不超过32GB
   • 使用G1垃圾回收器

2. 索引优化：

   • 定期执行_forcemerge，减少segment数量
   • 对于只读索引，设置index.blocks.write=true

3. 查询优化：

   • 避免使用script查询
   • 限制返回字段，只查询需要的字段
   • 使用docvalue_fields替代_source获取字段值

4. 硬件选择：

   • 使用SSD硬盘
   • 确保足够的内存，ES非常依赖文件系统缓存

8. 实施效果与经验总结

8.1 性能对比

优化前后的性能对比：

8.2 经验总结

在实施过程中，我们总结了以下经验教训：

1. 索引设计要前置：合理的索引设计是性能的基础，后期修改成本很高
2. 数据同步要考虑幂等性：网络抖动可能导致重复消息，处理逻辑要保证幂等
3. 监控要全面：不仅要监控ES本身，还要监控整个数据流水线
4. 容量规划很重要：根据业务增长预估数据量和查询量，提前规划集群规模
5. 版本升级要谨慎：ES不同版本间API变化较大，升级前要充分测试

8.3 后续优化方向

未来我们计划在以下方面继续优化：

1. 引入NLP：提升搜索相关性，理解用户搜索意图
2. 个性化推荐：基于用户历史行为优化搜索结果排序
3. 多集群架构：实现读写分离，进一步提升性能
4. 冷热数据分离：对历史数据使用不同的存储策略，降低成本