搜索功Neng早Yi不再是简单的“查字典”，而是成为了现代应用架构中不可或缺的心脏。你是否曾好奇，当你在电商网站输入“运动鞋”并按下回车的那一瞬间，系统是如何在毫秒级的时间内，从数以亿计的商品库中捞出你想要的结果？又或者，为什么传统的数据库在面对模糊查询时会显得力不从心，而Elasticsearch却Neng游刃有余？

今天我们不谈枯燥的API调用，而是要像拆解一台精密的钟表一样，一层层剥开ES的外壳，去探寻它那令人惊叹的底层逻辑。这不仅仅是一次技术原理的复盘，geng是一场关于速度与效率的思维碰撞。

一、 核心引擎：倒排索引的魔法

要理解ES的快， 得理解它到底存了什么。在关系型数据库的世界里数据是按行存储的，我们称之为“正排索引”。这就像是一本没有目录的书，Ru果你想找“北京”这个词出现在哪里你只Neng把整本书从头读到尾。这种全表扫描的代价，在海量数据面前是灾难性的。

而ES之所以Neng成为搜索界的扛把子，全靠它独门的秘籍——倒排索引。想象一下Ru果你把书里所有的词dou挑出来按字母顺序排好，并在每个词后面记下它出现在哪一页、哪一行，查找速度是不是就起飞了？这就是倒排索引的核心思想。

1.1 正排与倒排的博弈

让我们通过一个直观的对比来kankan两者的差异。在MySQL中，我们通过文档ID去找内容；而在ES中，我们通过词项去找文档ID列表。

┌─────────────────────────────────────────────────────────────────────┐
│                    正排索引 vs 倒排索引                              │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  正排索引：                                              │
│  ┌─────────┬───────────────────────────────────┐                    │
│  │  文档ID  │              文档内容              │                    │
│  ├─────────┼───────────────────────────────────┤                    │
│  │   1     │  我爱北京天安门                   │                    │
│  │   2     │  北京是中国的首dou                 │                    │
│  │   3     │  天安门在中国北京                 │                    │
│  └─────────┴───────────────────────────────────┘                    │
│  查询方式：文档ID → 文档内容                                          │
│                                                                      │
│  倒排索引：                                                │
│  ┌───────────┬───────────────────────────────┐                     │
│  │    词    │              文档ID              │                     │
│  ├───────────┼───────────────────────────────┤                     │
│  │    我    │                              │                     │
│  │   天安门  │                           │                     │
│  │   北京    │                        │                     │
│  │   中国    │                           │                     │
│  │   首dou    │                              │                     │
│  │   是      │                              │                     │
│  └───────────┴───────────────────────────────┘                     │
│  查询方式：词 → 包含该词的文档列表                                    │
│                                                                      │
│  优势：查询"北京"，直接返回，无需扫描全表！                    │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

kan到没？这就是效率的源泉。当你搜索“北京”时ES根本不需要去读文档内容，直接去词典里一查，立马就Neng知道文档1、2、3dou包含这个词。

1.2 倒排索引的精密结构

当然实际的生产环境远比这个例子复杂。ES的倒排索引内部其实是一套精密的组合拳，包含了词典、倒排表、以及为了加速查询而设计的各种数据结构。

┌─────────────────────────────────────────────────────────────────────┐
│                      倒排索引结构                                    │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  ┌────────────────────────────────────────────────────────────────┐ │
│  │                      Dictionary                          │ │
│  │  包含所有term，按字典序排列，支持二分查找                          │ │
│  └────────────────────────────────────────────────────────────────┘ │
│                              ↓                                        │
│  ┌────────────────────────────────────────────────────────────────┐ │
│  │                      Posting List                     │ │
│  │  每个term对应一个列表，记录包含该term的文档ID                     │ │
│  │                                         │ │
│  └────────────────────────────────────────────────────────────────┘ │
│                              ↓                                        │
│  ┌────────────────────────────────────────────────────────────────┐ │
│  │                      FST                          │ │
│  │  用于前缀查询，如"开*"匹配"开放"、"开始"                        │ │
│  └────────────────────────────────────────────────────────────────┘ │
│                                                                      │
│  ┌────────────────────────────────────────────────────────────────┐ │
│  │                      Skip List                          │ │
│  │  用于AND/OR运算加速，避免逐个遍历Posting List                    │ │
│  └────────────────────────────────────────────────────────────────┘ │
│                                                                      │
│  ┌────────────────────────────────────────────────────────────────┐ │
│  │                      Bitmap                              │ │
│  │  文档数量少时使用bitset存储，节省空间                          │ │
│  └────────────────────────────────────────────────────────────────┘ │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

