Elasticsearch

介绍

Elasticsearch是由elastic公司开发的一套搜索引擎技术，它是elastic技术栈中的一部分。完整的技术栈包括：

• Elasticsearch：用于数据存储、计算和搜索
• Logstash/Beats：用于数据收集
• Kibana：用于数据可视化

整套技术栈被称为ELK，经常用来做日志收集、系统监控和状态分析等等。

Elasticsearch对外提供的是Restful风格的API，任何操作都可以通过发送http请求来完成。不过http请求的方式、路径、还有请求参数的格式都有严格的规范。

安装

linux离线安装

安装ElasticSearch

下载链接：https://www.elastic.co/downloads/past-releases#elasticsearch

1. 上传离线包至服务器/usr/local目录下 。
2. 进入该目录，使用tar -xzvf elasticsearch-6.8.11.tar.gz命令进行解压。
3. 修改es配置文件 vi /usr/local/elasticsearch-6.8.11/config/elasticsearch.yml

# 设置为0.0.0.0，该参数表示允许所有ip访问，es默认仅允许本机访问
#network.host: 192.168.0.1
# 取消注释
#http.port: 9200

4. 修改jvm参数，vi /usr/local/elasticsearch-6.8.11/config/jvm.options

## JVM configuration

####################################################
## IMPORTANT: JVM heap size
####################################################
##
## You should always set the min and max JVM heap
## size to the same value. For example, to set
## the heap to 4 GB, set:
##
## -Xms4g
## -Xmx4g
##
## See https://www.elastic.co/guide/en/elasticsearch/reference/current/heap-size.html
## for more information
##
####################################################

# Xms represents the initial size of total heap space
# Xmx represents the maximum size of total heap space

# 根据实际内存情况进行分配运行堆内存，一般设置为物理机的1/4且最大不超过32G，
-Xms1g 
-Xmx1g

5. 创建es用户

创建用户组：groupadd es
创建用户并添加至用户组：useradd es -g es

🌍 说明

Elasticsearch默认不允许使用root进行安装，在安装之前，应创建一个用户及用户组。

6. 切换到es用户su es，进入bin目录cd /usr/local/elasticsearch-6.8.11/bin/
7. 执行./elasticsearch启动ES。
8. 防火墙开放端口。

firewall-cmd --zone=public --add-port=9200/tcp --permanent
firewall-cmd --reload

9. 在浏览器输入ip:9200来验证elasticsearch是否配置成功，若出现以下字样说明配置成功.

{
  "name" : "3CBfLD\_",
  "cluster\_name" : "elasticsearch",
  "cluster\_uuid" : "Hszg4mFkRuugIAN0golMNw",
  "version" : {
    "number" : "6.8.11",
    "build\_flavor" : "default",
    "build\_type" : "tar",
    "build\_hash" : "00bf386",
    "build\_date" : "2020-07-09T19:08:08.940669Z",
    "build\_snapshot" : false,
    "lucene\_version" : "7.7.3",
    "minimum\_wire\_compatibility\_version" : "5.6.0",
    "minimum\_index\_compatibility\_version" : "5.0.0"
  },
  "tagline" : "You Know, for Search"
}

安装kibana

下载链接：https://www.elastic.co/downloads/past-releases#kibana

1. 上传离线包至服务器/usr/local目录下
2. 使用cd /usr/local命令进入该目录，使用tar -xzvf kibana-6.8.11.tar.gz命令进行解压。
3. 给es用户授权

chown -R es:es /usr/local/kibana-6.8.11-linux-x86_64

4. 修改配置文件vi /usr/local/kibana-6.8.11-linux-x86_64/config/kibana.yml,修改内容如下

server.port: 5601
server.host: "0.0.0.0"
#修改为ES的连接地址
elasticsearch.url: "http://localhost:9200"
#设置中文
i18n.locale: "zh-CN"

5. 启动kibana

