数据结构+算法=程序
程序+设计模式=框架

0%

ElasticSearch快速入门

发表于 分类于 阅读次数： 评论：

1 Elasticsearch介绍和安装

1.1 Elasticsearch简介

什么是Elasticsearch

Elaticsearch简称为es,是一个开源的可扩展的全文检索引擎服务器，它可以近乎实时的存储、检索数据；本身扩展性很好，可以扩展到上百台服务器，处理PB级别的数据。es使用Java开发并使用Lucene作为其核心来实现索引和搜索的功能，但是它通过简单的RestfulAPI和javaAPI来隐藏Lucene的复杂性，从而让全文搜索变得简单。

Elasticsearch官网：https://www.elastic.co/cn/products/elasticsearch

ES企业使用场景

企业使用场景一般分为2种情况：

  1. 已经上线的系统，某些模块的搜索功能是使用数据库搜索实现的，但是已经出现性能问题或者不满足产品的高亮相关度排序的需求时候，就会对系统的搜索功能进行技术改造，使用全文检索，而es就是首选。针对这种情况企业改造的业务流程如下图：

  2. 系统新增加的模块，产品一开始就要实现高亮相关度排序等全文检索的功能或者技术分析觉得该模块使用全文检索更适合。针对这种情况企业改造的业务流程如下图：

索引库（ES）存什么数据

索引库的数据是用来搜索用的，里面存储的数据和数据库一般不会是完全一样的，一般都比数据库的数据少。那索引库存什么数据呢？以业务需求为准，需求决定页面要显示什么字段以及会按什么字段进行搜索，那么这些字段就都要保存到索引库中。

1.2 Elasticsearch安装和配置

为了模拟真实场景，我们将在linux下安装Elasticsearch，我们使用6.8.0版本，建议使用JDK1.8及以上
环境要求：

  • centos 7 64位
  • JDK8及以上

本文演示Elasticsearch安装包下载地址：百度云，提取码: 79wa

新建一个用户

出于安全考虑，elasticsearch默认不允许以root账号运行。

1
2
3
4
5
6
# 创建elastic用户
useradd elastic
# 设置密码
passwd elastic
# 切换用户
su - elastic

上传安装包并解压

我们将安装包上传到：/home/elastic目录

1
2
cd /home/elastic
rz

解压缩：

1
tar xvf elasticsearch-6.8.0.tar.gz

目录重命名：

1
mv elasticsearch-6.8.0/ elasticsearch

进入，查看目录结构：

  • bin 二进制脚本，包含启动命令等
  • config 配置文件目录
  • lib 依赖包目录
  • logs 日志文件目录
  • modules 模块库
  • plugins 插件目录，这里存放一些常用的插件比如IK分词器插件
  • data 数据储存目录(暂时没有，需要在配置文件中指定存放位置，启动es时会自动根据指定位置创建)

修改配置

进入config目录：

1
2
cd config
ll

需要修改的配置文件有两个：

修改jvm配置：

Elasticsearch基于Lucene的，而Lucene底层是java实现，因此我们需要配置jvm参数设置堆大小

1
vim jvm.options

默认配置如下：

1
2
-Xms1g
-Xmx1g

内存占用太多了，我们可以调小一些，最小设置128m，如果虚机内存允许的话设置为512m

1
2
-Xms256m 
-Xmx256m

修改elasticsearch.yml：

1
vim elasticsearch.yml

修改数据和日志目录：

1
2
path.data: /home/elastic/elasticsearch/data # 数据目录位置
path.logs: /home/elastic/elasticsearch/logs # 日志目录位置

修改绑定的ip：

1
network.host: 0.0.0.0 # 绑定到0.0.0.0，允许任何ip来访问

默认只允许本机访问，修改为0.0.0.0后则可以远程访问。
目前我们是做的单机安装，如果要做集群，只需要在这个配置文件中添加其它节点信息即可。

elasticsearch.yml的其它可配置信息：

属性名 说明
cluster.name 配置elasticsearch的集群名称，默认是elasticsearch。建议修改成一个有意义的名称。
node.name 节点名，es会默认随机指定一个名字，建议指定一个有意义的名称，方便管理。
path.conf 设置配置文件的存储路径，tar或zip包安装默认在es根目录下的config文件夹，rpm安装默认在/etc/ elasticsearch。
path.data 设置索引数据的存储路径，默认是es根目录下的data文件夹，可以设置多个存储路径，用逗号隔开。
path.logs 设置日志文件的存储路径，默认是es根目录下的logs文件夹。
path.plugins 设置插件的存放路径，默认是es根目录下的plugins文件夹。
bootstrap.memory_lock 设置为true可以锁住ES使用的内存，避免内存进行swap。
network.host 设置bind_host和publish_host，设置为0.0.0.0允许外网访问。
http.port 设置对外服务的http端口，默认为9200。
transport.tcp.port 集群结点之间通信端口。
discovery.zen.ping.timeout 设置ES自动发现节点连接超时的时间，默认为3秒，如果网络延迟高可设置大些。
discovery.zen.minimum_master_nodes 主结点数量的最少值 ,此值的公式为：(master_eligible_nodes / 2) + 1 ，比如：有3个符合要求的主结点，那么这里要设置为2。