这里特别值得一提的是FST。它是一种极其节省内存的结构，ES用它来把Term压缩存储在内存中。没有FST，你的内存可Neng早就爆了。而跳表则是为了解决多Term查询的问题，比如你要查“北京” AND “首dou”，它不需要遍历两个列表，而是像跳格子一样快速找到交集。

1.3 分词器：理解语言的桥梁

倒排索引虽好，但Ru果不懂人类的语言，也是白搭。这就不得不提分词器。ES怎么知道“程序员”和“码农”是一回事？怎么处理英文的时态？

分词器就像是一个翻译官，它接收原始文本，吐出一串Token。这个过程通常分为三步：字符过滤、分词、词元过滤。

// ES分词流程示例
"我是程序员，在北京工作"
     ↓
Analyzer处理
     ↓
/**
 * 分词器核心组件解析
 */
public class AnalyzerComponents {
    // 1. Character Filter
    // - HTML Strip：清洗HTML标签
    // - Mapping：字符映射
    // - Pattern Replace：正则替换特殊字符
    // 2. Tokenizer
    // - Standard：默认分词，按单词分割
    // - Keyword：不分词，整个字符串作为一个token
    // - Whitespace：按空格分割
    // - Punctuation：按标点分割
    // 3. Token Filter
    // - Lowercase：转小写
    // - Stop：去停用词
    // - Synonym：同义词处理
    // - Stemming：词干提取
}
// 自定义分词器配置示例
PUT /my_index
{
  "settings": {
    "analysis": {
      "char_filter": {
        "my_char_filter": {
          "type": "mapping",
          "mappings": 
        }
      },
      "tokenizer": {
        "my_tokenizer": {
          "type": "pattern",
          "pattern": "+"  // 按逗号和空格分割
        }
      },
      "filter": {
        "my_synonym": {
          "type": "synonym",
          "synonyms": 
        },
        "my_stopwords": {
          "type": "stop",
          "stopwords": 
        }
      },
      "analyzer": {
        "my_analyzer": {
          "type": "custom",
          "char_filter": ,
          "tokenizer": ,
          "filter": 
        }
      }
    }
  }
}

kan到那个同义词配置了吗？这就是让搜索变得“智Neng”的关键。Ru果你配置了“北京”和“帝dou”同义，用户搜“帝dou美食”时也Neng搜到标记为“北京”的文档，这体验，绝了。

二、 数据的栖息地：Shard与Segment

理解了索引，我们再来kankanES是怎么存数据的。ES是分布式的，这意味着数据被切成了hen多小块，散落在不同的机器上。这里有两个核心概念：分片和段。

2.1 ES的存储层级架构

一个Index被拆分成多个Shard，每个Shard其实就是一个Lucene Index。而Lucene Index内部，又是由多个Segment组成的。

┌─────────────────────────────────────────────────────────────────────┐
│                      ES数据存储架构                                 │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  Index                                                       │
│    ↓                                                                 │
│  ┌────────┬────────┬────────┐                                      │
│  │ Shard0 │ Shard1 │ Shard2 │  ← 主分片           │
│  │    │    │    │                                      │
│  └────────┴────────┴────────┘                                      │
│         ↓           ↓           ↓                                   │
│  ┌────────┬────────┬────────┐                                      │
│  │ Shard0 │ Shard1 │ Shard2 │  ← 副本分片        │
│  │    │    │    │                                      │
│  └────────┴────────┴────────┘                                      │
│                                                                      │
│  Shard = Lucene Index                                               │
│  ↓                                                                   │
│  ┌────────────────────────────────────────────────────────────────┐ │
│  │                    Segment                              │ │
│  │  每个Shard包含多个Segment                  │ │
│  │  新数据写入新Segment，查询时并行搜索所有Segment                  │ │
│  └────────────────────────────────────────────────────────────────┘ │
│                              ↓                                        │
│  ┌────────────────────────────────────────────────────────────────┐ │
│  │                    Document写入流程                             │ │
│  │  1. 写入内存Buffer                                             │ │
│  │  2. 写入translog                                  │ │
│  │  3. refresh后生成Segment                                       │ │
│  │  4. flush时清空Buffer和translog                                │ │
│  └────────────────────────────────────────────────────────────────┘ │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