#切换到es用户
su es
#进入bin目录
cd /usr/local/kibana-6.8.11-linux-x86_64/bin
#启动kibana
./kibana

6. 防火墙开放端口

firewall-cmd --zone=public --add-port=5601/tcp --permanent
firewall-cmd --reload

7. 验证是否配置成功，在浏览器输入ip:5601，若能访问kibana页面即配置成功。

IK分词器安装

下载地址：https://release.infinilabs.com/analysis-ik/stable/

github：https://github.com/infinilabs/analysis-ik/releases

下载和elasticsearch对应版本的ik版本，插件文件夹新建一个ik目录【/elasticsearch-xxx/plugins/ik】，将zip文件解压到，必须是ik目录，否则es启动不识别，给ik目录授权【chmod 777 ik】，重启es

进入kibana测试

POST /_analyze
{
  "analyzer": "ik_smart",
  "text": "这是一个测试"
}

elasticsearch-head插件【可选】

可安装，浏览器插件

github搜索elasticsearch-head【已暂停更新】，crx文件夹下的es-head.crx解压，谷歌浏览器 >>>管理扩展程序 >>>打开开发者模式 >>>加载已解压的扩展程序 >>>导入解压的文件夹 >>>输入es的ip地址连接

Elasticvue插件【可选】

🚀同样的浏览器插件还有Elasticvue【插件还在更新，而且支持中文语言】

谷歌浏览器插件搜索Elasticvue安装【需科学上网】：

https://chromewebstore.google.com/

正向索引和倒排索引

相关概念【es中的】

• 索引

提高数据查询速度的一种数据结构

• 文档（Document）

每条数据就是一个文档，文档数据会被序列化为 json 格式后存储在 elasticsearch 中

• 词条（Term）

对文档数据或用户搜索数据，利用某种算法分词，得到的具备含义的词语就是词条。例如：我是中国人，就可以分为：我、是、中国人、中国、国人这样的几个词条

正向索引和倒排索引

• 正向索引

查询词条时必须先找到文档，而后判断是否包含词条。

将文档id建立为索引，通过id快速可以快速查找数据。如数据库中的主键就会创建正排索引。

根据id精确匹配时，可以走索引，查询效率较高。而当搜索条件为模糊匹配时，由于索引无法生效，导致从索引查询退化为全表扫描，效率很差。

因此，正向索引适合于根据索引字段的精确搜索，不适合基于部分词条的模糊匹配。

而倒排索引恰好解决的就是根据部分词条模糊匹配的问题。

• 倒排索引

对文档内容分词，对词条创建索引，并记录词条所在文档的信息。查询时先根据词条查询到文档 id ，而后获取到文档。

es和mysql概念对比

MySQL	Elasticsearch	说明
Table	Index【索引】	索引(index)，就是文档的集合，类似数据库的表(table)
Row	Document【文档】	文档（Document），就是一条条的数据，类似数据库中的行（Row），文档都是JSON格式
Column	Field【字段】	字段（Field），就是JSON文档中的字段，类似数据库中的列（Column）
Schema	Mapping【映射】	Mapping（映射）是索引中文档的约束，例如字段类型约束。类似数据库的表结构（Schema）
SQL	DSL【Domain Specific Language领域特定语言】	DSL是elasticsearch提供的JSON风格的请求语句，用来操作elasticsearch，实现CRUD

💡两者对比：

• Mysql：擅长事务类型操作，可以确保数据的安全和一致性

• Elasticsearch：擅长海量数据的搜索、分析、计算

• 对安全性要求较高的写操作，使用mysql实现

• 对查询性能要求较高的搜索需求，使用elasticsearch实现

• 两者再基于某种方式，实现数据的同步，保证一致性

分词器

普通分词器

es 在创建倒排索引时需要对文档分词；在搜索时，需要对用户输入内容分词。

POST /_analyze
{
  "text": "你好分词器",
  "analyzer": "standard"
}

语法说明：

