Elasticsearch 是一个开源的搜索引擎，建立在一个全文搜索引擎库 Apache Lucene™ 基础之上。 Lucene 可能是目前存在的，不论开源还是私有的，拥有最先进，高性能和全功能搜索引擎功能的库。但是 Lucene 仅仅只是一个库。为了利用它，你需要编写 java 程序，并在你的 java 程序里面直接集成 Lucene 包。 更坏的情况是，你需要对信息检索有一定程度的理解才能明白 Lucene 是怎么工作的。Lucene 是 很 复杂的。
Elasticsearch 也是使用 Java 编写的，它的内部使用 Lucene 做索引与搜索，但是它的目标是使全文检索变得简单， 通过隐藏 Lucene 的复杂性，取而代之的提供一套简单一致的 RESTful API。然而，Elasticsearch 不仅仅是 Lucene，并且也不仅仅只是一个全文搜索引擎。 它可以被下面这样准确的形容：
- 一个分布式的实时文档存储，每个字段 可以被索引与搜索
- 一个分布式实时分析搜索引擎
- 能胜任上百个服务节点的扩展，并支持 PB 级别的结构化或者非结构化数据
 

1、使用Elasticsearch搭建一个文件搜索系统（带界面）


何为文件搜索系统？其实简单一点，就可以想象为一个带用户界面的grep，可以根据你提供的关键字查询包含该内容的文件。与grep一样，该系统应该能返回包含该搜索条件的文件名，行号和具体内容等，同时应该支持高亮。与grep只支持正则表达式不一样的是，以elasticsearch为基础的搜索系统，能支持更多的搜索模式和匹配模式。当然，我们的系统肯定是比grep提供更多的功能。

基本需求
特点如下：

基于web的用户界面，使用浏览器就可以直接访问
可以对文件内容进行搜索和匹配，并且返回文件基本信息和关键字高亮，并提供链接远程打开文件
支持各种富文本内容，包括ppt, pdf等
可以监控文件的变化，当文件有增删改之后，能够重新索引文件
我们先看看最终的效果：


任务分解
再简单分解一下所需要的技术：

web前端：
UI：提供搜索条、展示搜索结果面板和文件打开链接
逻辑：将搜索内容组装为elasticsearch的搜索语句发送到后端，并且将response进行合理的处理
web后端：
web服务器提供web API服务
同时对接elasticsearch，作为中间件，处理 前端请求 <——> elasticsearch 之间的互动
web文件服务器，提供静态文件的访问
数据库：
elasticsearch作为数据库，包含文件的索引和基本信息
文件监控与索引
需要对特定目录下的文件进行监控和索引
任何的增删改动作都触发文件的索引（把文件索引到elasticsearch当中，以便可以搜索）
咋一看貌似挺复杂的。但如同所有的软件开发，只要不是特别创新的功能，总会有人已经帮你踩好了坑，我们要做的是找到合适的轮子而不是重复造轮子（一开始也是打算自己把这套东西都实现了，结果一google，啥都有）。

为了更方便的集成搜索服务到你的APP或者网站，elastic提供了一套search UI （官网）。只需要寥寥几行代码，即可内嵌一个非常美观的search套件到你的应用或者网站当中。我们的实现也主要是基于这个search UI.

具体的代码可查地址。

web 前端
但是这套工具的是默认你使用App search或者site search服务的，其接口设置是使用一个connector与远程的search服务进行交互。

如果我们没有购买类似的服务，只能修改这个代码为使用本地的elasticsearch。具体的示例在github上也能找到，我们的代码也是基于这个example。

所需的component大致如下：

package.json:

{
  "name": "elasticsearch-example",
  "version": "0.8.0",
  "private": true,
  "proxy": "http://localhost:9000",
  "dependencies": {
    "@elastic/react-search-ui": "0.8.0",
    "@elastic/react-search-ui-views": "0.8.0",
    "@elastic/search-ui": "0.8.0",
    "react": "^16.8.6",
    "react-dom": "^16.8.6",
    "react-scripts": "3.0.1"
  },
  "scripts": {
    "start": "npm-run-all --parallel start:app start:server",
    "start:app": "react-scripts start",
    "start:server": "netlify-lambda serve ./functions",
    "build": "npm-run-all --parallel build:**",
    "read": "read",
    "build:app": "react-scripts build",
    "build:functions": "netlify-lambda build ./functions"
  },
  "eslintConfig": {
    "extends": "react-app"
  },
  "browserslist": {
    "production": [
      ">0.2%",
      "not dead",
      "not op_mini all"
    ],
    "development": [
      "last 1 chrome version",
      "last 1 firefox version",
      "last 1 safari version"
    ]
  },
  "devDependencies": {
    "encoding": "^0.1.12",
    "netlify-lambda": "^1.4.7",
    "node-fetch": "^2.5.0",
    "npm-run-all": "^4.1.5"
  }
}


需要重写一下autoComplete.js以适配我们自己的数据格式