为什么要搞这么复杂？因为不可变性。Segment一旦写入磁盘，就永远不会修改。这种设计带来了极高的读取性Neng，但也带来了新的问题：怎么geng新和删除？

其实ES的geng新和删除是“标记”操作。当你删除一个文档，ES只是在对应的Segment里记了一个“Yi删除”的标记。真正的物理删除，是在Segment合并的时候发生的。

2.2 文档写入的完整生命周期

当你发送一个PUT请求保存数据时后台发生了一系列惊心动魄的操作。

/**
 * 文档写入完整流程解析
 */
// 1. 客户端发起请求
PUT /my_index/_doc/1
{
  "name": "张三",
  "age": 25,
  "skills": 
}
// 2. 请求路由到主分片
// hash % number_of_shards = primary_shard
// 3. 主分片写入核心流程
/**
 * ┌─────────────────────────────────────────────────────────────────┐
 * │                    写入流程                                      │
 * │                                                                 │
 * │  1. 写入内存Buffer                            │
 * │          ↓                                                       │
 * │  2. 写入Translog               │
 * │          ↓                                                       │
 * │  3. 定期refresh                                       │
 * │     Buffer中的数据被写入新的Segment，此时变得可搜索               │
 * │          ↓                                                       │
 * │  4. Segment定期flush                                            │
 * │     内存Buffer清空，Translog清空                                 │
 * │          ↓                                                       │
 * │  5. Segment定期merge                                            │
 * │     多个小Segment合并成大Segment，清理Yi删除文档                 │
 * │                                                                 │
 * └─────────────────────────────────────────────────────────────────┘
 */
// 4. 并行复制到副本分片
// 只有所有副本dou写入成功，才算写入成功

这里有个关键点：Translog。在数据被刷新到磁盘之前，Ru果机器断电了怎么办？Translog就是救命稻草。它先记录操作日志，确保数据不丢失，然后再异步去写Segment。这就是ES为什么Neng提供准实时搜索的原因——数据写入1秒后就Neng搜到，但还没真正落盘。

2.3 Segment合并机制

随着数据不断写入，Segment会越来越多。文件多了查找就慢，而且还会占用大量文件句柄。所以ES后台有一个专门的线程负责把小Segment合并成大Segment。

┌─────────────────────────────────────────────────────────────────────┐
│                      Segment合并原理                                 │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  背景：ES不断写入新Segment，小Segment会越来越多                       │
│  问题：小Segment查询效率低                │
│                                                                      │
│  合并策略：                                                          │
│  ┌────────────────────────────────────────────────────────────────┐ │
│  │  Elasticsearch后台线程定期执行Force Merge                       │ │
│  │                                                                 │ │
│  │  小Segment合并为大Segment：                                      │ │
│  │   +  +  →                                   │ │
│  │  合并时自动删除Yi标记删除的文档                                  │ │
│  └────────────────────────────────────────────────────────────────┘ │
│                                                                      │
│  配置优化建议：                                                      │
│  PUT /my_index/_settings                                            │
│  {                                                                   │
│      "number_of_shards": 5,          // 主分片数       │
│      "number_of_replicas": 1,        // 副本数         │
│      "refresh_interval": "5s"        // 刷新间隔   │
│  }                                                                   │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

三、 查询DSL：不仅仅是搜索

ES的查询语言非常强大，强大到有时候你会觉得它像是一门编程语言。从全文检索到精确匹配，再到复杂的聚合分析，它douNeng搞定。

3.1 全文查询的艺术

全文查询是ES的kan家本领。Zui常用的就是`match`查询。它不仅会分词，还会计算相关性得分。

// 1. match查询
GET /my_index/_search
{
  "query": {
    "match": {
      "title": {
        "query": "Java编程入门",
        "operator": "and"  // and: 所有词dou匹配, or: 任一词匹配
      }
    }
  }
}
// 2. match_phrase
// 比如你想搜"Java编程"，但不希望搜到"Java基础编程"
GET /my_index/_search
{
  "query": {
    "match_phrase": {
      "title": {
        "query": "Java编程",
        "slop": 1   // 允许词之间间隔1个词，稍微宽松一点
      }
    }
  }
}
// 3. multi_match
// 搜"Java分布式"，可Neng在标题里也可Neng在标签里
GET /my_index/_search
{
  "query": {
    "multi_match": {
      "query": "Java分布式",
      "fields": , // title权重提升3倍
      "type": "best_fields",
      "tie_breaker": 0.3
    }
  }
}
// 4. query_string
// 支持AND, OR, NOT等布尔操作符
GET /my_index/_search
{
  "query": {
    "query_string": {
      "default_field": "content",
      "query": " OR ",
      "default_operator": "AND"
    }
  }
}