• POST ：请求方式
• /_analyze ：请求路径，这里省略了 http://ip:9200，有 kibana 帮我们补充
• 请求参数， json 风格
  • analyzer ：分词器类型，这里是默认的 standard 分词器
  • text ：要分词的内容

分词结果：

{
  "tokens" : [
    {
      "token" : "你",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "<IDEOGRAPHIC>",
      "position" : 0
    },
    {
      "token" : "好",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "<IDEOGRAPHIC>",
      "position" : 1
    },
    {
      "token" : "分",
      "start_offset" : 2,
      "end_offset" : 3,
      "type" : "<IDEOGRAPHIC>",
      "position" : 2
    },
    {
      "token" : "词",
      "start_offset" : 3,
      "end_offset" : 4,
      "type" : "<IDEOGRAPHIC>",
      "position" : 3
    },
    {
      "token" : "器",
      "start_offset" : 4,
      "end_offset" : 5,
      "type" : "<IDEOGRAPHIC>",
      "position" : 4
    }
  ]
}

ik分词器

处理中文分词，一般会使用 IK 分词器

ik 分词器包含两种模式：

• ik_smart ：最少切分，粗粒度

POST /_analyze
{
  "text": "你好分词器",
  "analyzer": "ik_smart"
}

分词结果：

{
  "tokens" : [
    {
      "token" : "你好",
      "start_offset" : 0,
      "end_offset" : 2,
      "type" : "CN_WORD",
      "position" : 0
    },
    {
      "token" : "分词器",
      "start_offset" : 2,
      "end_offset" : 5,
      "type" : "CN_WORD",
      "position" : 1
    }
  ]
}

• ik_max_word ：最细切分，细粒度

POST /_analyze
{
  "text": "你好分词器",
  "analyzer": "ik_max_word"
}

分词结果：

{
  "tokens" : [
    {
      "token" : "你好",
      "start_offset" : 0,
      "end_offset" : 2,
      "type" : "CN_WORD",
      "position" : 0
    },
    {
      "token" : "分词器",
      "start_offset" : 2,
      "end_offset" : 5,
      "type" : "CN_WORD",
      "position" : 1
    },
    {
      "token" : "分词",
      "start_offset" : 2,
      "end_offset" : 4,
      "type" : "CN_WORD",
      "position" : 2
    },
    {
      "token" : "器",
      "start_offset" : 4,
      "end_offset" : 5,
      "type" : "CN_CHAR",
      "position" : 3
    }
  ]
}

支持拓展词库

找到ik分词器安装目录下的config路径下的IKAnalyzer.cfg.xml文件，配置自己的拓展词以及停用词的路径

编辑IKAnalyzer.cfg.xml文件：

举例：

POST /_analyze
{
  "text": "你好分词器",
  "analyzer": "ik_smart"
}

分词结果：

{
  "tokens" : [
    {
      "token" : "你好分词器",
      "start_offset" : 0,
      "end_offset" : 5,
      "type" : "CN_WORD",
      "position" : 0
    }
  ]
}

索引操作

mapping映射

mapping是对索引库中文档的约束，常见的mapping属性包括：

• type：字段数据类型，常见的简单类型有：
  • 字符串：text（可分词的文本）、keyword（精确值，例如：品牌、国家、ip地址）
  • 数值：long、integer、short、byte、double、float、
  • 布尔：boolean
  • 日期：date
  • 对象：object
• index：是否创建索引，默认为true
• analyzer：使用哪种分词器
• properties：该字段的子字段

创建索引

PUT /索引库名称
{
  "mappings": {
    "properties": {
      " 字段名 ": {
        "type": "text",
        "analyzer": "ik_smart"
      },
      " 字段名 2": {
        "type": "keyword",
        "index": "false"
      },
      " 字段名 3": {
        "properties": {
          " 子字段 ": {
            "type": "keyword"
          }
        }
      }
    }
  }
}