1.3 启动运行

进入elasticsearch/bin目录，可以看到下面的执行文件：

然后输入命令：

1
./elasticsearch

后台启动：

1
./elasticsearch -d

如启动失败，查看错误信息：

错误1：

1
[1]: max file descriptors [4096] for elasticsearch process likely too low, increase to at least [65535]

问题翻译过来就是：elasticsearch用户拥有的可创建文件描述的权限太低，至少需要65535；我们用的是elastic用户，而不是root，所以文件权限不足。
首先用root用户登录。
然后修改配置文件：

1
vim /etc/security/limits.conf

添加下面的内容：注意下面的 “*” 号不要去除

1
2
3
4
5
6
7
8
9
10
11
# 可打开的文件描述符的最大数(软限制)
* soft nofile 65536  

# 可打开的文件描述符的最大数(硬限制)
* hard nofile 131072

# 单个用户可用的最大进程数量(软限制)
* soft nproc 4096

# 单个用户可用的最大进程数量(硬限制)
* hard nproc 4096

错误2：

1
[3]: max virtual memory areas vm.max_map_count [65530] likely too low, increase to at least [262144]

问题翻译过来就是：elasticsearch用户拥有的最大虚拟内存太小，至少需要262144；
继续修改配置文件：

1
vim /etc/sysctl.conf

添加下面内容：

1
vm.max_map_count=262144

然后执行命令：

1
sysctl -p

重启ES

所有错误修改完毕后，关闭终端会话，重新启动ES，可以看到启动成功了

可以看到绑定了两个端口：

  • 9300：集群节点间通讯接口，接收tcp协议
  • 9200：客户端访问接口，接收Http协议

验证是否启动成功：

在浏览器中访问：http://192.168.129.139:9200/，如果不能访问，则需要关闭虚拟机防火墙，**需要root权限**

关闭系统防火墙

1
2
# 查看防火墙：
firewall-cmd --state   (centos7)

1
2
# 关闭防火墙：
systemctl stop firewalld.service   (centos7)

1
2
# 禁止开机启动防火墙：
systemctl disable firewalld.service  (centos7)

如果浏览器显示如下效果，说明启动成功

1.4 图形化可视工具安装

ElasticSearch没有自带图形化界面，我们可以通过安装ElasticSearch的图形化插件，实现图形化界面的效果，完成索引数据的查看。目前主流的ES图形化插件有kibana和elasticsearch-head。
具体安装过程详见：ElasticSearch 可视化插件安装

1.5 集成ik分词器

Lucene的IK分词器早在2012年已经没有维护了，现在我们要使用的是在其基础上维护升级的版本，并且开发为Elasticsearch的集成插件了，与Elasticsearch一起维护升级，版本也保持一致，源码地址：https://github.com/medcl/elasticsearch-analysis-ik

方式一：使用插件安装

1）在elasticsearch的bin目录下执行以下命令,es插件管理器会自动帮我们安装，然后等待安装完成：

1
./elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.8.0/elasticsearch-analysis-ik-6.8.0.zip

2）下载完成后会提示 Continue with installation？输入 y 即可完成安装

3）重启es

方式二：上传安装包安装

1）在elasticsearch的plugins目录下新建 analysis-ik 目录

1
2
3
4
5
6
7
8
9
10
#新建analysis-ik文件夹
mkdir analysis-ik
#切换至 analysis-ik文件夹下
cd analysis-ik
#rz上传资料中的 elasticsearch-analysis-ik-6.8.0.zip
rz  
#解压
unzip elasticsearch-analysis-ik-6.8.0.zip
#解压完成后删除zip
rm -rf elasticsearch-analysis-ik-6.8.0.zip

本文演示analysis-ik安装包下载地址：百度云，提取码: hxj6

2）重启es

推荐使用方式二安装。

测试分词器

IK分词器有两种分词模式：ik_max_word和ik_smart模式。

  1. ik_max_word (常用)：会将文本做最细粒度的拆分
  2. ik_smart：会做最粗粒度的拆分

我们直接在kibana测试一波输入下面的请求：

1
2
3
4
5
POST  _analyze
{
  "analyzer": "ik_max_word",
  "text": "南京市长江大桥"
}