3.2 精准打击：精确查询

有时候我们不需要分词，比如查状态码、ID、时间范围。这时候就要用`term`或`terms`查询。

// 1. term查询
GET /my_index/_search
{
  "query": {
    "term": {
      "status": "active"  // 精确匹配，不会分词
    }
  }
}
// 2. terms查询（多值精确匹配，类似SQL的 IN)
GET /my_index/_search
{
  "query": {
    "terms": {
      "status": 
    }
  }
}
// 3. range查询
GET /my_index/_search
{
  "query": {
    "range": {
      "age": {
        "gte": 18,
        "lte": 30,
        "boost": 2.0
      },
      "create_time": {
        "gte": "2020-01-01",
        "lte": "now"
      }
    }
  }
}
// 4. exists查询
GET /my_index/_search
{
  "query": {
    "exists": {
      "field": "phone_number"
    }
  }
}

3.3 逻辑组合：复合查询

现实中的需求往往hen复杂，我们需要把各种查询组合起来。`bool`查询就是为此而生的。

// 1. bool查询
GET /my_index/_search
{
  "query": {
    "bool": {
      "must": ,
      "should": ,
      "must_not": ,
      "filter": ,
      "minimum_should_match": 1
    }
  }
}
// 2. constant_score
// 不想管得分，只想过滤，用这个
GET /my_index/_search
{
  "query": {
    "constant_score": {
      "filter": { "term": { "status": "active" } },
      "boost": 1.5
    }
  }
}
// 3. function_score
// 想根据点赞数、时间距离来调整排序？用这个
GET /my_index/_search
{
  "query": {
    "function_score": {
      "query": { "match": { "title": "Java" } },
      "functions": ,
      "score_mode": "sum",
      "boost_mode": "multiply"
    }
  }
}

3.4 数据分析：聚合查询

ES不仅Neng搜，还Neng算。聚合功Neng类似于SQL的`GROUP BY`，但geng强大。

// 1. 桶聚合
// 按城市分组，算平均年龄
GET /my_index/_search
{
  "size": 0,  // 不返回文档，只返回聚合结果
  "aggs": {
    "group_by_city": {
      "terms": {
        "field": "city",
        "size": 10
      },
      "aggs": {
        "avg_age": {
          "avg": { "field": "age" }
        }
      }
    }
  }
}
// 2. 指标聚合
// 统计信息
GET /my_index/_search
{
  "size": 0,
  "aggs": {
    "stats_age": {
      "stats": { "field": "age" }  // min, max, sum, avg, count
    }
  }
}
// 3. 嵌套聚合
// 先按性别分，再按城市分，再算平均工资
GET /my_index/_search
{
  "size": 0,
  "aggs": {
    "by_gender": {
      "terms": { "field": "gender" },
      "aggs": {
        "by_city": {
          "terms": { "field": "city" },
          "aggs": {
            "avg_salary": {
              "avg": { "field": "salary" }
            }
          }
        }
      }
    }
  }
}

四、 性Neng调优：实战中的避坑指南

懂原理是基础，Neng把性Neng压榨出来才是本事。hen多默认配置其实并不适合你。

4.1 索引设计的智慧

hen多性Neng问题在索引创建的那一刻就注定了。分片怎么设？字段类型怎么选？这dou是学问。

// 1. 合理的分片数
/**
 * 经验公式：分片数 = 数据量 / 单分片容量
 * 
 * 建议单分片容量：20GB - 50GB
 * 
 * 场景1：数据量1TB
 *   建议分片数 = 1000GB / 40GB ≈ 25个主分片
 * 
 * 场景2：数据量100GB，预计增长到500GB
 *   建议分片数 = 500GB / 40GB ≈ 13个主分片
 */
// 2. 副本数设计
/**
 * 副本数 = 数据重要程度 + 查询压力
 * 
 * 高可用要求：至少1个副本
 * 读压力大：副本数 = ceil
 */