举例：

PUT /iam
{
  "mappings": {
    "properties": {
      "info":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "email":{
        "type": "keyword",
        "index": "false"
      },
      "name":{
        "properties": {
          "firstName": {
            "type": "keyword"
          }
        }
      }
    }
  }
}

返回结果：

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "iam"
}

查看索引

GET /iam

删除索引

DELETE /iam

修改索引

索引库和 mapping 一旦创建无法修改，但是可以添加新的字段，语法如下：
添加字段： PUT / 索引库名 /_mapping

PUT /iam/_mapping
{
  "properties": {
    "age": {
      "type": "integer"
    }
  }
}

索引总结

🌍总结：

• 创建索引库：PUT /索引库名
• 查询索引库：GET /索引库名
• 删除索引库：DELETE /索引库名
• 修改索引库，添加字段：PUT /索引库名/_mapping

文档操作

新增文档

POST /索引库名/_doc/文档id
{
  " 字段 1": " 值 1",
  " 字段 2": " 值 2",
  " 字段 3": {
    " 子属性 1": " 值 3",
    " 子属性 2": " 值 4"
  }
}

举例：

POST /iam/_doc/1
{
  "info": "Java工程师",
  "email": "zy@test.cn",
  "age": 20,
  "name": {
    "firstName": "张",
    "fullName": "张三"
  }
}

返回结果：

{
  "_index" : "iam",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 1,
  "result" : "created",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 0,
  "_primary_term" : 1
}

查看文档

GET /索引库名/_doc/文档 id

举例：

GET /iam/_doc/1

返回结果：

{
  "_index" : "iam",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 1,
  "_seq_no" : 0,
  "_primary_term" : 1,
  "found" : true,
  "_source" : {
    "info" : "Java工程师",
    "email" : "zy@test.cn",
    "age" : 20,
    "name" : {
      "firstName" : "张",
      "fullName" : "张三"
    }
  }
}

删除文档

DELETE /索引库名/_doc/文档 id

DELETE /iam/_doc/1

返回结果：

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

修改文档

修改有两种方式：

• 全量修改：直接覆盖原来的文档
• 局部修改：修改文档中的部分字段

方式一：全量修改，会删除旧文档，添加新文档

PUT /iam/_doc/1
{
  "info": "Java攻城狮",
  "email": "zy@test.cn",
  "name": {
    "firstName": "云",
    "fullName": "赵云"
  }
}

返回结果：

{
  "_index" : "iam",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 2,
  "result" : "updated",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 3,
  "_primary_term" : 1
}

方式二：局部修改，修改指定字段值

POST /iam/_update/1
{
  "doc": {
    "email": "ZhaoYun@test.cn"
  }
}

批处理

POST _bulk
{ "index" : { "_index" : "test", "_id" : "1" } }
{ "field1" : "value1" }
{ "delete" : { "_index" : "test", "_id" : "2" } }
{ "create" : { "_index" : "test", "_id" : "3" } }
{ "field1" : "value3" }
{ "update" : {"_id" : "1", "_index" : "test"} }
{ "doc" : {"field2" : "value2"} }

说明：

• index代表新增操作
  • _index：指定索引库名
  • _id指定要操作的文档id
  • { "field1" : "value1" }：则是要新增的文档内容
• delete代表删除操作
  • _index：指定索引库名
  • _id指定要操作的文档id
• update代表更新操作
  • _index：指定索引库名
  • _id指定要操作的文档id
  • { "doc" : {"field2" : "value2"} }：要更新的文档字段

示例，批量新增：

POST /_bulk
{"index": {"_index":"iam", "_id": "3"}}
{"info": "C++", "email": "ww@test.cn", "name":{"firstName": "五", "lastName":"王"}}
{"index": {"_index":"iam", "_id": "4"}}
{"info": "前端", "email": "zhangsan@test.cn", "name":{"firstName": "三", "lastName":"张"}}