ik_max_word 分词模式运行得到结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
{
    "tokens": [{
            "token": "南京市",
            "start_offset": 0,
            "end_offset": 3,
            "type": "CN_WORD",
            "position": 0
        },
        {
            "token": "南京",
            "start_offset": 0,
            "end_offset": 2,
            "type": "CN_WORD",
            "position": 1
        },
        {
            "token": "市长",
            "start_offset": 2,
            "end_offset": 4,
            "type": "CN_WORD",
            "position": 2
        },
        {
            "token": "长江大桥",
            "start_offset": 3,
            "end_offset": 7,
            "type": "CN_WORD",
            "position": 3
        },
        {
            "token": "长江",
            "start_offset": 3,
            "end_offset": 5,
            "type": "CN_WORD",
            "position": 4
        },
        {
            "token": "大桥",
            "start_offset": 5,
            "end_offset": 7,
            "type": "CN_WORD",
            "position": 5
        }
    ]
}

ik_smart分词模式运行得到结果：

1
2
3
4
5
POST  _analyze
{
  "analyzer": "ik_smart",
  "text": "南京市长江大桥"
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{
    "tokens": [{
            "token": "南京市",
            "start_offset": 0,
            "end_offset": 3,
            "type": "CN_WORD",
            "position": 0
        },
        {
            "token": "长江大桥",
            "start_offset": 3,
            "end_offset": 7,
            "type": "CN_WORD",
            "position": 1
        }
    ]
}

假如江大桥是一个人名，是南京市市长，那么上面的分词显然是不合理的，该怎么办？

添加扩展词典和停用词典

停用词：有些词在文本中出现的频率非常高。但对本文的语义产生不了多大的影响。例如英文的a、an、the、of等。或中文的”的、了、呢等”。这样的词称为停用词。停用词经常被过滤掉，不会被进行索引。在检索的过程中，如果用户的查询词中含有停用词，系统会自动过滤掉。停用词可以加快索引的速度，减少索引库文件的大小。

扩展词：就是不想让哪些词被分开，让他们分成一个词。比如上面的江大桥。

自定义扩展词库

  1. 进入到elasticsearch/config/analysis-ik(插件安装方式) 或 elasticsearch/plugins/analysis-ik/config(安装包安装方式) 目录下, 新增自定义词典

    1
    vim myext_dict.dic

  2. 将我们自定义的扩展词典文件添加到IKAnalyzer.cfg.xml配置中

    1
    vim IKAnalyzer.cfg.xml

    然后重启：

1.6 API简介

Elasticsearch提供了Restful风格的API，即http请求接口，而且也提供了各种语言的客户端API。

Restful风格API

文档地址：https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html

客户端API

Elasticsearch支持的客户端非常多：https://www.elastic.co/guide/en/elasticsearch/client/index.html

1.7 ElasticSearch相关概念

Elasticsearch是基于Lucene的全文检索库，本质也是存储数据，很多概念与MySQL类似的。
对比关系：

ElasticSearch Mysql
索引库（indexes） 数据库（databases）
类型（type） 数据表（table）
文档（document） 行（row）
字段（field） 列（column）
映射配置（mappings） 表结构

详细说明：

概念 说明
索引库（indexes) 索引库包含一堆相关业务，结构相似的文档document数据，比如说建立一个商品product索引库，里面可能就存放了所有的商品数据。
类型（type） type是索引库中的一个逻辑数据分类，一个type下的document，都有相同的field，类似于数据库中的表。比如商品type，里面存放了所有的商品document数据。6.0版本以后一个index只能有1个type，6.0版本以前每个index里可以是一个或多个type。
文档（document） 文档是es中的存入索引库最小数据单元，一个document可以是一条客户数据，一条商品数据，一条订单数据，通常用JSON数据结构表示。document存在索引库下的type类型中。
字段（field） Field是Elasticsearch的最小单位。一个document里面有多个field，每个field就是一个数据字段。
映射配置（mappings） 类型对文档结构的约束叫做映射(mapping)，用来定义document的每个字段的约束。如：字段的数据类型、是否分词、是否索引、是否存储等特性。类型是模拟mysql中的table概念。表是有结构的，也就是表中每个字段都有约束信息。

2 索引库操作

2.1 创建索引库

Elasticsearch采用Restful风格API，因此其API就是一次http请求，你可以用任何工具发起http请求，

语法：

1
2
3
4
5
6
PUT /blog1
{
  "settings": {
    "属性名": "属性值"
  }
}

settings：就是索引库设置，其中可以定义索引库的各种属性，目前我们可以不设置，都走默认

可以看到索引创建成功了。

2.2 查看索引库

Get请求可以帮我们查看索引信息，语法：

1
GET /blog1

2.3 删除索引库

删除索引使用DELETE请求，语法：

1
DELETE /blog1

再次查询，返回索引不存在

3 类型及映射操作

有了索引库，等于有了数据库中的database。接下来就需要索引库中的类型了，也就是数据库中的表。创建数据库表需要设置字段约束，索引库也一样，在创建索引库的类型时，需要知道这个类型下有哪些字段，每个字段有哪些约束信息，这就叫做字段映射(mapping)。