web 后端
以上项目已经实现了一个nodeJs的后端，直接启动npm start即可，但需要注意的是，需要通过环境变量指定elasticsearch的url，即完整的命令是：
ELASTICSEARCH_HOST=http://localhost:9200 npm start

索引替换
前面我们提到后端需要对接elasticsearch，作为中间件，处理 前端请求 <——> elasticsearch 之间的互动，这部分代码框架已经实现了，我们要做的是把索引替换为我们自己的索引。

文件监控与索引
这里，我们使用 fscrawler 就能完全满足我们的需求。因为文档很齐全，我这里就不一一解释了。
我这里监控了一个目录/Users/Documents/AWS：

ls -l
total 24736
-rw-r--r--@ 1 lex  staff    22523  6 10 15:20 2019年风险管理制度学习活动-量化风险-学习资料.docx
-rw-r--r--@ 1 lex  staff   567176  6 10 15:20 AWS_Certified_Solutions_Architect_Associate_Feb_2018_ Exam_Guide_v1.5.2.pdf
-rw-r--r--@ 1 lex  staff   389035  6 10 15:20 AWS_Certified_Solutions_Architect_Associate_Sample_Questions.pdf
-rw-r--r--@ 1 lex  staff   195516  6 10 15:20 AWS_certified_solutions_architect_associate_blueprint.pdf
-rw-r--r--@ 1 lex  staff  2338541  6 10 15:20 ES多数据同步之道分享.key


则对应的配置文件，简单的可以设置为：

---
name: "files"
fs:
  url: "/Users/Documents/AWS/"
  update_rate: "15m"
  excludes:
  - "*/~*"
  json_support: false
  filename_as_id: false
  add_filesize: true
  remove_deleted: true
  add_as_inner_object: false
  store_source: false
  index_content: true
  attributes_support: false
  raw_metadata: false
  xml_support: false
  index_folders: true
  lang_detect: false
  continue_on_error: false
  ocr:
    language: "eng"
    enabled: true
    pdf_strategy: "ocr_and_text"
  follow_symlinks: false
elasticsearch:
  nodes:
  - url: "http://127.0.0.1:9200"
  bulk_size: 100
  flush_interval: "5s"
  byte_size: "10mb"


以下是该工具写入到es的对象为：

{
  "_index": "files",
  "_type": "_doc",
  "_id": "f982d250b791df3ea3b1e0c1b184e283",
  "_version": 18,
  "_score": null,
  "_source": {
    "content": "\n   AWS Certified Solutions Architect – \nAssociate ...",
    "meta": {
      "author": "Barnosky, Timothy",
      "date": "2018-02-08T06:13:32.000+0000",
      "language": "en-US",
      "format": "application/pdf; version=1.5",
      "creator_tool": "Microsoft® Word 2013",
      "created": "2018-02-08T06:13:32.000+0000"
    },
    "file": {
      "extension": "pdf",
      "content_type": "application/pdf",
      "created": "2019-04-03T03:31:49.000+0000",
      "last_modified": "2019-04-03T03:31:49.000+0000",
      "last_accessed": "2019-06-05T08:08:22.000+0000",
      "indexing_date": "2019-06-05T08:08:22.479+0000",
      "filesize": 567176,
      "filename": "AWS_Certified_Solutions_Architect_Associate_Feb_2018_ Exam_Guide_v1.5.2.pdf",
      "url": "file:///Users/caishichao/Documents/AWS/AWS_Certified_Solutions_Architect_Associate_Feb_2018_ Exam_Guide_v1.5.2.pdf"
    },
    "path": {
      "root": "431c7636e585854c841c8e88a25ea39",
      "virtual": "AWS_Certified_Solutions_Architect_Associate_Feb_2018_ Exam_Guide_v1.5.2.pdf",
      "real": "/Users/caishichao/Documents/AWS/AWS_Certified_Solutions_Architect_Associate_Feb_2018_ Exam_Guide_v1.5.2.pdf"
    }
  },
  "sort": [
    -9223372036854776000
  ]
}


UI上可以通过读取content，file，path的内容进行必要的展示

具体需要修改buildState.js里面的内容进行适配。


文件下载
我们可以使用nginx或者其他工具为文件目录提供一个web访问的解决方案，当搜索某个关键字被匹配后，根据文件信息，构造一个下载路径，提供文件下载
 

2、Python操作ElasticSearch笔记

第一步安装Elasticsearch

1. 下载tar包,进行解压

第二部安装pip

1. 到下载的包:用python setup.py install 进行编译
2. 然后配置环境变量(变量环境为python下的scripts):C:\Users\Administrator\AppData\Local\Programs\Python\Python37-32\Scripts

第三步查看pii是否安装成功:(配置完环境变量之后需要重启,才能生效)

pip list
Package    Version
---------- -------
pip        19.0.3
setuptools 40.6.2

第四步使用pip 安装elasticsearch

pip install elasticsearch