批量删除：

POST /_bulk
{"delete":{"_index":"iam", "_id": "3"}}
{"delete":{"_index":"iam", "_id": "4"}}

总结

🌍总结：

• 创建文档：POST /{索引库名}/_doc/文档id { json文档 }
• 查询文档：GET /{索引库名}/_doc/文档id
• 删除文档：DELETE /{索引库名}/_doc/文档id
• 修改文档：
  • 全量修改：PUT /{索引库名}/_doc/文档id { json文档 }
  • 局部修改：POST /{索引库名}/_update/文档id { "doc": {字段}}

DSL查询

Elasticsearch提供了基于JSON的DSL（Domain Specific Language）语句来定义查询条件，其JavaAPI就是在组织DSL条件。

Elasticsearch的查询可以分为两大类：

• 叶子查询（Leaf query clauses）：一般是在特定的字段里查询特定值，属于简单查询，很少单独使用。
• 复合查询（Compound query clauses）：以逻辑方式组合多个叶子查询或者更改叶子查询的行为方式。

语法：GET /{索引库名}/_search：其中的_search是固定路径，不能修改

GET /{索引库名}/_search
{
  "query": {
    "查询类型": {
      // .. 查询条件
    }
  }
}

无条件查询

由于match_all无条件，所以条件位置不写即可。

GET /items/_search
{
  "query": {
    "match_all": {
      
    }
  }
}

虽然是match_all，但是响应结果中并不会包含索引库中的所有文档，而是仅有10条。这是因为处于安全考虑，elasticsearch设置了默认的查询页数。

叶子查询

这里列举一些常见的，例如：

• 全文检索查询（Full Text Queries）：利用分词器对用户输入搜索条件先分词，得到词条，然后再利用倒排索引搜索词条。例如：
  • match：
  • multi_match
• 精确查询（Term-level queries）：不对用户输入搜索条件分词，根据字段内容精确值匹配。但只能查找keyword、数值、日期、boolean类型的字段。例如：
  • ids
  • term
  • range
• **地理坐标查询：**用于搜索地理位置，搜索方式很多，例如：
  • geo_bounding_box：按矩形搜索
  • geo_distance：按点和半径搜索
• ...略

Full Text Queries

全文检索查询（Full Text Queries）：利用分词器对用户输入搜索条件先分词，得到词条，然后再利用倒排索引搜索词条。🚀， 例如：

• match：
• multi_match

• match：

GET /{索引库名}/_search
{
  "query": {
    "match": {
      "字段名": "搜索条件"
    }
  }
}

GET /items/_search
{
  "query": {
    "match": {
      "name": "华为"
    }
  }
}

• multi_match

与match类似的还有multi_match，区别在于可以同时对多个字段搜索，而且多个字段都要满足，语法示例：

GET /{索引库名}/_search
{
  "query": {
    "multi_match": {
      "query": "搜索条件",
      "fields": ["字段1", "字段2"]
    }
  }
}

GET /items/_search
{
  "query": {
    "multi_match": {
      "query": "华为",
      "fields": ["name", "brand"]
    }
  }
}

Term-level queries

精确查询（Term-level queries）：不对用户输入搜索条件分词，根据字段内容精确值匹配。🚀。例如：

• ids
• term
• range

语法：

• term

GET /{索引库名}/_search
{
  "query": {
    "term": {
      "字段名": {
        "value": "搜索条件"
      }
    }
  }
}

• range

GET /{索引库名}/_search
{
  "query": {
    "range": {
      "字段名": {
        "gte": {最小值},
        "lte": {最大值}
      }
    }
  }
}

range是范围查询，对于范围筛选的关键字有：

• gte：大于等于
• gt：大于
• lte：小于等于
• lt：小于

复合查询

复合查询大致可以分为两类：

• 第一类：基于逻辑运算组合叶子查询，实现组合条件，例如
  • bool