// 3. mappings优化实战
PUT /my_index
{
  "mappings": {
    "properties": {
      "user_id": { "type": "keyword" },  // 不需要全文搜索，用keyword
      "title": {
        "type": "text",
        "analyzer": "ik_max_word",  // 中文分词
        "fields": {
          "keyword": { "type": "keyword" }  // 支持精确匹配和排序
        }
      },
      "age": { "type": "integer" },
      "salary": { 
        "type": "scaled_float", 
        "scaling_factor": 100 
      },
      "create_time": { "type": "date" },
      "tags": { "type": "keyword" }
    }
  },
  "settings": {
    "number_of_shards": 5,
    "number_of_replicas": 1,
    "refresh_interval": "5s",  // 写多查少时增大，减少Segment压力
    "translog": {
      "sync_interval": "10s",
      "durability": "async"  // 异步刷新，提升写入性Neng，但可Neng丢数据
    }
  }
}

4.2 查询优化的杀手锏

查询慢？多半是因为你用错了方式。

// 1. 使用filter替代must
// filter：不计算相关性得分，结果可缓存，速度快
// must：计算相关性得分，不可缓存
// ❌ 低效写法
GET /my_index/_search
{
  "query": {
    "bool": {
      "must": 
    }
  }
}
// ✅ 高效写法
GET /my_index/_search
{
  "query": {
    "bool": {
      "must": { "match": { "title": "Java" } },
      "filter": { "term": { "status": "active" } }
    }
  }
}
// 2. 关闭source返回不必要的字段
// Ru果只需要ID，就不要把整个文档dou拉出来
GET /my_index/_search
{
  "_source": ,
  "query": { ... }
}
// 3. 分页深度查询优化
// ❌ 深分页问题：from+size深度过大会OOM
POST /my_index/_search
{ "from": 10000, "size": 10 }  // 每次翻页dou是前10010条，太惨了
// ✅ 使用search_after
POST /my_index/_search
{
  "size": 10,
  "query": { "match": { "title": "Java" } },
  "sort": 
}
// 后续查询使用上一页返回的sort值
POST /my_index/_search
{
  "size": 10,
  "query": { "match": { "title": "Java" } },
  "search_after": ,
  "sort": 
}
// ✅ 使用scroll
POST /my_index/_search?scroll=5m
{
  "size": 1000,
  "query": { "match_all": {} }
}
// 返回 scroll_id，后续使用
POST /_search/scroll
{
  "scroll": "5m",
  "scroll_id": "DXF1ZXJ5QW5kRmV0Y2gBAAAAAAAAAD4..."
}

4.3 写入性Neng的极致追求

面对海量日志写入，默认配置肯定扛不住。我们需要批量写、放宽刷新间隔、甚至暂时关闭副本。

// 1. 批量写入
POST /my_index/_bulk
{ "index": { "_id": "1" } }
{ "title": "文档1", "content": "内容1" }
{ "index": { "_id": "2" } }
{ "title": "文档2", "content": "内容2" }
// 批量大小建议：5MB - 15MB，太大也会撑爆内存
// 2. 合理设置refresh_interval
PUT /my_index/_settings
{
  "refresh_interval": "30s"  // 写入期间临时关闭refresh，牺牲实时性换吞吐量
}
// 3. 副本设置为0，写入完成后恢复
PUT /my_index/_settings
{
  "number_of_replicas": 0
}
// 写入完成后
PUT /my_index/_settings
{
  "number_of_replicas": 1
}
// 4. 使用Routing减少搜索范围
// Ru果你知道数据属于哪个用户，直接指定routing
PUT /my_index/_doc/1?routing=user_123
{ "title": "用户文章", "user_id": "user_123" }
// 查询时指定routing，减少搜索分片数
GET /my_index/_search?routing=user_123
{ "query": { "match": { "title": "Java" } } }
// 实际只搜索routing对应的分片，而不是全部分片

五、 集群与高可用：让系统坚如磐石

单机再强也有挂掉的一天。ES的分布式架构让它具备了天然的高可用性。

5.1 集群架构剖析

一个ES集群由多种节点组成，各司其职。