字段的约束包括但不限于：

  • 字段的数据类型
  • 是否要存储
  • 是否要索引
  • 是否分词
  • 分词器是什么

我们一起来看下创建的语法。

3.1 创建映射字段(需先创建索引库)

请求方式依然是PUT

1
2
3
4
5
6
7
8
9
10
11
PUT /索引库名/_mapping/类型名称 或 索引库名/类型名称/_mapping
{
  "properties": {
    "字段名": {
      "type": "类型",
      "index": true，
      "store": true，
      "analyzer": "分词器"
    }
  }
}

类型名称：就是前面将的type的概念，类似于数据库中的表

字段名：任意填写，下面指定许多属性，例如：

  • type：类型，可以是text、long、short、date、integer、object等
  • index：是否索引，默认为true
  • store：是否存储，默认为false
  • analyzer：分词器，这里的ik_max_word即使用ik分词器

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
PUT /heima/_mapping/goods
{
  "properties": {
    "title": {
      "type": "text",
      "analyzer": "ik_max_word"
    },
    "subtitle": {
      "type": "text",
      "analyzer": "ik_max_word"
    },
    "images": {
      "type": "keyword",
      "index": "false"
    },
    "price": {
      "type": "float"
    }
  }
}

响应结果：

上述案例中，就给heima这个索引库添加了一个名为goods的类型，并且在类型中设置了4个字段：

  • title：商品标题
  • subtitle: 商品子标题
  • images：商品图片
  • price：商品价格

并且给这些字段设置了一些属性，至于这些属性对应的含义，我们在后续会详细介绍。

3.2 映射属性详解

type

Elasticsearch中支持的数据类型非常丰富：

  • String类型，又分两种：

    • text：可分词，不可参与聚合
    • keyword：不可分词，数据会作为完整字段进行匹配，可以参与聚合

  • Numerical：数值类型，分两类

    • 基本数据类型：long、interger、short、byte、double、float、half_float
    • 浮点数的高精度类型：scaled_float
      • 需要指定一个精度因子，比如10或100。elasticsearch会把真实值乘以这个因子后存储，取出时再还原。

  • Date：日期类型

    elasticsearch可以对日期格式化为字符串存储，但是建议我们存储为毫秒值，存储为long，节省空间。

  • Array：数组类型

    • 进行匹配时，任意一个元素满足，都认为满足
    • 排序时，如果升序则用数组中的最小值来排序，如果降序则用数组中的最大值来排序

  • Object：对象

    1
    2
    3
    4
    5
    6
    7
    {
        name:"Jack",
        age:21,
        girl:{
            name: "Rose", age:21
       }
    }

    如果存储到索引库的是对象类型，例如上面的girl，会把girl编程两个字段：girl.name和girl.age

index

index影响字段的索引情况。

  • true：字段会被索引，则可以用来进行搜索。默认值就是true
  • false：字段不会被索引，不能用来搜索

index的默认值就是true，也就是说你不进行任何配置，所有字段都会被索引。
但是有些字段是我们不希望被索引的，比如商品的图片信息，就需要手动设置index为false。

store

是否将数据进行独立存储。
原始的文本会存储在_source里面，默认情况下其他提取出来的字段都不是独立存储的，是从_source里面提取出来的。当然你也可以独立的存储某个字段，只要设置store:true即可，获取独立存储的字段要比从_source中解析快得多，但是也会占用更多的空间，所以要根据实际业务需求来设置，默认为false。

3.3 查看映射关系

语法：

1
GET /索引库名/_mapping/类型名

示例：

1
GET /heima/_mapping/goods

响应：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
{
  "heima": {
    "mappings": {
      "goods": {
        "properties": {
          "images": {
            "type": "keyword",
            "index": false
          },
          "price": {
            "type": "float"
          },
          "subtitle": {
            "type": "text",
            "analyzer": "ik_max_word"
          },
          "title": {
            "type": "text",
            "analyzer": "ik_max_word"
          }
        }
      }
    }
  }
}

3.4 一次创建索引库和类型（常用）

刚才的案例中我们是把创建索引库和类型分开来做，其实也可以在创建索引库的同时，直接制定索引库中的类型，基本语法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
put /索引库名
{
    "settings":{
        "索引库属性名":"索引库属性值"
    },
    "mappings":{
        "类型名":{
            "properties":{
                "字段名":{
                    "映射属性名":"映射属性值"
                }
            }
        }
    }
}

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
PUT /heima2
{
  "settings": {},
  "mappings": {
    "goods": {
      "properties": {
        "title": {
          "type": "text",
          "analyzer": "ik_max_word"
        }
      }
    }
  }
}

结果：

1
2
3
4
5
{
  "acknowledged": true,
  "shards_acknowledged": true,
  "index": "heima2"
}