• 第二类：基于某种算法修改查询时的文档相关性算分，从而改变文档排名。例如：
  • function_score
  • dis_max

算分函数查询

当我们利用match查询时，文档结果会根据与搜索词条的关联度打分（_score），返回结果时按照分值降序排列。

例如：_score字段

GET /iam/_search
{
  "query": {
    "multi_match": {
      "query": "前端讲师",
      "fields": ["info"]
    }
  }
}


返回结果：
{
  "took" : 3,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 1.5408845,
    "hits" : [
      {
        "_index" : "iam",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : 1.5408845,
        "_source" : {
          "info" : "前端讲师",
          "email" : "zhangsan@test.cn",
          "name" : {
            "firstName" : "三",
            "lastName" : "张"
          }
        }
      },
      {
        "_index" : "iam",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 0.49917626,
        "_source" : {
          "info" : "C++讲师",
          "email" : "ww@test.cn",
          "name" : {
            "firstName" : "五",
            "lastName" : "王"
          }
        }
      }
    ]
  }
}

从elasticsearch5.1开始，采用的相关性打分算法是BM25算法，公式如下：

基于这套公式，就可以判断出某个文档与用户搜索的关键字之间的关联度，还是比较准确的。但是，在实际业务需求中，常常会有竞价排名的功能。不是相关度越高排名越靠前，而是掏的钱多的排名靠前。要想人为控制相关性算分，就需要利用elasticsearch中的function score 查询了。

🌍基本语法

function score 查询中包含四部分内容：

• 原始查询条件：query部分，基于这个条件搜索文档，并且基于BM25算法给文档打分，原始算分（query score)
• 过滤条件：filter部分，符合该条件的文档才会重新算分
• 算分函数：符合filter条件的文档要根据这个函数做运算，得到的函数算分（function score），有四种函数
  • weight：函数结果是常量
  • field_value_factor：以文档中的某个字段值作为函数结果
  • random_score：以随机数作为函数结果
  • script_score：自定义算分函数算法
• 运算模式：算分函数的结果、原始查询的相关性算分，两者之间的运算方式，包括：
  • multiply：相乘
  • replace：用function score替换query score
  • 其它，例如：sum、avg、max、min

function score的运行流程如下：

• 1）根据原始条件查询搜索文档，并且计算相关性算分，称为原始算分（query score）
• 2）根据过滤条件，过滤文档
• 3）符合过滤条件的文档，基于算分函数运算，得到函数算分（function score）
• 4）将原始算分（query score）和函数算分（function score）基于运算模式做运算，得到最终结果，作为相关性算分。

因此，其中的关键点是：

• 过滤条件：决定哪些文档的算分被修改
• 算分函数：决定函数算分的算法
• 运算模式：决定最终算分结果

示例：给IPhone这个品牌的手机算分提高十倍，分析如下：

• 过滤条件：品牌必须为IPhone
• 算分函数：常量weight，值为10
• 算分模式：相乘multiply

对应代码如下：

GET /hotel/_search
{
  "query": {
    "function_score": {
      "query": {  .... }, // 原始查询，可以是任意条件
      "functions": [ // 算分函数
        {
          "filter": { // 满足的条件，品牌必须是Iphone
            "term": {
              "brand": "Iphone"
            }
          },
          "weight": 10 // 算分权重为2
        }
      ],
      "boost_mode": "multipy" // 加权模式，求乘积
    }
  }
}

bool查询

bool查询，即布尔查询。就是利用逻辑运算来组合一个或多个查询子句的组合。bool查询支持的逻辑运算有：

• must：必须匹配每个子查询，类似“与”
• should：选择性匹配子查询，类似“或”
• must_not：必须不匹配，不参与算分，类似“非”
• filter：必须匹配，不参与算分

*�基本语法

