释放双眼，带上耳机，听听看~！
Elasticsearch 是一个搜索服务器，特点：分布式、易于扩展、全文检索、索引速度快。
本篇文章主要介绍 Elasticsearch 的安装和基本使用，假定你有一定的Linux基础（所有命令均在命令行中执行）。
Elasticsearch 版本：2.2.0
服务器：CentOS 6.4 （Win7 下的虚拟机）
一、安装
因为 Elasticsearch 是 Java 开发的，所以要先安装 Java
可用 java -version来查 看是否已安装Java
若没有安装，且jdk 在 /usr/local/src/jdk-7u79-linux-x64.gz 目录下
2
3
2cp -r /usr/local/src/jdk1.7.0_79/ /usr/local/java
3
添加 java 环境变量，保存并退出
2
3
4
5
6
2#在最后面添加
3export JAVA_HOME=/usr/local/java
4export PATH=$JAVA_HOME/bin:$PATH
5export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
6
执行 source /etc/profile 使更改生效，再使用 java -version 看一下java 版本
安装 Elasticsearch ，假定安装包在 /usr/local/src/elasticsearch-2.2.0.tar.gz 目录下
2
2
2
2
这样在 /usr/local 下就有一个 elasticsearch-2.2.0 的目录
Elasticsearch 的配置文件在 /usr/local/elasticsearch-2.2.0/config/elasticsearch.yml
打开配置文件，加入如下配置（可以不用配置）
2
3
4
5
6
7
2cluster.name: cluster-test
3#节点名称，本服务器的名称
4node.name: node-136
5#监听端口，默认为 9200
6http.port: 9200
7
- # vi /usr/local/elasticsearch/config/elasticsearch.yml
- # 注意冒号后有空格
- http.port: 9200
- node.name: node-1
- cluster.name: es_cluster
- network.host: 192.168.1.222
- bootstrap.memory_lock: false
- path.data: /usr/local/elasticsearch/data
- path.logs: /usr/local/elasticsearch/logs
打开端口，Elasticsearch 默认监听9200 端口，可在 elasticsearch.yml 中修改
2
3
4
5
6
7
8
2vim /etc/sysconfig/iptables
3#加入
4-A INPUT -p tcp -m state --state NEW -m tcp --dport 9200 -j ACCEPT
5-A INPUT -p udp -m state --state NEW -m udp --dport 9200 -j ACCEPT
6#重启生效
7service iptables restart
8
启动 Elasticsearch。为安全考虑，Elasticsearch不允许 root 启动，所以你要先创建一个用于启动 Elasticsearch 的用户，并将 elasticsearch-2.2.0 文件的所有者赋予该用户
假如你已经创建了一个 elastic 的用户（我创建的用户名是 jam）
2
2
启动（-d 表示后台运行）
2
2
查看是否启动
2
3
4
2#有如下信息表示成功
3jam 44292 3.4 17.4 2088296 176320 pts/1 Sl 17:37 0:05 /usr/bin/java -Xms256m -Xmx1g -Djava.awt.headless=true -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFraction=75 -XX:+UseCMSInitiatingOccupancyOnly -XX:+HeapDumpOnOutOfMemoryError -XX:+DisableExplicitGC -Dfile.encoding=UTF-8 -Djna.nosys=true -Des.path.home=/usr/local/elasticsearch-2.2.0 -cp /usr/local/elasticsearch-2.2.0/lib/elasticsearch-2.2.0.jar:/usr/local/elasticsearch-2.2.0/lib/* org.elasticsearch.bootstrap.Elasticsearch start -d
4
停止 Elasticsearch
2
3
2kill -9 44292
3
二、使用
1、基本概念
传统关系型数据库（如 MySQL）与 Elasticsearch 对比
Databases
Indices
索引(名词)即数据库
Tables
Types
类型即表名
Rows
Documents
文档即每行数据
Columns
Fields
字段
2、与 Elasticsearch 通信
Elasticsearch 支持 RESTful API的访问方式，这里我们使用 curl 访问和操作Elasticsearch
官方也有很多对应语言的 API 供大家选择
PHP-API
JAVA-API
Python-API
初探：查看 Elasticsearch 的基本信息
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2curl 'http://localhost:9200/?pretty'
3#返回
4{
5 "name" : "node-136",
6 "cluster_name" : "cluster-test",
7 "version" : {
8 "number" : "2.2.0",
9 "build_hash" : "8ff36d139e16f8720f2947ef62c8167a888992fe",
10 "build_timestamp" : "2016-01-27T13:32:39Z",
11 "build_snapshot" : false,
12 "lucene_version" : "5.4.1"
13 },
14 "tagline" : "You Know, for Search"
15}
16
简单介绍一下 curl 命令
2
3
4
5
6
7
8
9
2VERB HTTP方法：GET, POST, PUT, HEAD, DELETE
3PROTOCOL http或者https协议（只有在Elasticsearch前面有https代理的时候可用）
4HOST Elasticsearch集群中的任何一个节点的主机名
5PORT Elasticsearch HTTP服务所在的端口，默认为9200
6PATH API路径，资源路径（例如_count将返回集群中文档的数量）
7QUERY_STRING 一些可选的查询请求参数，例如?pretty参数将返回易读的JSON数据
8BODY 一个JSON格式的请求主体（如果请求需要的话）
9
3、elasticsearch-head 插件
这里介绍一个 Elasticsearch 可视化的管理插件 elasticsearch-head，可方便的查看，删除，管理数据（生产环境不推荐安装）
root 安装
2
3
2./plugin install mobz/elasticsearch-head
3
访问（linux 有桌面系统带浏览器的可直接访问）：http://127.0.0.1:9200/_plugin/head/
那外网如何访问呢，使用 Nginx 代理，修改Nginx 配置文件加入
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2 {
3 listen 8080;
4 #192.168.1.136 是我虚拟机的 ip 地址
5 server_name 192.168.1.136;
6 location / {
7 #http://127.0.0.1:9200/ 是后端代理的地址
8 proxy_pass http://127.0.0.1:9200/;
9 proxy_redirect off;
10 proxy_set_header Host $host;
11 proxy_set_header X-Real-IP $remote_addr;
12 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
13 }
14 }
15
重启nginx，在windows下访问 http://192.168.1.136:8080/_plugin/head/，界面如下
可以查看集群信息，节点信息，索引信息…都是以json 形式显示这些信息
4、创建、查看索引
现在我们来添加一个名叫 test 的索引（可理解为数据库）
2
3
4
5
6
2#返回
3{
4 "acknowledged" : true
5}
6
创建成功后，默认会分配五个主分片（创建后不可更改，通过算法将数据存放在这五个分片中的一个，增删改都是针对主分片的）和一个复制分片（可修改，每个主分片都对应一个复制分片），这两个默认值都可以在配置文件中修改，也可以在创建的时候指定，如
2
3
4
5
6
7
2 "settings": {
3 "number_of_shards" : 2, #2个主分片
4 "number_of_replicas" : 0 #0个复制分片
5 }
6}'
7
查看索引
2
2
5、创建、查看 类型
创建一个名叫 article 的类型（即表名），有这几个字段，id、subject、content、author
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2 "properties": {
3 "id": {
4 "type": "integer",
5 "index": "not_analyzed"
6 },
7 "subject": {
8 "type": "string",
9 "analyzer": "standard"
10 },
11 "content": {
12 "type": "string",
13 "analyzer": "standard"
14 },
15 "author": {
16 "type": "string",
17 "index": "not_analyzed"
18 }
19 }
20}'
21
type：是指定字段的数据类型
index：有三个选项 analyzed（当成全文来搜索），not_analyzed（当成一个准确的值），no（完全不可被搜索）
analyzer：索引和搜索时全文字段（即此字段）使用的分析器，standard 为 Elasticsearch 默认的全文字段分析器（对中文不友好，可使用 ik 代替）
Elasticsearch 字段类型和对应的分类类型
String
string
Whole number
byte , short , integer , long
Floating point
float , double
Boolean
boolean
Date
date
查看刚才新增的类型
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
2#返回
3{
4 "test" : {
5 "mappings" : {
6 "article" : {
7 "properties" : {
8 "author" : {
9 "type" : "string",
10 "index" : "not_analyzed"
11 },
12 "content" : {
13 "type" : "string",
14 "analyzer" : "standard"
15 },
16 "id" : {
17 "type" : "integer"
18 },
19 "subject" : {
20 "type" : "string",
21 "analyzer" : "standard"
22 }
23 }
24 }
25 }
26 }
27}
28
6、创建、查看、修改、删除 文档
创建一条数据
指定 _id 的创建
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
2 "id": 1,
3 "subject": "第一篇文章标题",
4 "content": "第一篇文章内容",
5 "author": "jam"
6}'
7#返回
8{
9 #文档所在的索引
10 "_index" : "test",
11 #文档的类型名
12 "_type" : "article",
13 #文档的字符串 ID,在请求链接中指定的1，若不指定，会自动生成
14 "_id" : "1",
15 #文档版本号，修改或删除都会增加
16 "_version" : 1,
17 "_shards" : {
18 "total" : 2,
19 "successful" : 1,
20 "failed" : 0
21 },
22 #表示创建成功
23 "created" : true
24}
25
自增 _id 的创建
2
3
4
5
6
7
8
9
10
11
2 "id": 2,
3 "subject": "第二篇文章标题",
4 "content": "第二篇文章内容",
5 "author": "jam"
6}'
7#返回
8...
9"_id" : "AVf_6fM1vEkwGPLuUJqp",
10...
11
查看指定文档
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2#返回
3{
4 "_index" : "test",
5 "_type" : "article",
6 "_id" : "1",
7 "_version" : 1,
8 "found" : true,
9 "_source" : {
10 "id" : 1,
11 "subject" : "第一篇文章标题",
12 "content" : "第一篇文章内容",
13 "author" : "jam"
14 }
15}
16
查看所有文档（_search）
2
2
更新文档（_update），局部更新（更新指定字段）
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
2{
3 "doc" : {
4 "content" : "第一篇文章内容-更新后"
5 }
6}'
7#返回
8{
9 "_index" : "test",
10 "_type" : "article",
11 "_id" : "1",
12 "_version" : 2,
13 "_shards" : {
14 "total" : 2,
15 "successful" : 1,
16 "failed" : 0
17 }
18}
19
_version 版本号变为 2
删除文档
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2#返回
3{
4 "found" : true,
5 "_index" : "test",
6 "_type" : "article",
7 "_id" : "1",
8 "_version" : 3,
9 "_shards" : {
10 "total" : 2,
11 "successful" : 1,
12 "failed" : 0
13 }
14}
15
_version 版本号变为 3，说明删除是不会真正删除文档的
7、批量操作——bulk API 介绍
先看一个批量创建文档的例子
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
2{ "index" : { "_id" : "3" } }
3{ "id" : 3,"subject" : "第三篇文章标题","content" : "第三篇文章内容" ,"author": "jam"}
4{ "index" : { "_id" : "4" } }
5{ "id" : 4,"subject" : "第四篇文章标题","content" : "第四篇文章内容" ,"author": "tomi"}
6'
7#返回
8{
9 "took" : 36,
10 "errors" : false,
11 "items" : [ {
12 "index" : {
13 "_index" : "test",
14 "_type" : "article",
15 "_id" : "3",
16 "_version" : 1,
17 "_shards" : {
18 "total" : 2,
19 "successful" : 1,
20 "failed" : 0
21 },
22 "status" : 201
23 }
24 }, {
25 "index" : {
26 "_index" : "test",
27 "_type" : "article",
28 "_id" : "4",
29 "_version" : 1,
30 "_shards" : {
31 "total" : 2,
32 "successful" : 1,
33 "failed" : 0
34 },
35 "status" : 201
36 }
37 } ]
38}
39
bulk API允许我们使用单一请求来实现多个文档的 create（文档不存在时才创建） 、 index（创建新文档或替换已有文档） 、 update 或 delete
它的请求体格式如下（也就是 -d 后面的数据）
2
3
4
5
2{ request body }\n
3{ action: { metadata }}\n
4{ request body }\n
5
action 有四个选项，即 create 、 index 、 update 、 delete
metadata 为元数据，即是 _index 、_type、_id，上面的例子中，因为我在请求链接中指定了 _index （test）和_type（article），所以我只需指定 _id
request body 这里就是每条数据的具体内容，字段名和数据一一对应就可以了
需要注意的是每行必须以 “\n” 符号结尾， 包括最后一行。直接敲回车键就可以了
可以在一条 bulk 的请求体中既执行 index（创建文档），又执行 update（更新文档），还可以执行 delete（删除文档），请求体类似如下
2
3
4
5
6
7
8
2{ "create": { "_index": "test", "_type": "article", "_id": "123" }}
3{ "id" : 123,"subject" : "第123篇文章标题","content" : "第123篇文章内容" ,"author": "jam123"}
4{ "index": { "_index": "test", "_type": "article", "_id": "3" }}
5{ "id" : 3,"subject" : "第三篇文章标题-替换后","content" : "第三篇文章内容-替换后" ,"author": "jam0"}
6{ "update": { "_index": "test", "_type": "article", "_id": "4"} }
7{ "doc" : {"content" : "第四篇文章内容-更新后"} }
8
delete 操作没有请求体，所以后面紧跟另一个操作
三、Elasticsearch 的 DSL（特定领域语言） 查询
以 json 请求体的形式查询数据
1、基本查询
查询所有文档
等同于 curl -XGET ‘http://localhost:9200/test/article/_search?pretty’
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
51
52
53
54
55
56
57
58
2{
3 "query": {
4 "match_all": {}
5 }
6}'
7#返回
8{
9 # 用时 毫秒
10 "took" : 4,
11 "timed_out" : false,
12 #分片信息
13 "_shards" : {
14 "total" : 5,
15 "successful" : 5,
16 "failed" : 0
17 },
18 "hits" : {
19 #文档数
20 "total" : 3,
21 "max_score" : 1.0,
22 "hits" : [ {
23 "_index" : "test",
24 "_type" : "article",
25 "_id" : "AVf_6fM1vEkwGPLuUJqp",
26 "_score" : 1.0,
27 "_source" : {
28 "id" : 2,
29 "subject" : "第二篇文章标题",
30 "content" : "第二篇文章内容",
31 "author" : "jam"
32 }
33 }, {
34 "_index" : "test",
35 "_type" : "article",
36 "_id" : "4",
37 "_score" : 1.0,
38 "_source" : {
39 "id" : 4,
40 "subject" : "第四篇文章标题",
41 "content" : "第四篇文章内容-更新后",
42 "author" : "tomi"
43 }
44 }, {
45 "_index" : "test",
46 "_type" : "article",
47 "_id" : "3",
48 "_score" : 1.0,
49 "_source" : {
50 "id" : 3,
51 "subject" : "第三篇文章标题",
52 "content" : "第三篇文章内容",
53 "author" : "jam"
54 }
55 } ]
56 }
57}
58
查询作者是名字包含 “jam” 的文档，返回 id 是 2和3 的文档
2
3
4
5
6
7
8
9
2{
3 "query": {
4 "match": {
5 "author": "jam"
6 }
7 }
8}'
9
查询文章内容包含 “更新” 的文档，返回 id 是 4 的文档
2
3
4
5
6
7
8
9
2{
3 "query": {
4 "match": {
5 "content": "更新"
6 }
7 }
8}'
9
2、过滤语句
1> term 过滤，主要用于精确匹配哪些值，比如数字，日期，布尔值或 not_analyzed 的字符串(未经分析的文本数据类型)
查询作者是 jam 的文档，返回 id 是 2 和 3 的文档
2
3
4
5
6
7
8
9
2{
3 "query": {
4 "term": {
5 "author": "jam"
6 }
7 }
8}'
9
2> terms 过滤，跟 term 有点类似，但 terms 允许指定多个匹配条件
查询作者是 jam 、tomi 的文档，返回 id 是2，3，4 的文档
2
3
4
5
6
7
8
9
2{
3 "query": {
4 "terms": {
5 "author": ["jam","tomi"]
6 }
7 }
8}'
9
3> range 过滤，指定范围查找
查找 id 范围是 大于等于2，小余4 的文档，返回 id 是2，3 的文档
2
3
4
5
6
7
8
9
10
11
12
2{
3 "query": {
4 "range": {
5 "id": {
6 "gte": 2,
7 "lt": 4
8 }
9 }
10 }
11}'
12
gt：大于
gte ：大于等于
lt：小于
lte：小于等于
4> bool 过滤
可以合并多个过滤条件查询结果的布尔逻辑，它有三个操作符
must
多个查询条件的完全匹配,相当于 and
must_not
多个查询条件的相反匹配，相当于 not
should
至少有一个查询条件匹配, 相当于 or
查找作者是 jam （查出 id 为 2，3 的文档），但是 id 不能为 2 的文档，返回 id 为 3的文档（should 就自己测试吧）
2
3
4
5
6
7
8
9
10
2{
3 "query": {
4 "bool": {
5 "must": { "term": { "author": "jam" }},
6 "must_not": { "term": { "id": 2 }}
7 }
8 }
9}'
10
提示：做精确匹配搜索时，你最好用过滤语句，因为过滤语句可以缓存数据
3、查询语句
1> multi_match 查询，同时搜索多个字段
查询 subject 或者 content 字段中有 “更新” 二字的文档，返回 id 为 4 的文档，由于用的分词器是 standard ，它会把 “更新” 拆成 “更”、”新” 来查找
2
3
4
5
6
7
8
9
10
2{
3 "query": {
4 "multi_match": {
5 "query": "更新",
6 "fields": ["subject", "content"]
7 }
8 }
9}'
10
2> bool 查询
与 bool 过滤相似，用于合并多个查询子句。
查询 内容中带有 “第” ，但是不带有 “新” 的文档，返回 id 为 2，3 的文档
2
3
4
5
6
7
8
9
10
2{
3 "query": {
4 "bool": {
5 "must": { "match": { "content": "第" }},
6 "must_not": { "match": { "content": "新" }}
7 }
8 }
9}'
10
3、复合查询
介绍完过滤语句和查询语句，现在我们就来将它们两个组合起来使用
请求体格式如下
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2 "query" : {
3 "filtered" : {
4 "query" : {
5 "match_all" : {}
6 },
7 "filter" : {
8 "term" : {
9 "author" : "jam"
10 }
11 }
12 }
13 }
14}
15
filtered 中可以只包含 query 或 filter 或者两者都存在，可存在多个 filter ，若不指定���询范围（query），默认为 “match_all” : {}
query 中可包含 bool 查询或match 查询
filter 中可包含各种过滤查询
现在来看一个比较复杂的例子
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
2{
3 "query": {
4 "filtered": {
5 "query" : {
6 "match_all" : {}
7 },
8 "filter" : {
9 "range": {
10 "id": {
11 "gte": 2,
12 "lte": 4
13 }
14 }
15 },
16 "filter" : {
17 "bool": {
18 "must": { "term": { "author": "jam" }},
19 "must_not": { "term": { "id": 2 }}
20 }
21 }
22 }
23 }
24}'
25
首先是查询所有数据（可省略），可改成有条件的查询
2
3
4
2 "match_all" : {}
3},
4
然后进行过滤查询，查询 id 范围 大于等于 2 小于等于 4 的文档
2
3
4
5
6
7
8
9
2 "range": {
3 "id": {
4 "gte": 2,
5 "lte": 4
6 }
7 }
8},
9
最后再过滤，查询作者是 jam ，但是 id 不能是 2 的文档，这样就只有 id 为 3 的文档符合条件
2
3
4
5
6
7
2 "bool": {
3 "must": { "term": { "author": "jam" }},
4 "must_not": { "term": { "id": 2 }}
5 }
6}
7
这条复合查询类似如下 SQL 语句
SELECT * FROM article WHERE id >= 2 AND id <= 4 AND author = ‘jam’ AND id != 2
4、 验证查询语句
查询语句的请求体越来越大，很容易在书写过程中出现错误，可以使用 validate API 的explain 进行验证
使用上面的复合查询语句（注意请求链接）
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
51
52
53
2{
3 "query": {
4 "filtered": {
5 "query" : {
6 "match_all" : {}
7 },
8 "filter" : {
9 "range": {
10 "id": {
11 "gte": 2,
12 "lte": 4
13 }
14 }
15 },
16 "filter" : {
17 "bool": {
18 "must": { "term": { "author": "jam" }},
19 "must_not": { "term": { "id": 2 }}
20 }
21 }
22 }
23 }
24}'
25#返回，真是正确的
26{
27 "valid" : true,
28 "_shards" : {
29 "total" : 1,
30 "successful" : 1,
31 "failed" : 0
32 },
33 "explanations" : [ {
34 "index" : "test",
35 "valid" : true,
36 "explanation" : "+(+*:* #(+author:jam -id:`\b\u0000\u0000\u0000\u0002)) #ConstantScore(+ConstantScore(_type:article))"
37 } ]
38}
39# 将第一个filter 上面的逗号去掉，再验证。错误信息中会提示第几行，第几列出错，方便修改错误
40{
41 "valid" : false,
42 "_shards" : {
43 "total" : 1,
44 "successful" : 1,
45 "failed" : 0
46 },
47 "explanations" : [ {
48 "index" : "test",
49 "valid" : false,
50 "error" : "[test] QueryParsingException[Failed to parse]; nested: JsonParseException[Unexpected character ('\"' (code 34)): was expecting comma to separate OBJECT entries\n at [Source: org.elasticsearch.transport.netty.ChannelBufferStreamInput@3175024d; line: 8, column: 14]];; com.fasterxml.jackson.core.JsonParseException: Unexpected character ('\"' (code 34)): was expecting comma to separate OBJECT entries\n at [Source: org.elasticsearch.transport.netty.ChannelBufferStreamInput@3175024d; line: 8, column: 14]"
51 } ]
52}
53
分析match 查询（explanation）
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
2{
3 "query": {
4 "match": {
5 "content": "更新"
6 }
7 }
8}'
9#返回
10{
11 "valid" : true,
12 "_shards" : {
13 "total" : 1,
14 "successful" : 1,
15 "failed" : 0
16 },
17 "explanations" : [ {
18 "index" : "test",
19 "valid" : true,
20 "explanation" : "+(content:更 content:新) #ConstantScore(+ConstantScore(_type:article))"
21 } ]
22}
23
explanations 中描述了 ES 将 “更新” 拆成 “更”、”新” 来查找
5、排序
默认情况下，结果集以 _score（相关性评分） 进行倒序排列（值越高越靠前）
可以使用 sort 指定排序字段
查询 内容中包含 “第二更新” 的文档，并按照 id 倒序排列
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
2{
3 "query": {
4 "match": {
5 "content": "第二更新"
6 }
7 },
8 "sort": {
9 "id": {
10 "order": "desc"
11 }
12 }
13}'
14#返回
15{
16 "took" : 96,
17 "timed_out" : false,
18 "_shards" : {
19 "total" : 5,
20 "successful" : 5,
21 "failed" : 0
22 },
23 "hits" : {
24 "total" : 3,
25 "max_score" : null,
26 "hits" : [ {
27 "_index" : "test",
28 "_type" : "article",
29 "_id" : "4",
30 "_score" : null,
31 "_source" : {
32 "id" : 4,
33 "subject" : "第四篇文章标题",
34 "content" : "第四篇文章内容-更新后",
35 "author" : "tomi"
36 },
37 "sort" : [ 4 ]
38 }, {
39 "_index" : "test",
40 "_type" : "article",
41 "_id" : "3",
42 "_score" : null,
43 "_source" : {
44 "id" : 3,
45 "subject" : "第三篇文章标题",
46 "content" : "第三篇文章内容",
47 "author" : "jam"
48 },
49 "sort" : [ 3 ]
50 }, {
51 "_index" : "test",
52 "_type" : "article",
53 "_id" : "AVf_6fM1vEkwGPLuUJqp",
54 "_score" : null,
55 "_source" : {
56 "id" : 2,
57 "subject" : "第二篇文章标题",
58 "content" : "第二篇文章内容",
59 "author" : "jam"
60 },
61 "sort" : [ 2 ]
62 } ]
63 }
64}
65
每个结果中多了个 sort 字段，就是以此来排序的，而 _score 的值为 null ，是因为计算 _score 是比较消耗性能的，而它通常主要用作排序，既然已经指定排序字段了，就不会计算 _score ，若要强制计算 _score ，可加入如下内容（与 query ，sort 同级）
2
2
多级排序
按照 _score 倒序排序，若分数相同，再按照 id 倒序排序；因为使用了 _score 排序，所以会计算出 _score ，而不需要使用 “track_scores” : true
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2{
3 "query": {
4 "match": {
5 "content": "第二更新"
6 }
7 },
8 "sort": [
9 { "_score": { "order": "desc" }},
10 { "id": { "order": "desc" }}
11 ]
12}'
13#返回
14...
15"sort" : [ 0.05846126, 4 ]
16...
17"sort" : [ 0.023869118, 2 ]
18...
19"sort" : [ 0.0050183414, 3 ]
20...
21
这里简单介绍一下 _score 相关性评分值是如何得来的，这就涉及到了 ElasticSearch 的相似度算法（ TF/IDF），即检索词频率/反向文档频率，它包括
检索词频率：检索词在该字段出现的频率，出现频率越高，相关性也越高
反向文档频率：一个词在所有文档中出现的频率，出现的越频繁，分数越低，因为像 “的” “我” 这类字出现得很频繁，对相关性贡献很低，相反，如 “ElasticSearch” 这类少见的词对相关性贡献很大，分数也就会越高
字段长度：字段越短，其权重就越高。检索词出现在一个较短的字段中比出现在一个较长的字段中所占的权重越高
参考文档
我们可以使用 explain 来查看相关性评分 _score 的计算过程，将上面的请求链接改成 http://localhost:9200/test/article/_search?explain&pretty 请求体不变
这里截取一段返回值做解释
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
2{
3 "value" : 0.023869118,
4 # 分析"第"字
5 "description" : "weight(content:第 in 0) [PerFieldSimilarity], result of:",
6 "details" : [ {
7 "value" : 0.023869118,
8 "description" : "score(doc=0,freq=1.0), product of:",
9 "details" : [ {
10 "value" : 0.20743163,
11 "description" : "queryWeight, product of:",
12 "details" : [ {
13 "value" : 0.30685282,
14 "description" : "idf(docFreq=1, maxDocs=1)",
15 "details" : [ ]
16 }, {
17 "value" : 0.67599714,
18 "description" : "queryNorm",
19 "details" : [ ]
20 } ]
21 }, {
22 "value" : 0.11506981,
23 "description" : "fieldWeight in 0, product of:",
24 "details" : [ {
25 "value" : 1.0,
26 # 检索词频率 检查
27 "description" : "tf(freq=1.0), with freq of:",
28 "details" : [ {
29 "value" : 1.0,
30 "description" : "termFreq=1.0",
31 "details" : [ ]
32 } ]
33 }, {
34 "value" : 0.30685282,
35 # 反向文档频率 检查
36 "description" : "idf(docFreq=1, maxDocs=1)",
37 "details" : [ ]
38 }, {
39 "value" : 0.375,
40 # 字段长度 检查
41 "description" : "fieldNorm(doc=0)",
42 "details" : [ ]
43 } ]
44 } ]
45 } ]
46}
47
6、分页与返回指定字段
分页
size 返回的结果数
from 开始数(偏移量)
先按照 id 字段顺序排序，然后从第二条（from）开始取，取两条（size）数据，返回 id 为 4 的文档
2
3
4
5
6
7
2{
3 "sort" : { "id" : { "order" : "asc"}},
4 "from" : 2,
5 "size" : 2
6}'
7
返回指定字段的数据。有时候数据字段太多，而我们使用的只是其中的几个字段，我么可以使用 _source 来指定返回的字段
查询所有数据， 只返回作者和标题
2
3
4
5
2{
3 "_source" : ["author" ,"subject"]
4}'
5