4 文档操作

文档，即索引库中某个类型下的数据，会根据规则创建索引，将来用来搜索。可以类比作数据库中的每一行数据。

4.1 新增文档随机生成id

通过POST请求，可以向一个已经存在的索引库中添加文档数据。

语法：

1
2
3
4
POST /索引库名/类型名
{
    "key":"value"
}

示例：

1
2
3
4
5
6
POST /heima/goods/
{
    "title":"小米手机",
    "images":"http://image.leyou.com/12479122.jpg",
    "price":2699.00
}

响应：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
  "_index": "heima",
  "_type": "goods",
  "_id": "2a3UTW0BTp_XthqB6lMH",
  "_version": 1,
  "result": "created",
  "_shards": {
    "total": 2,
    "successful": 1,
    "failed": 0
  },
  "_seq_no": 0,
  "_primary_term": 1
}

可以看到结果显示为：created，应该是创建成功了。
另外，需要注意的是，在响应结果中有个_id字段，这个就是这条文档数据的唯一标示，以后的增删改查都依赖这个id作为唯一标示。
可以看到id的值为：2a3UTW0BTp_XthqB6lMH,这里我们新增时没有指定id，所以是ES帮我们随机生成的id。

4.2 查看文档

根据rest风格，新增是post，查询应该是get，不过查询一般都需要条件，这里我们把刚刚生成数据的id带上。

1
GET /heima/goods/2a3UTW0BTp_XthqB6lMH

查看结果：

1
2
3
4
5
6
7
8
9
10
11
12
{
  "_index": "heima",
  "_type": "goods",
  "_id": "2a3UTW0BTp_XthqB6lMH",
  "_version": 1,
  "found": true,
  "_source": {
    "title": "小米手机",
    "images": "http://image.leyou.com/12479122.jpg",
    "price": 2699
  }
}
  • _source：源文档信息，所有的数据都在里面。
  • _id：这条文档的唯一标示

4.3 新增文档并自定义id

如果我们想要自己新增的时候指定id，可以这么做：

1
2
3
4
POST /索引库名/类型/id值
{
    ...
}

示例：

1
2
3
4
5
6
POST /heima/goods/2
{
    "title":"大米手机",
    "images":"http://image.leyou.com/12479122.jpg",
    "price":2899.00
}

得到的数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
  "_index": "heima",
  "_type": "goods",
  "_id": "2",
  "_version": 1,
  "result": "created",
  "_shards": {
    "total": 2,
    "successful": 1,
    "failed": 0
  },
  "_seq_no": 0,
  "_primary_term": 1
}

4.4 修改数据

把刚才新增的请求方式改为PUT，就是修改了。不过修改必须指定id。

  • id对应文档存在，则修改
  • id对应文档不存在，则新增

比如，我们把使用id为3，不存在，则应该是新增：

1
2
3
4
5
6
PUT /heima/goods/3
{
    "title":"超米手机",
    "images":"http://image.leyou.com/12479122.jpg",
    "price":3899.00
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
  "_index": "heima",
  "_type": "goods",
  "_id": "3",
  "_version": 1,
  "result": "created",
  "_shards": {
    "total": 2,
    "successful": 1,
    "failed": 0
  },
  "_seq_no": 0,
  "_primary_term": 1
}

可以看到是created，是新增。
我们再次执行刚才的请求，不过把数据改一下：

1
2
3
4
5
6
PUT /heima/goods/3
{
    "title":"超大米手机",
    "images":"http://image.leyou.com/12479122.jpg",
    "price":3299.00
}

查看结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
  "_index": "heima",
  "_type": "goods",
  "_id": "3",
  "_version": 2,
  "result": "updated",
  "_shards": {
    "total": 2,
    "successful": 1,
    "failed": 0
  },
  "_seq_no": 1,
  "_primary_term": 1
}

可以看到结果是：updated，显然是更新数据。

4.5 删除数据

根据id进行删除

语法

1
DELETE /索引库名/类型名/id值

实例：

1
DELETE heima/goods/3

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
  "_index": "heima",
  "_type": "goods",
  "_id": "3",
  "_version": 3,
  "result": "deleted",
  "_shards": {
    "total": 2,
    "successful": 1,
    "failed": 0
  },
  "_seq_no": 2,
  "_primary_term": 1
}

可以看到结果是：deleted，显然是删除数据

根据查询条件进行删除

语法

1
2
3
4
5
6
7
8
POST  /索引库名/_delete_by_query
{
  "query": { 
    "match": {
      "字段名": "搜索关键字"
    }
  }
}

示例：