GET /items/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {"name": "手机"}}
      ],
      "should": [
        {"term": {"brand": { "value": "vivo" }}},
        {"term": {"brand": { "value": "小米" }}}
      ],
      "must_not": [
        {"range": {"price": {"gte": 2500}}}
      ],
      "filter": [
        {"range": {"price": {"lte": 1000}}}
      ]
    }
  }
}

出于性能考虑，与搜索关键字无关的查询尽量采用must_not或filter逻辑运算，避免参与相关性算分。

排序

elasticsearch默认是根据相关度算分（_score）来排序，但是也支持自定义方式对搜索结果排序。不过分词字段无法排序，能参与排序字段类型有：keyword类型、数值类型、地理坐标类型、日期类型等。

*�基本语法

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "排序字段": {
        "order": "排序方式asc和desc"
      }
    }
  ]
}

示例，我们按照商品价格排序：

GET /items/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "price": {
        "order": "desc"
      }
    }
  ]
}

分页

elasticsearch 默认情况下只返回top10的数据。而如果要查询更多数据就需要修改分页参数了。

基础分页

elasticsearch中通过修改from、size参数来控制要返回的分页结果：

• from：从第几个文档开始
• size：总共查询几个文档

类似于mysql中的limit ?, ?

🌍基本语法

GET /items/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0, // 分页开始的位置，默认为0
  "size": 10,  // 每页文档数量，默认10
  "sort": [
    {
      "price": {
        "order": "desc"
      }
    }
  ]
}

深度分页

当查询分页深度较大时，汇总数据过多，对内存和CPU会产生非常大的压力。

因此elasticsearch会禁止from+ size 超过10000的请求。

针对深度分页，elasticsearch提供了两种解决方案：

• search after：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐使用的方式。

优点：没有查询上限

缺点：只能向后逐页查询，不能随机翻页

适用场景：数据迁移，手动滚动查询

• scroll：原理将排序后的文档id形成快照，保存下来，基于快照做分页。官方已经不推荐使用。

总结：

大多数情况下，采用普通分页就可以了。

查看百度、京东等网站，会发现其分页都有限制。例如百度最多支持77页，每页不足20条。京东最多100页，每页最多60条。

因此，一般采用限制分页深度的方式即可，无需实现深度分页。

高亮

我们在百度，京东搜索时，关键字会变成红色，比较醒目，这叫高亮显示

css样式肯定是前端实现页面的时候写好的，但是前端编写页面的时候是不知道页面要展示什么数据的，不可能给数据加标签。而服务端实现搜索功能，要是有elasticsearch做分词搜索，是知道哪些词条需要高亮的。

因此词条的高亮标签肯定是由服务端提供数据的时候已经加上的。

因此实现高亮的思路就是：

• 用户输入搜索关键字搜索数据
• 服务端根据搜索关键字到elasticsearch搜索，并给搜索结果中的关键字词条添加html标签
• 前端提前给约定好的html标签添加CSS样式

*�基本语法：

GET /{索引库名}/_search
{
  "query": {
    "match": {
      "搜索字段": "搜索关键字"
    }
  },
  "highlight": {
    "fields": {
      "高亮字段名称": {
        "pre_tags": "<em>",
        "post_tags": "</em>"
      }
    }
  }
}

注意：

• 搜索必须有查询条件，而且是全文检索类型的查询条件，例如match
• 参与高亮的字段必须是text类型的字段
• 默认情况下参与高亮的字段要与搜索字段一致，除非添加：required_field_match=false

🌍【Easy-Es】

推荐easy-es框架：https://www.easy-es.cn/

Easy-Es（简称EE）是一款基于ElasticSearch(简称Es)官方提供的RestHighLevelClient打造的ORM开发框架，在 RestHighLevelClient 的基础上,只做增强不做改变，为简化开发、提高效率而生,您如果有用过Mybatis-Plus(简称MP),那么您基本可以零学习成本直接上手EE,EE是MP的Es平替版,在有些方面甚至比MP更简单,同时也融入了更多Es独有的功能,助力您快速实现各种场景的开发