第五步,在python中连接ES

1. 需要指定访问es的主机和端口号
2. 确定需要访问的索引 index 
3. 确定doc_typey
    通过访问 主机+端口号+index
        示例:   http://xx.xx.xx.xx9200/hi_camera_info
            ```{
            "hi_camera_info":{
                "aliases":{
        
                },
                "mappings":{
                    "info":
             ```
    doc_type 就是mappings中对应的info
```
1. 
    from elasticsearch import Elasticsearch
    es = Elasticsearch(hosts="xx.xx.xx.xx# 指定主机", port=9200 # 指定端口, timeout=200)
    query = {
        "from": 0,
        "size": 2
    }
    result = es.search(index="hi_camera_info", doc_type="info", body=query)
    value1 = []
    for value in result['hits']['hits']:
        value1 += [value]
    for value in value1:
        print(value['_source'])
```  
采用pyton 查询Elasticsearch并导出所有的数据到Excel中.

[link](https://blog.csdn.net/fwj_ntu/article/details/87863788)

案例:

    ```
    import csv
    from elasticsearch import Elasticsearch
    
    es = Elasticsearch(hosts="xx.xx.xx.xx", port=9200, timeout=200)
    # 1. 先借助游标,将所有结果数据存储到内存中
    # 2. 然后将内存中的结果数据写入到磁盘,也就是文件中
    query1 = {
        "size": 100
    }
    query = es.search(index="hi_camera_info", doc_type="info", scroll='5m', body=query1)
    value = query["hits"]["hits"]
    
    # es查询出的结果第一页
    results = query['hits']['hits']
    # es查询出的结果总量
    total = query['hits']['total']
    # 游标用于输出es查询出的所有结果
    scroll_id = query['_scroll_id']
    # 在发送查询请求的时候,就告诉ES需要使用游标,并定义每次返回数据量的大小
    # 定义一个list变量results用来存储数据结果,在代码中,可以另其为空list,即results=[],也可以先将返回结果
    # 的第一页存尽进来, 即results = query['hits']['hits']
    # 对于所有二级果数据写个分页加载到内存变量的循环
    for i in range(0, int(total / 100) + 1):
        # scroll参数必须制定否则会报错
        query_scroll = es.scroll(scroll_id=scroll_id, scroll="5m")['hits']['hits']
        results += query_scroll
    with open("D://ml/data.csv", 'w', newline='', encoding="gbk") as flow:
        # 获取_source 下的所有字段名
        names = results[0]['_source'].keys()
        csv_writer = csv.writer(flow)
        csv_writer.writerow(names)
        for res in results:
            csv_writer.writerow(res['_source'].values())
    print("done!")

    ```

3、什么是Elasticsearch?

  Elasticsearch是一个开源的分布式、RESTful 风格的搜索和数据分析引擎，它的底层是开源库Apache Lucene。
  Lucene 可以说是当下最先进、高性能、全功能的搜索引擎库——无论是开源还是私有，但它也仅仅只是一个库。为了充分发挥其功能，你需要使用 Java 并将 Lucene 直接集成到应用程序中。 更糟糕的是，您可能需要获得信息检索学位才能了解其工作原理，因为Lucene 非常复杂。
  为了解决Lucene使用时的繁复性，于是Elasticsearch便应运而生。它使用 Java 编写，内部采用 Lucene 做索引与搜索，但是它的目标是使全文检索变得更简单，简单来说，就是对Lucene 做了一层封装，它提供了一套简单一致的 RESTful API 来帮助我们实现存储和检索。
  当然，Elasticsearch 不仅仅是 Lucene，并且也不仅仅只是一个全文搜索引擎。 它可以被下面这样准确地形容：

  • 一个分布式的实时文档存储，每个字段可以被索引与搜索；
  • 一个分布式实时分析搜索引擎；
  • 能胜任上百个服务节点的扩展，并支持 PB 级别的结构化或者非结构化数据。

由于Elasticsearch的功能强大和使用简单，维基百科、卫报、Stack Overflow、GitHub等都纷纷采用它来做搜索。现在，Elasticsearch已成为全文搜索领域的主流软件之一。
  下面将介绍Elasticsearch的安装与简单使用。

安装并运行Elasticsearch

  安装 Elasticsearch 之前，你需要先安装一个较新版本的 Java，最好的选择是，你可以从 www.java.com 获得官方提供的最新版本的Java。
  你可以从 elastic 的官网 elastic.co/downloads/elasticsearch 获取最新版本的Elasticsearch。解压文档后，按照下面的操作，即可在前台(foregroud)启动 Elasticsearch：

cd elasticsearch-<version>
./bin/elasticsearch

此时，Elasticsearch运行在本地的9200端口，在浏览器中输入网址“http://localhost:9200/”，如果看到以下信息就说明你的电脑已成功安装Elasticsearch：

{
  "name" : "YTK8L4q",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "hB2CZPlvSJavhJxx85fUqQ",
  "version" : {
    "number" : "6.5.4",
    "build_flavor" : "default",
    "build_type" : "tar",
    "build_hash" : "d2ef93d",
    "build_date" : "2018-12-17T21:17:40.758843Z",
    "build_snapshot" : false,
    "lucene_version" : "7.5.0",
    "minimum_wire_compatibility_version" : "5.6.0",
    "minimum_index_compatibility_version" : "5.0.0"
  },
  "tagline" : "You Know, for Search"
}

在这里，我们安装的Elasticsearch版本号为6.5.4。
  Kibana 是一个开源的分析和可视化平台，旨在与 Elasticsearch 合作。Kibana 提供搜索、查看和与存储在 Elasticsearch 索引中的数据进行交互的功能。开发者或运维人员可以轻松地执行高级数据分析，并在各种图表、表格和地图中可视化数据。
  你可以从 elastic 的官网 https://www.elastic.co/downloads/kibana 获取最新版本的Kibana。解压文档后，按照下面的操作，即可在前台(foregroud)启动Kibana：

cd kibana-<version>
./bin/kabana

此时，Kibana运行在本地的5601端口，在浏览器中输入网址“http://localhost:5601”，即可看到以下界面：

Kibana启动界面

  下面，让我们来了解Elasticsearch的一些基本概念，这有助于我们更好地理解和使用Elasticsearch。

Elasticsearch基本概念

全文搜索(Full-text Search)

  全文检索是指计算机索引程序通过扫描文章中的每一个词，对每一个词建立一个索引，指明该词在文章中出现的次数和位置，当用户查询时，检索程序就根据事先建立的索引进行查找，并将查找的结果反馈给用户的检索方式。
  在全文搜索的世界中，存在着几个庞大的帝国，也就是主流工具，主要有：

  • Apache Lucene
  • Elasticsearch
  • Solr
  • Ferret

倒排索引（Inverted Index）

  该索引表中的每一项都包括一个属性值和具有该属性值的各记录的地址。由于不是由记录来确定属性值，而是由属性值来确定记录的位置，因而称为倒排索引(inverted index)。Elasticsearch能够实现快速、高效的搜索功能，正是基于倒排索引原理。

节点 & 集群（Node & Cluster）

  Elasticsearch 本质上是一个分布式数据库，允许多台服务器协同工作，每台服务器可以运行多个Elasticsearch实例。单个Elasticsearch实例称为一个节点（Node），一组节点构成一个集群（Cluster）。

索引（Index）

  Elasticsearch 数据管理的顶层单位就叫做 Index（索引），相当于关系型数据库里的数据库的概念。另外，每个Index的名字必须是小写。

文档（Document）

  Index里面单条的记录称为 Document（文档）。许多条 Document 构成了一个 Index。Document 使用 JSON 格式表示。同一个 Index 里面的 Document，不要求有相同的结构（scheme），但是最好保持相同，这样有利于提高搜索效率。

类型（Type）

  Document 可以分组，比如employee这个 Index 里面，可以按部门分组，也可以按职级分组。这种分组就叫做 Type，它是虚拟的逻辑分组，用来过滤 Document，类似关系型数据库中的数据表。
  不同的 Type 应该有相似的结构（Schema），性质完全不同的数据（比如 products 和 logs）应该存成两个 Index，而不是一个 Index 里面的两个 Type（虽然可以做到）。

文档元数据（Document metadata）

  文档元数据为_index, _type, _id, 这三者可以唯一表示一个文档，_index表示文档在哪存放，_type表示文档的对象类别，_id为文档的唯一标识。

字段（Fields）

  每个Document都类似一个JSON结构，它包含了许多字段，每个字段都有其对应的值，多个字段组成了一个 Document，可以类比关系型数据库数据表中的字段。
  在 Elasticsearch 中，文档（Document）归属于一种类型（Type），而这些类型存在于索引（Index）中，下图展示了Elasticsearch与传统关系型数据库的类比：

Elasticsearch入门

  Elasticsearch提供了多种交互使用方式，包括Java API和RESTful API ，本文主要介绍RESTful API 。所有其他语言可以使用RESTful API 通过端口 9200 和 Elasticsearch 进行通信，你可以用你最喜爱的 web 客户端访问 Elasticsearch 。甚至，你还可以使用 curl 命令来和 Elasticsearch 交互。
  一个Elasticsearch请求和任何 HTTP 请求一样，都由若干相同的部件组成：

curl -X<VERB> '<PROTOCOL>://<HOST>:<PORT>/<PATH>?<QUERY_STRING>' -d '<BODY>'

返回的数据格式为JSON，因为Elasticsearch中的文档以JSON格式储存。其中，被 < > 标记的部件：

部件说明
VERB适当的 HTTP 方法 或 谓词 : GET、 POST、 PUT、 HEAD 或者 DELETE。
PROTOCOLhttp 或者 https（如果你在 Elasticsearch 前面有一个 https 代理）
HOSTElasticsearch 集群中任意节点的主机名，或者用 localhost 代表本地机器上的节点。
PORT运行 Elasticsearch HTTP 服务的端口号，默认是 9200 。
PATHAPI 的终端路径（例如 _count 将返回集群中文档数量）。Path 可能包含多个组件，例如：_cluster/stats 和 _nodes/stats/jvm 。
QUERY_STRING任意可选的查询字符串参数 (例如 ?pretty 将格式化地输出 JSON 返回值，使其更容易阅读)
BODY一个 JSON 格式的请求体 (如果请求需要的话)

对于HTTP方法，它们的具体作用为：

HTTP方法说明
GET获取请求对象的当前状态
POST改变对象的当前状态
PUT创建一个对象
DELETE销毁对象
HEAD请求获取对象的基础信息

  我们以下面的数据为例，来展示Elasticsearch的用法。

以下全部的操作都在Kibana中完成，创建的index为conference, type为event .

插入数据

  首先创建index为conference, 创建type为event, 插入id为1的第一条数据，只需运行下面命令就行：

PUT /conference/event/1
{
  "host": "Dave",
  "title": "Elasticsearch at Rangespan and Exonar",
  "description": "Representatives from Rangespan and Exonar will come and discuss how they use Elasticsearch",
  "attendees": ["Dave", "Andrew", "David", "Clint"],
  "date": "2013-06-24T18:30",
  "reviews": 3
}

在上面的命令中，路径/conference/event/1表示文档的index为conference, type为event, id为1. 类似于上面的操作，依次插入剩余的4条数据，完成插入后，查看数据如下：

插入数据

删除数据

  比如我们想要删除conference中event里面id为5的数据，只需运行下面命令即可：

DELETE /conference/event/5

返回结果如下：

{
  "_index" : "conference",
  "_type" : "event",
  "_id" : "5",
  "_version" : 2,
  "result" : "deleted",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 1,
  "_primary_term" : 1
}

表示该文档已成功删除。如果想删除整个event类型，可输入命令:

DELETE /conference/event

如果想删除整个conference索引，可输入命令:

DELETE /conference

修改数据

  修改数据的命令为POST, 比如我们想要将conference中event里面id为4的文档的作者改为Bob，那么需要运行命令如下：

POST /conference/event/4/_update
{
  "doc": {"host": "Bob"}
}

返回的信息如下：（表示修改数据成功）

{
  "_index" : "conference",
  "_type" : "event",
  "_id" : "4",
  "_version" : 7,
  "result" : "updated",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 7,
  "_primary_term" : 1
}

查看修改后的数据如下：

修改数据

查询数据

  查询数据的命令为GET，查询命令也是Elasticsearch最为重要的功能之一。比如我们想查询conference中event里面id为1的数据，运行命令如下：

GET /conference/event/1

返回的结果如下：

{
  "_index" : "conference",
  "_type" : "event",
  "_id" : "1",
  "_version" : 2,
  "found" : true,
  "_source" : {
    "host" : "Dave",
    "title" : "Elasticsearch at Rangespan and Exonar",
    "description" : "Representatives from Rangespan and Exonar will come and discuss how they use Elasticsearch",
    "attendees" : [
      "Dave",
      "Andrew",
      "David",
      "Clint"
    ],
    "date" : "2013-06-24T18:30",
    "reviews" : 3
  }
}

在_source 属性中，内容是原始的 JSON 文档，还包含有其它属性，比如_index, _type, _id, _found等。
  如果想要搜索conference中event里面所有的文档，运行命令如下：

GET /conference/event/_search

返回结果包括了所有四个文档，放在数组 hits 中。
  当然，Elasticsearch 提供更加丰富灵活的查询语言叫做 查询表达式 ， 它支持构建更加复杂和健壮的查询。利用查询表达式，我们可以检索出conference中event里面所有host为Bob的文档，命令如下：

GET /conference/event/_search
{
    "query" : {
        "match" : {
            "host" : "Bob"
        }
    }
}

返回的结果只包括了一个文档，放在数组 hits 中。
  接着，让我们尝试稍微高级点儿的全文搜索——一项传统数据库确实很难搞定的任务。搜索下所有description中含有"use Elasticsearch"的event：

GET /conference/event/_search
{
    "query" : {
        "match" : {
            "description" : "use Elasticsearch"
        }
    }
}

返回的结果（部分）如下：

{
 ...
  "hits" : {
    "total" : 2,
    "max_score" : 0.65109104,
    "hits" : [
      {
        ...
        "_score" : 0.65109104,
        "_source" : {
          "host" : "Dave Nolan",
          "title" : "real-time Elasticsearch",
          "description" : "We will discuss using Elasticsearch to index data in real time",
          ...
        }
      },
      {
        ...
        "_score" : 0.5753642,
        "_source" : {
          "host" : "Dave",
          "title" : "Elasticsearch at Rangespan and Exonar",
          "description" : "Representatives from Rangespan and Exonar will come and discuss how they use Elasticsearch",
          ...
        }
      }
    ]
  }
}

返回的结果包含了两个文档，放在数组 hits 中。让我们对这个结果做一些分析，第一个文档的description里面含有“using Elasticsearch”，这个能匹配“use Elasticsearch”是因为Elasticsearch含有内置的词干提取算法，之后两个文档按_score进行排序，_score字段表示文档的相似度（默认的相似度算法为BM25）。
  如果想搜索下所有description中严格含有"use Elasticsearch"这个短语的event，可以使用下面的命令：

GET /conference/event/_search
{
    "query" : {
        "match_phrase": {
            "description" : "use Elasticsearch"
        }
    }
}

这时候返回的结果只有一个文档，就是上面输出的第二个文档。
  当然，Elasticsearch还支持更多的搜索功能，比如过滤器，高亮搜索，结构化搜索等，希望接下来能有更多的时间和经历来介绍~

3、Elasticsearch－基础介绍及索引原理分析

最近在参与一个基于Elasticsearch作为底层数据框架提供大数据量(亿级)的实时统计查询的方案设计工作，花了些时间学习Elasticsearch的基础理论知识，整理了一下，希望能对Elasticsearch感兴趣/想了解的同学有所帮助。 同时也希望有发现内容不正确或者有疑问的地方，望指明，一起探讨，学习，进步。

介绍

Elasticsearch 是一个分布式可扩展的实时搜索和分析引擎,一个建立在全文搜索引擎 Apache Lucene(TM) 基础上的搜索引擎.当然 Elasticsearch 并不仅仅是 Lucene 那么简单，它不仅包括了全文搜索功能，还可以进行以下工作:

  • 分布式实时文件存储，并将每一个字段都编入索引，使其可以被搜索。
  • 实时分析的分布式搜索引擎。
  • 可以扩展到上百台服务器，处理PB级别的结构化或非结构化数据。

基本概念

先说Elasticsearch的文件存储，Elasticsearch是面向文档型数据库，一条数据在这里就是一个文档，用JSON作为文档序列化的格式，比如下面这条用户数据：

{
    "name" :     "John",
    "sex" :      "Male",
    "age" :      25,
    "birthDate": "1990/05/01",
    "about" :    "I love to go rock climbing",
    "interests": [ "sports", "music" ]
}

用Mysql这样的数据库存储就会容易想到建立一张User表，有balabala的字段等，在Elasticsearch里这就是一个文档，当然这个文档会属于一个User的类型，各种各样的类型存在于一个索引当中。这里有一份简易的将Elasticsearch和关系型数据术语对照表:

关系数据库     ⇒ 数据库 ⇒ 表    ⇒ 行    ⇒ 列(Columns)

Elasticsearch  ⇒ 索引(Index)   ⇒ 类型(type)  ⇒ 文档(Docments)  ⇒ 字段(Fields)

一个 Elasticsearch 集群可以包含多个索引(数据库)，也就是说其中包含了很多类型(表)。这些类型中包含了很多的文档(行)，然后每个文档中又包含了很多的字段(列)。Elasticsearch的交互，可以使用Java API，也可以直接使用HTTP的Restful API方式，比如我们打算插入一条记录，可以简单发送一个HTTP的请求：

PUT /megacorp/employee/1  
{
    "name" :     "John",
    "sex" :      "Male",
    "age" :      25,
    "about" :    "I love to go rock climbing",
    "interests": [ "sports", "music" ]
}

更新，查询也是类似这样的操作，具体操作手册可以参见Elasticsearch权威指南

索引

Elasticsearch最关键的就是提供强大的索引能力了，其实InfoQ的这篇时间序列数据库的秘密(2)——索引写的非常好，我这里也是围绕这篇结合自己的理解进一步梳理下，也希望可以帮助大家更好的理解这篇文章。

Elasticsearch索引的精髓：

一切设计都是为了提高搜索的性能

另一层意思：为了提高搜索的性能，难免会牺牲某些其他方面，比如插入/更新，否则其他数据库不用混了。前面看到往Elasticsearch里插入一条记录，其实就是直接PUT一个json的对象，这个对象有多个fields，比如上面例子中的name, sex, age, about, interests，那么在插入这些数据到Elasticsearch的同时，Elasticsearch还默默1的为这些字段建立索引--倒排索引，因为Elasticsearch最核心功能是搜索。

Elasticsearch是如何做到快速索引的

InfoQ那篇文章里说Elasticsearch使用的倒排索引比关系型数据库的B-Tree索引快，为什么呢？

什么是B-Tree索引?

上大学读书时老师教过我们，二叉树查找效率是logN，同时插入新的节点不必移动全部节点，所以用树型结构存储索引，能同时兼顾插入和查询的性能。因此在这个基础上，再结合磁盘的读取特性(顺序读/随机读)，传统关系型数据库采用了B-Tree/B+Tree这样的数据结构：

Alt text

为了提高查询的效率，减少磁盘寻道次数，将多个值作为一个数组通过连续区间存放，一次寻道读取多个数据，同时也降低树的高度。

什么是倒排索引?

Alt text

继续上面的例子，假设有这么几条数据(为了简单，去掉about, interests这两个field):

| ID | Name | Age  |  Sex     |
| -- |:------------:| -----:| -----:| 
| 1  | Kate         | 24 | Female
| 2  | John         | 24 | Male
| 3  | Bill         | 29 | Male

ID是Elasticsearch自建的文档id，那么Elasticsearch建立的索引如下:

Name:

| Term | Posting List |
| -- |:----:|
| Kate | 1 |
| John | 2 |
| Bill | 3 |

Age:

| Term | Posting List |
| -- |:----:|
| 24 | [1,2] |
| 29 | 3 |

Sex:

| Term | Posting List |
| -- |:----:|
| Female | 1 |
| Male | [2,3] |

Posting List

Elasticsearch分别为每个field都建立了一个倒排索引，Kate, John, 24, Female这些叫term，而[1,2]就是Posting List。Posting list就是一个int的数组，存储了所有符合某个term的文档id。

看到这里，不要认为就结束了，精彩的部分才刚开始...

通过posting list这种索引方式似乎可以很快进行查找，比如要找age=24的同学，爱回答问题的小明马上就举手回答：我知道，id是1，2的同学。但是，如果这里有上千万的记录呢？如果是想通过name来查找呢？

Term Dictionary

Elasticsearch为了能快速找到某个term，将所有的term排个序，二分法查找term，logN的查找效率，就像通过字典查找一样，这就是Term Dictionary。现在再看起来，似乎和传统数据库通过B-Tree的方式类似啊，为什么说比B-Tree的查询快呢？

Term Index

B-Tree通过减少磁盘寻道次数来提高查询性能，Elasticsearch也是采用同样的思路，直接通过内存查找term，不读磁盘，但是如果term太多，term dictionary也会很大，放内存不现实，于是有了Term Index，就像字典里的索引页一样，A开头的有哪些term，分别在哪页，可以理解term index是一颗树：

Alt text

这棵树不会包含所有的term，它包含的是term的一些前缀。通过term index可以快速地定位到term dictionary的某个offset，然后从这个位置再往后顺序查找。

Alt text

所以term index不需要存下所有的term，而仅仅是他们的一些前缀与Term Dictionary的block之间的映射关系，再结合FST(Finite State Transducers)的压缩技术，可以使term index缓存到内存中。从term index查到对应的term dictionary的block位置之后，再去磁盘上找term，大大减少了磁盘随机读的次数。

这时候爱提问的小明又举手了:"那个FST是神马东东啊?"

一看就知道小明是一个上大学读书的时候跟我一样不认真听课的孩子，数据结构老师一定讲过什么是FST。但没办法，我也忘了，这里再补下课：

FSTs are finite-state machines that map a term (byte sequence) to an arbitrary output.

假设我们现在要将mop, moth, pop, star, stop and top(term index里的term前缀)映射到序号：0，1，2，3，4，5(term dictionary的block位置)。最简单的做法就是定义个Map<string, integer="">，大家找到自己的位置对应入座就好了，但从内存占用少的角度想想，有没有更优的办法呢？答案就是：FST(理论依据在此，但我相信99%的人不会认真看完的)

Alt text

⭕️表示一种状态

-->表示状态的变化过程，上面的字母/数字表示状态变化和权重

将单词分成单个字母通过⭕️和-->表示出来，0权重不显示。如果⭕️后面出现分支，就标记权重，最后整条路径上的权重加起来就是这个单词对应的序号。

FSTs are finite-state machines that map a term (byte sequence) to an arbitrary output.

FST以字节的方式存储所有的term，这种压缩方式可以有效的缩减存储空间，使得term index足以放进内存，但这种方式也会导致查找时需要更多的CPU资源。

后面的更精彩，看累了的同学可以喝杯咖啡……

压缩技巧

Elasticsearch里除了上面说到用FST压缩term index外，对posting list也有压缩技巧。 
小明喝完咖啡又举手了:"posting list不是已经只存储文档id了吗？还需要压缩？"

嗯，我们再看回最开始的例子，如果Elasticsearch需要对同学的性别进行索引(这时传统关系型数据库已经哭晕在厕所……)，会怎样？如果有上千万个同学，而世界上只有男/女这样两个性别，每个posting list都会有至少百万个文档id。 Elasticsearch是如何有效的对这些文档id压缩的呢？

Frame Of Reference

增量编码压缩，将大数变小数，按字节存储

首先，Elasticsearch要求posting list是有序的(为了提高搜索的性能，再任性的要求也得满足)，这样做的一个好处是方便压缩，看下面这个图例： 

Alt text

如果数学不是体育老师教的话，还是比较容易看出来这种压缩技巧的。

原理就是通过增量，将原来的大数变成小数仅存储增量值，再精打细算按bit排好队，最后通过字节存储，而不是大大咧咧的尽管是2也是用int(4个字节)来存储。

Roaring bitmaps

说到Roaring bitmaps，就必须先从bitmap说起。Bitmap是一种数据结构，假设有某个posting list：

[1,3,4,7,10]

对应的bitmap就是：

[1,0,1,1,0,0,1,0,0,1]

非常直观，用0/1表示某个值是否存在，比如10这个值就对应第10位，对应的bit值是1，这样用一个字节就可以代表8个文档id，旧版本(5.0之前)的Lucene就是用这样的方式来压缩的，但这样的压缩方式仍然不够高效，如果有1亿个文档，那么需要12.5MB的存储空间，这仅仅是对应一个索引字段(我们往往会有很多个索引字段)。于是有人想出了Roaring bitmaps这样更高效的数据结构。

Bitmap的缺点是存储空间随着文档个数线性增长，Roaring bitmaps需要打破这个魔咒就一定要用到某些指数特性：

将posting list按照65535为界限分块，比如第一块所包含的文档id范围在0~65535之间，第二块的id范围是65536~131071，以此类推。再用<商，余数>的组合表示每一组id，这样每组里的id范围都在0~65535内了，剩下的就好办了，既然每组id不会变得无限大，那么我们就可以通过最有效的方式对这里的id存储。

Alt text

细心的小明这时候又举手了:"为什么是以65535为界限?"

程序员的世界里除了1024外，65535也是一个经典值，因为它=2^16-1，正好是用2个字节能表示的最大数，一个short的存储单位，注意到上图里的最后一行“If a block has more than 4096 values, encode as a bit set, and otherwise as a simple array using 2 bytes per value”，如果是大块，用节省点用bitset存，小块就豪爽点，2个字节我也不计较了，用一个short[]存着方便。

那为什么用4096来区分大块还是小块呢？

个人理解：都说程序员的世界是二进制的，4096*2bytes ＝ 8192bytes < 1KB, 磁盘一次寻道可以顺序把一个小块的内容都读出来，再大一位就超过1KB了，需要两次读。

联合索引

上面说了半天都是单field索引，如果多个field索引的联合查询，倒排索引如何满足快速查询的要求呢？

  • 利用跳表(Skip list)的数据结构快速做“与”运算，或者
  • 利用上面提到的bitset按位“与”

先看看跳表的数据结构：

Alt text

将一个有序链表level0，挑出其中几个元素到level1及level2，每个level越往上，选出来的指针元素越少，查找时依次从高level往低查找，比如55，先找到level2的31，再找到level1的47，最后找到55，一共3次查找，查找效率和2叉树的效率相当，但也是用了一定的空间冗余来换取的。

假设有下面三个posting list需要联合索引：

Alt text

如果使用跳表，对最短的posting list中的每个id，逐个在另外两个posting list中查找看是否存在，最后得到交集的结果。

如果使用bitset，就很直观了，直接按位与，得到的结果就是最后的交集。

总结和思考

Elasticsearch的索引思路:

将磁盘里的东西尽量搬进内存，减少磁盘随机读取次数(同时也利用磁盘顺序读特性)，结合各种奇技淫巧的压缩算法，用及其苛刻的态度使用内存。

所以，对于使用Elasticsearch进行索引时需要注意:

  • 不需要索引的字段，一定要明确定义出来，因为默认是自动建索引的
  • 同样的道理，对于String类型的字段，不需要analysis的也需要明确定义出来，因为默认也是会analysis的
  • 选择有规律的ID很重要，随机性太大的ID(比如java的UUID)不利于查询

关于最后一点，个人认为有多个因素:

其中一个(也许不是最重要的)因素: 上面看到的压缩算法，都是对Posting list里的大量ID进行压缩的，那如果ID是顺序的，或者是有公共前缀等具有一定规律性的ID，压缩比会比较高；

另外一个因素: 可能是最影响查询性能的，应该是最后通过Posting list里的ID到磁盘中查找Document信息的那步，因为Elasticsearch是分Segment存储的，根据ID这个大范围的Term定位到Segment的效率直接影响了最后查询的性能，如果ID是有规律的，可以快速跳过不包含该ID的Segment，从而减少不必要的磁盘读次数，具体可以参考这篇如何选择一个高效的全局ID方案(评论也很精彩)

来源：点击访问

Logo
华为云开发者联盟

为开发者提供学习成长、分享交流、生态实践、资源工具等服务，帮助开发者快速成长。

更多推荐

cover

解锁HDC 2024之旅：从购票到报名，全程攻略

avatar 华为云开发者联盟
cover

从原始边列表到邻接矩阵Python实现图数据处理的完整指南

avatar 华为云开发者联盟
cover

华为云云原生FinOps解决方案，释放云原生最大价值

avatar 华为云开发者联盟