1
2
3
4
5
6
7
8
POST heima/_delete_by_query
{
    "query": {
        "match": {
            "title": "小米"
        }
    }
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{
  "took": 269,
  "timed_out": false,
  "total": 1,
  "deleted": 1,
  "batches": 1,
  "version_conflicts": 0,
  "noops": 0,
  "retries": {
    "bulk": 0,
    "search": 0
  },
  "throttled_millis": 0,
  "requests_per_second": -1,
  "throttled_until_millis": 0,
  "failures": []
}

4.6 删除所有数据

1
2
3
4
5
6
POST  索引库名/_delete_by_query
{
  "query": { 
    "match_all": {}
  }
}

示例：

1
2
3
4
5
6
POST heima/_delete_by_query
{
  "query": {
    "match_all": {}
  }
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{
  "took": 11,
  "timed_out": false,
  "total": 1,
  "deleted": 1,
  "batches": 1,
  "version_conflicts": 0,
  "noops": 0,
  "retries": {
    "bulk": 0,
    "search": 0
  },
  "throttled_millis": 0,
  "requests_per_second": -1,
  "throttled_until_millis": 0,
  "failures": []
}

5 查询

我们将从以下6点来讲解查询：

  • 基本查询
  • 结果过滤（_source过滤）
  • 高级查询
  • 排序
  • 高亮
  • 分页

首先导入测试数据，这里是采用批处理的API（_bulk），直接复制到kibana运行即可，不要使用kibana的格式化，否则会执行报错

1
2
3
4
5
6
7
POST /heima/goods/_bulk
{"index":{}}
{"title":"大米手机","images":"http://image.leyou.com/12479122.jpg","price":3288}
{"index":{}}
{"title":"小米手机","images":"http://image.leyou.com/12479122.jpg","price":2699}
{"index":{}}
{"title":"小米电视4A","images":"http://image.leyou.com/12479122.jpg","price":4288}

5.1 基本查询

语法

1
2
3
4
5
6
7
8
POST /索引库名/_search
{
    "query":{
        "查询类型":{
            "查询条件":"查询条件值"
        }
    }
}

这里的query代表一个查询对象，里面可以有不同的查询属性

  • 查询类型：例如match_all， match，term ， range 等等
  • 查询条件：查询条件会根据类型的不同，写法也有差异，后面详细讲解

查询所有（match_all)

示例：

1
2
3
4
5
6
POST /heima/_search
{
    "query":{
        "match_all": {}
    }
}
  • query：代表查询对象
  • match_all：代表查询所有

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
{
  "took": 7,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 3,
    "max_score": 1,
    "hits": [
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "3a3hTW0BTp_XthqB2lMR",
        "_score": 1,
        "_source": {
          "title": "大米手机",
          "images": "http://image.leyou.com/12479122.jpg",
          "price": 3288
        }
      },
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "3q3hTW0BTp_XthqB2lMR",
        "_score": 1,
        "_source": {
          "title": "小米手机",
          "images": "http://image.leyou.com/12479122.jpg",
          "price": 2699
        }
      },
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "363hTW0BTp_XthqB2lMR",
        "_score": 1,
        "_source": {
          "title": "小米电视4A",
          "images": "http://image.leyou.com/12479122.jpg",
          "price": 4288
        }
      }
    ]
  }
}
  • took：查询花费时间，单位是毫秒
  • time_out：是否超时
  • _shards：分片信息
  • hits：搜索结果总览对象
    • total：搜索到的总条数
    • max_score：所有结果中文档得分的最高分
    • hits：搜索结果的文档对象数组，每个元素是一条搜索到的文档信息
      • _index：索引库
      • _type：文档类型
      • _id：文档id
      • _score：文档得分
      • _source：文档的源数据

匹配查询（match）

现在，索引库中有2部手机，1台电视;

or关系

match类型查询，会把查询条件进行分词，然后进行查询,多个词条之间是or的关系

1
2
3
4
5
6
7
8
POST /heima/_search
{
    "query":{
        "match":{
            "title":"小米电视4A"
        }
    }
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
{
  "took": 20,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 2,
    "max_score": 2.5141225,
    "hits": [
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "363hTW0BTp_XthqB2lMR",
        "_score": 2.5141225,
        "_source": {
          "title": "小米电视4A",
          "images": "http://image.leyou.com/12479122.jpg",
          "price": 4288
        }
      },
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "3q3hTW0BTp_XthqB2lMR",
        "_score": 0.22108285,
        "_source": {
          "title": "小米手机",
          "images": "http://image.leyou.com/12479122.jpg",
          "price": 2699
        }
      }
    ]
  }
}

在上面的案例中，不仅会查询到电视，而且与小米相关的都会查询到，多个词之间是or的关系。

and关系

某些情况下，我们需要更精确查找，我们希望这个关系变成and，可以这样做：

1
2
3
4
POST /heima/_search
{"query": {"match": {
  "title": {"query": "小米电视4A","operator": "and"}
}}}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
{
  "took": 7,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 1,
    "max_score": 2.5141225,
    "hits": [
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "363hTW0BTp_XthqB2lMR",
        "_score": 2.5141225,
        "_source": {
          "title": "小米电视4A",
          "images": "http://image.leyou.com/12479122.jpg",
          "price": 4288
        }
      }
    ]
  }
}