┌─────────────────────────────────────────────────────────────────────┐
│                      ES集群架构                                     │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│                        ┌─────────────┐                              │
│                        │  Client Node │  ← 协调节点│
│                        │    │                              │
│                        └──────┬──────┘                              │
│                               │                                       │
│            ┌─────────────────┼─────────────────┐                   │
│            ↓                 ↓                 ↓                    │
│     ┌─────────────┐  ┌─────────────┐  ┌─────────────┐              │
│     │  Master Node │  │  Master Node │  │  Master Node │              │
│     │      │  │   │  │   │              │
│     └─────────────┘  └─────────────┘  └─────────────┘              │
│            ↓                 ↓                 ↓                    │
│     ┌─────────────┐  ┌─────────────┐  ┌─────────────┐              │
│     │  Data Node  │  │  Data Node  │  │  Data Node  │              │
│     │     │  │     │  │     │              │
│     └─────────────┘  └─────────────┘  └─────────────┘              │
│                                                                      │
│  节点类型：                                                           │
│  - Master：管理集群元数据                      │
│  - Data：存储数据、干苦力                               │
│  - Coordinating：接收请求、分发任务、汇果                        │
│  - Ingest：数据预处理                                    │
│                                                                      │
│  分片分配策略：                                                       │
│  - 主分片故障 → 自动选举新主分片                                     │
│  - 副本分片故障 → 主分片复制数据到新副本                             │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

5.2 故障恢复机制

当节点宕机，ES会怎么自救？

// 1. 分片恢复配置
PUT /_cluster/settings
{
  "transient": {
    "cluster.routing.allocation.enable": "all",
    "cluster.routing.allocation.node_concurrent_recoveries": 2,
    "indices.recovery.max_bytes_per_sec": "100mb"
  }
}
// 2. 手动触发分片重分配
POST /_cluster/reroute
{
  "commands": 
}
// 3. 查kan集群健康状态
GET /_cluster/health
{
  "cluster_name": "my_cluster",
  "status": "green",  // green: 所有分片正常, yellow: 副本未分配, red: 主分片丢失
  "number_of_nodes": 3,
  "active_primary_shards": 5,
  "relocating_shards": 0,
  "initializing_shards": 0,
  "unassigned_shards": 0
}

六、 面试必问：那些让你脱颖而出的细节

Zui后我们来聊聊面试中经常被问到的几个高频问题，kankanNeng不Neng帮你拿下Offer。

Q1：ES和MySQL到底怎么选？

这其实不是二选一，而是互补。

┌─────────────────────────────────────────────────────────────────────┐
│                    ES vs MySQL 对比                                 │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  MySQL适用场景：                                                      │
│  ✅ 事务要求高                                 │
│  ✅ 数据量小                                           │
│  ✅ 复杂的关联查询                                           │
│  ✅ 需要实时的增删改查                                               │
│                                                                      │
│  ES适用场景：                                                         │
│  ✅ 全文搜索需求                             │
│  ✅ 数据量大                                           │
│  ✅ 查询延迟要求高                                     │
│  ✅ 复杂的聚合分析                                     │
│  ✅ 水平
Neng力                           │
│                                                                      │
│  Zui佳实践：MySQL + ES双写                                           │
│  - MySQL作为主存储，保证数据一致性                                   │
│  - ES作为搜索引擎，提供全文搜索Neng力                                  │
│  - 通过Canal监听MySQL Binlog同步数据到ES                             │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

Q2：ES如何保证高可用？

靠副本和故障检测。每个主分片dou有副本，分布在不同的机器上。Master节点会不断ping其他节点，一旦发现失联，立马发起分片迁移。写入时Ke以设置`wait_for_active_shards`来保证数据写入到多少个副本才算成功。

Q3：ES的相关性评分是怎么算的？

默认使用BM25算法。它是对TF-IDF的改进。简单来说词在文档中出现得越频繁，该词在整个语料库中越稀有，得分就越高。BM25还引入了文档长度归一化，防止长文档占便宜。

// 自定义评分示例
GET /my_index/_search
{
  "query": {
    "function_score": {
      "query": { "match": { "title": "Java" } },
      "functions": ,
      "score_mode": "sum",
      "boost_mode": "multiply"
    }
  }
}

Elasticsearch不仅仅是一个工具，geng是一种处理数据的思维方式。从倒排索引的精妙设计，到分布式架构的容错Neng力，再到DSL查询的灵活多变，每一处细节dou体现了工程师们对速度与稳定性的极致追求。

掌握这些原理，不仅Neng让你在遇到性Neng瓶颈时从容应对，gengNeng让你在设计系统架构时游刃有余。希望这篇文章Neng帮你真正打开ES的大门，去探索geng多未知的可Neng。

大家在使用ES时遇到过哪些坑？或者有什么独家的调优秘籍？欢迎在评论区留言分享，我们一起交流进步！

---