本例中，只有同时包含小米和电视的词条才会被搜索到。

多字段查询（multi_match）

multi_match与match类似，不同的是它可以在多个字段中查询

为了测试效果我们在这里新增一条数据：

1
2
3
4
5
6
7
POST /heima/goods
{
    "title": "华为手机",
    "images": "http://image.leyou.com/12479122.jpg",
    "price": 5288,
    "subtitle": "小米"
}

示例：

1
2
3
4
5
6
7
8
9
POST /heima/_search
{
  "query": {
    "multi_match": {
      "query": "小米",
      "fields": ["title","subtitle"]
    }
  }
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
{
  "took": 6,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 3,
    "max_score": 0.5442147,
    "hits": [
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "3q3hTW0BTp_XthqB2lMR",
        "_score": 0.5442147,
        "_source": {
          "title": "小米手机",
          "images": "http://image.leyou.com/12479122.jpg",
          "price": 2699
        }
      },
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "363hTW0BTp_XthqB2lMR",
        "_score": 0.36928856,
        "_source": {
          "title": "小米电视4A",
          "images": "http://image.leyou.com/12479122.jpg",
          "price": 4288
        }
      },
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "5a3yTW0BTp_XthqBcFOL",
        "_score": 0.2876821,
        "_source": {
          "title": "华为手机",
          "images": "http://image.leyou.com/12479122.jpg",
          "price": 5288,
          "subtitle": "小米"
        }
      }
    ]
  }
}

本例中，我们会假设在title字段和subtitle字段中查询小米这个词。

词条匹配(term)

term 查询被用于精确值 匹配，这些精确值可能是数字、时间、布尔或者那些未分词的字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
POST /heima/_search
{
    "query":{
        "term":{
            "price":2699
        }
    }
}

-------或者----------
POST /heima/_search
{
  "query": {
    "term": {
      "price": {
        "value": "2699"
      }
    }
  }
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
{
  "took": 13,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 1,
    "max_score": 1,
    "hits": [
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "3q3hTW0BTp_XthqB2lMR",
        "_score": 1,
        "_source": {
          "title": "小米手机",
          "images": "http://image.leyou.com/12479122.jpg",
          "price": 2699
        }
      }
    ]
  }
}

多词条精确匹配(terms)

terms 查询和 term 查询一样，但它允许你指定多值进行匹配。如果这个字段包含了指定值中的任何一个值，那么这个文档满足条件，类似于mysql的in：

1
2
3
4
5
6
7
8
POST /heima/_search
{
    "query":{
        "terms":{
            "price":[2699,5288]
        }
    }
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
{
  "took": 9,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 2,
    "max_score": 1,
    "hits": [
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "3q3hTW0BTp_XthqB2lMR",
        "_score": 1,
        "_source": {
          "title": "小米手机",
          "images": "http://image.leyou.com/12479122.jpg",
          "price": 2699
        }
      },
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "5a3yTW0BTp_XthqBcFOL",
        "_score": 1,
        "_source": {
          "title": "华为手机",
          "images": "http://image.leyou.com/12479122.jpg",
          "price": 5288,
          "subtitle": "小米"
        }
      }
    ]
  }
}

5.2 结果过滤

默认情况下，elasticsearch在搜索的结果中，会把文档中保存在_source的所有字段都返回。
如果我们只想获取其中的部分字段，我们可以添加_source的过滤。

直接指定字段

示例：

1
2
3
4
5
6
7
8
9
POST /heima/_search
{
  "_source": ["title","price"],
  "query": {
    "term": {
      "price": 2699
    }
  }
}

返回的结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
{
  "took": 4,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 1,
    "max_score": 1,
    "hits": [
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "3q3hTW0BTp_XthqB2lMR",
        "_score": 1,
        "_source": {
          "price": 2699,
          "title": "小米手机"
        }
      }
    ]
  }
}

指定includes和excludes

我们也可以通过：

  • includes：来指定想要显示的字段
  • excludes：来指定不想要显示的字段

二者都是可选的。

示例：

1
2
3
4
5
6
7
8
9
10
11
POST /heima/_search
{
  "_source": {
    "includes":["title","price"]
  },
  "query": {
    "term": {
      "price": 2699
    }
  }
}

与下面的结果将是一样的：

1
2
3
4
5
6
7
8
9
10
11
POST /heima/_search
{
  "_source": {
     "excludes": ["images"]
  },
  "query": {
    "term": {
      "price": 2699
    }
  }
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
{
  "took": 2,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 1,
    "max_score": 1,
    "hits": [
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "3q3hTW0BTp_XthqB2lMR",
        "_score": 1,
        "_source": {
          "price": 2699,
          "title": "小米手机"
        }
      }
    ]
  }
}

5.3 高级查询

布尔组合（bool）

bool把各种其它查询通过must（与）、must_not（非）、should（或）的方式进行组合

1
2
3
4
5
6
7
8
9
10
GET /heima/_search
{
    "query":{
        "bool":{
            "must":     { "match": { "title": "小米" }},
            "must_not": { "match": { "title":  "电视" }},
            "should":   { "match": { "title": "手机" }}
        }
    }
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
{
  "took": 134,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 1,
    "max_score": 1.0884295,
    "hits": [
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "3q3hTW0BTp_XthqB2lMR",
        "_score": 1.0884295,
        "_source": {
          "title": "小米手机",
          "images": "http://image.leyou.com/12479122.jpg",
          "price": 2699
        }
      }
    ]
  }
}

范围查询（range）

range查询找出那些落在指定区间内的数字或者时间，range查询允许以下字符：

操作符 说明
gt 大于
gte 大于等于
lt 小于
lte 小于等于

示例：

1
2
3
4
5
6
7
8
9
10
11
POST /heima/_search
{
    "query":{
        "range": {
            "price": {
                "gte":  3000,
                "lt":   5000
            }
        }
    }
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
{
  "took": 7,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 2,
    "max_score": 1,
    "hits": [
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "3a3hTW0BTp_XthqB2lMR",
        "_score": 1,
        "_source": {
          "title": "大米手机",
          "images": "http://image.leyou.com/12479122.jpg",
          "price": 3288
        }
      },
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "363hTW0BTp_XthqB2lMR",
        "_score": 1,
        "_source": {
          "title": "小米电视4A",
          "images": "http://image.leyou.com/12479122.jpg",
          "price": 4288
        }
      }
    ]
  }
}

模糊查询（fuzzy）

我们新增一个商品：

1
2
3
4
5
6
POST /heima/goods/4
{
    "title":"apple手机",
    "images":"http://image.leyou.com/12479122.jpg",
    "price":5899.00
}

fuzzy自动将拼写错误的搜索文本，进行纠正，纠正以后去尝试匹配索引中的数据。它允许用户搜索词条与实际词条出现偏差，但是偏差的编辑距离不得超过2：

1
2
3
4
5
6
7
8
POST /heima/_search
{
  "query": {
    "fuzzy": {
      "title": "appla"
    }
  }
}

上面的查询，也能查询到apple手机。
还可以通过设置fuzziness指定搜索文本最多可以纠正几个字母去和数据进行匹配，如果不设置，默认就是2。

1
2
3
4
5
6
7
8
9
10
11
POST /heima/_search
{
  "query": {
    "fuzzy": {
      "title": {
        "value": "applaa",
        "fuzziness": 2
      }
    }
  }
}

5.4 排序

单字段排序

sort 可以让我们按照不同的字段进行排序，并且通过order指定排序的方式：

1
2
3
4
5
6
7
8
9
POST /heima/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {"price": {"order": "desc"}}
  ]
}

多字段排序

假定我们想要结合使用 price和 _score（得分） 进行查询，并且匹配的结果首先按照价格排序，然后按照相关性得分排序：

1
2
3
4
5
6
7
8
9
10
POST /heima/_search
{
    "query":{
        "match_all":{}
    },
    "sort": [
      { "price": { "order": "desc" }},
      { "_score": { "order": "desc" }}
    ]
}

5.5 高亮

elasticsearch中实现高亮的语法比较简单：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
POST /heima/_search
{
  "query": {
    "match": {
      "title": "电视"
    }
  },
  "highlight": {
    "pre_tags": "<font color='pink'>",
    "post_tags": "</font>",
    "fields": {
      "title": {}
    }
  }
}

在使用match查询的同时，加上一个highlight属性：

  • pre_tags：前置标签
  • post_tags：后置标签
  • fields：需要高亮的字段
    • title：这里声明title字段需要高亮，后面可以为这个字段设置特有配置，也可以空

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
{
  "took": 12,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 1,
    "max_score": 0.90204775,
    "hits": [
      {
        "_index": "heima",
        "_type": "goods",
        "_id": "363hTW0BTp_XthqB2lMR",
        "_score": 0.90204775,
        "_source": {
          "title": "小米电视4A",
          "images": "http://image.leyou.com/12479122.jpg",
          "price": 4288
        },
        "highlight": {
          "title": [
            "小米<font color='pink'>电视</font>4A"
          ]
        }
      }
    ]
  }
}

5.6 分页

elasticsearch中实现分页的语法非常简单： 

1
2
3
4
5
6
7
8
POST /heima/_search
{
  "query": {
    "match_all": {}
  },
  "size": 2,
  "from": 0
}
  • size：每页显示多少条
  • from：当前页起始索引, int start = (pageNum - 1) * size;