一、简介

一、简介

1、RESTful

原则：

REST 指的是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是 RESTful。即可以理解为一种原则或者是设计风格。

特点：

1、每一个URI代表1种资源； 2、客户端使用GET、POST、PUT、DELETE4个表示操作方式的动词对服务端资源进行操作：GET用来获取资源，POST用来新建资源（也可以用于更新资源），PUT用来更新资源，DELETE用来删除资源；（增删改查） 3、通过操作资源的表现形式来操作资源； 4、资源的表现形式是XML或者HTML； 5、客户端与服务端之间的交互在请求之间是无状态的，从客户端到服务端的每个请求都必须包含理解请求所必需的信息。

2、数据格式

与MySql做对比
图片.png
注意：

ES里的Index可以看做一个库，而Types相当于表，Documents则相当于表的行。这里Types的概念已经被逐渐弱化，Elasticsearch 6.X中，一个index下已经只能包含一个type，Elasticsearch 7.X中, Type的概念已经被删除了。

json样例

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

3、HTTP操作

查看es版本

curl http://127.0.0.1:9200


{
  "name" : "node-1",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "EdMLWkYqS7a6tlLolc1GeA",
  "version" : {
    "number" : "7.8.1",#版本
    "build_flavor" : "default",
    "build_type" : "rpm",
    "build_hash" : "b5ca9c58fb664ca8bf9e4057fc229b3396bf3a89",
    "build_date" : "2020-07-21T16:40:44.668009Z",
    "build_snapshot" : false,
    "lucene_version" : "8.5.1",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

3.1、索引操作

1）创建索引

向ES服务器发PUT请求：http://127.0.0.1:9200/shopping

{
"acknowledged"【响应结果】: true, # true操作成功
"shards_acknowledged"【分片结果】: true, # 分片操作成功
"index"【索引名称】: "shopping"
}
# 注意：创建索引库的分片数默认1片，在7.0.0之前的Elasticsearch版本中，默认5片

2）查看所有索引

向ES服务器发GET请求：http://127.0.0.1:9200/_cat/indices?v
解释：

这里请求路径中的_cat表示查看的意思，indices表示索引，所以整体含义就是查看当前ES服务器中的所有索引，就好像MySQL中的show tables的感觉，服务器响应结果如下

图片.png

表头	含义
health	当前服务器健康状态： green(集群完整) yellow(单点正常、集群不完整) red(单点不正常)
status	索引打开、关闭状态
index	索引名
uuid	索引统一编号
pri	主分片数量
rep	副本数量
docs.count	可用文档数量
docs.deleted	文档删除状态（逻辑删除）
store.size	主分片和副分片整体占空间大小
pri.store.size	主分片占空间大小

3）查看单个索引

向ES服务器发GET请求：http://127.0.0.1:9200/shopping
注意：

查看索引向ES服务器发送的请求路径和创建索引是一致的。但是HTTP方法不一致。这里可以体会一下RESTful的意义

图片.png

{
"shopping"【索引名】: {        
"aliases"【别名】: {},
"mappings"【映射】: {},
"settings"【设置】: {
"index"【设置 - 索引】: {
"creation_date"【设置 - 索引 - 创建时间】: "1614265373911",
"number_of_shards"【设置 - 索引 - 主分片数量】: "1",
"number_of_replicas"【设置 - 索引 - 副分片数量】: "1",
"uuid"【设置 - 索引 - 唯一标识】: "eI5wemRERTumxGCc1bAk2A",
"version"【设置 - 索引 - 版本】: {
"created": "7080099"
                },
"provided_name"【设置 - 索引 - 名称】: "shopping"
            }
        }
    }
}

3）删除索引

向ES服务器发DELETE请求：http://127.0.0.1:9200/shopping 图片.png

3.2、文档操作

1）创建文档

向ES服务器发POST请求：http://127.0.0.1:9200/shopping/_doc
注意：

索引已经创建好了，接下来我们来创建文档，并添加数据。这里的文档可以类比为关系型数据库中的表数据，添加的数据格式为JSON格式

添加内容：

{
"title":"小米手机",
"category":"小米",
"images":"http://www.gulixueyuan.com/xm.jpg",
"price":3999.00
}

图片.png 注意：

此处发送请求的方式必须为POST，不能是PUT，否则会发生错误

响应：
图片.png

{
"_index"【索引】: "shopping",
"_type"【类型-文档】: "_doc",
"_id"【唯一标识】: "Xhsa2ncBlvF_7lxyCE9G", #可以类比为MySQL中的主键，随机生成
"_version"【版本】: 1,
"result"【结果】: "created", #这里的create表示创建成功
"_shards"【分片】: {
"total"【分片 - 总数】: 2,
"successful"【分片 - 成功】: 1,
"failed"【分片 - 失败】: 0
    },
"_seq_no": 0,
"_primary_term": 1
}

注意：

上面的数据创建后，由于没有指定数据唯一性标识（ID），默认情况下，ES服务器会随机生成一个。如果想要自定义唯一性标识，需要在创建时指定：http://127.0.0.1:9200/shopping/_doc/**1** 此处需要注意：如果增加数据时明确数据主键，那么请求方式也可以为PUT

2）查看文档

查看文档时，需要指明文档的唯一性标识，类似于MySQL中数据的主键查询
向ES服务器发GET请求：http://127.0.0.1:9200/shopping/_doc/1
图片.png

{
"_index"【索引】: "shopping",
"_type"【文档类型】: "_doc",
"_id": "1",
"_version": 2,
"_seq_no": 2,
"_primary_term": 2,
"found"【查询结果】: true, # true表示查找到，false表示未查找到
"_source"【文档源信息】: {
"title": "华为手机",
"category": "华为",
"images": "http://www.gulixueyuan.com/hw.jpg",
"price": 4999.00
    }
}

3）修改文档

和新增文档一样，输入相同的URL地址请求，如果请求体变化，会将原有的数据内容覆盖
向ES服务器发POST请求：http://127.0.0.1:9200/shopping/_doc/1
请求内容：

{
"title":"华为手机",
"category":"华为",
"images":"http://www.gulixueyuan.com/hw.jpg",
"price":4999.00
}

图片.png 响应结果：

{
"_index": "shopping",
"_type": "_doc",
"_id": "1",
"_version"【版本】: 2,
"result"【结果】: "updated", # updated表示数据被更新
"_shards": {
"total": 2,
"successful": 1,
"failed": 0
    },
"_seq_no": 2,
"_primary_term": 2
}

4）修改字段

修改数据时，也可以只修改某一给条数据的局部信息
向ES服务器发POST请求：http://127.0.0.1:9200/shopping/_doc/1/_update
请求体内容

{ 
"doc": {
"price":3000.00
  } 
}

图片.png

5）删除文档

删除一个文档不会立即从磁盘上移除，它只是被标记成已删除（逻辑删除）
向ES服务器发DELETE请求：http://127.0.0.1:9200/shopping/_doc/1
响应结果：
图片.png

{
"_index": "shopping",
"_type": "_doc",
"_id": "1",
"_version"【版本】: 4, #对数据的操作，都会更新版本
"result"【结果】: "deleted", # deleted表示数据被标记为删除
"_shards": {
"total": 2,
"successful": 1,
"failed": 0
    },
"_seq_no": 4,
"_primary_term": 2
}

6）条件删除文档

一般删除数据都是根据文档的唯一性标识进行删除，实际操作时，也可以根据条件对多条数据进行删除
删除目标数据：

{
"title":"小米手机",
"category":"小米",
"images":"http://www.gulixueyuan.com/xm.jpg",
"price":4000.00
}
{
"title":"华为手机",
"category":"华为",
"images":"http://www.gulixueyuan.com/hw.jpg",
"price":4000.00
}

向ES服务器发POST请求：http://127.0.0.1:9200/shopping/_delete_by_query
请求体内容：

{
"query":{
"match":{
"price":4000.00
    }
  }
}

图片.png

{
"took"【耗时】: 175,
"timed_out"【是否超时】: false,
"total"【总数】: 2,
"deleted"【删除数量】: 2,
"batches": 1,
"version_conflicts": 0,
"noops": 0,
"retries": {
"bulk": 0,
"search": 0
    },
"throttled_millis": 0,
"requests_per_second": -1.0,
"throttled_until_millis": 0,
"failures": []
}

3.3、映射操作

说明：

有了索引库，等于有了数据库中的database。接下来就需要建索引库(index)中的映射了，类似于数据库(database)中的表结构(table)。创建数据库表需要设置字段名称，类型，长度，约束等；索引库也一样，需要知道这个类型下有哪些字段，每个字段有哪些约束信息，这就叫做映射(mapping)。

1）创建映射

向ES服务器发PUT请求：http://127.0.0.1:9200/student/_mapping
请求体内容：

{
"properties": {
"name":{
"type": "text",
"index": true
    },
"sex":{
"type": "text",
"index": false
    },
"age":{
"type": "long",
"index": false
    }
  }
}

图片.png 映射数据说明：
ELK - 图15

    字段名：任意填写，下面指定许多属性，例如：title、subtitle、images、price
    type：类型，Elasticsearch中支持的数据类型非常丰富，说几个关键的：
    String类型，又分两种：
text：可分词
keyword：不可分词，数据会作为完整字段进行匹配
    Numerical：数值类型，分两类
基本数据类型：long、integer、short、byte、double、float、half_float
浮点数的高精度类型：scaled_float
    Date：日期类型
    Array：数组类型
    Object：对象
    index：是否索引，默认为true，也就是说你不进行任何配置，所有字段都会被索引。
true：字段会被索引，则可以用来进行搜索
false：字段不会被索引，不能用来搜索
    store：是否将数据进行独立存储，默认为false
原始的文本会存储在_source里面，默认情况下其他提取出来的字段都不是独立存储的，是从_source里面提取出来的。当然你也可以独立的存储某个字段，只要设置"store": true即可，获取独立存储的字段要比从_source中解析快得多，但是也会占用更多的空间，所以要根据实际业务需求来设置。
    analyzer：分词器，这里的ik_max_word即使用ik分词器,后面会有专门的章节学习

2）查看映射

向ES服务器发GET请求：http://127.0.0.1:9200/student/_mapping
图片.png
默认动态映射含义：

"productID": {
    "type": "text", //默认的type类型
    "fields": {
        "keyword": { // 字段名称 可以是任意你想要的单词 比如 raw
            "type": "keyword", //keyword 类型 不分词 用于聚合或排序
            "ignore_above": 256 //超过256长度无法被索引
        }
    }
}
查询 
{
  "query":{
    "term": {
      "productID": "haha" // 分词
    }
  }
}
{
  "query":{
    "term": {
      "productID.keyword": "haha" // 不分词
    }
  }
}

3）索引映射关联

向ES服务器发PUT请求：http://127.0.0.1:9200/student1
图片.png

4）补充

多字段：

Mapping 中可以定义 fields 多字段属性，以满足不同场景下的实现。比如 address 定义为 text 类型，fields 里面又有定义 keyword 类型，这里主要是区分两个不同不同使用场景。

text 会建立分词倒排索引，用于全文检索。
keyword 不会建立分词倒排索引，用于排序和聚合。
基于这个映射你即可以在字段上进行全文搜索, 也可以通过foo.keyword字段实现关键词搜索及数据聚合.

参考文档：链接

3.4、高级查询

Elasticsearch提供了基于JSON提供完整的查询DSL来定义查询
定义数据：

# POST /student/_doc/1001
{
"name":"zhangsan",
"nickname":"zhangsan",
"sex":"男",
"age":30
}
# POST /student/_doc/1002
{
"name":"lisi",
"nickname":"lisi",
"sex":"男",
"age":20
}
# POST /student/_doc/1003
{
"name":"wangwu",
"nickname":"wangwu",
"sex":"女",
"age":40
}
# POST /student/_doc/1004
{
"name":"zhangsan1",
"nickname":"zhangsan1",
"sex":"女",
"age":50
}
# POST /student/_doc/1005
{
"name":"zhangsan2",
"nickname":"zhangsan2",
"sex":"女",
"age":30
}

1）查询所有文档

向ES服务器发GET请求：http://127.0.0.1:9200/student/_search

{
"query": {
"match_all": {}
"track_total_hits": true --查出所有，不局限默认的一万条
  }
}
# "query"：这里的query代表一个查询对象，里面可以有不同的查询属性
# "match_all"：查询类型，例如：match_all(代表查询所有)， match，term ， range 等等
# {查询条件}：查询条件会根据类型的不同，写法也有差异

图片.png 响应结果：

{
    "took": 994,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 5,
            "relation": "eq"
        },
        "max_score": 1.0,
        "hits": [
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1001",
                "_score": 1.0,
                "_source": {
                    "name": "zhangsan",
                    "nickname": "zhangsan",
                    "sex": "男",
                    "age": 30
                }
            }
        ]
    }
}

{
"took【查询花费时间，单位毫秒】" : 1116,
"timed_out【是否超时】" : false,
"_shards【分片信息】" : {
"total【总数】" : 1,
"successful【成功】" : 1,
"skipped【忽略】" : 0,
"failed【失败】" : 0
  },
"hits【搜索命中结果】" : {
"total"【搜索条件匹配的文档总数】: {
"value"【总命中计数的值】: 3,
"relation"【计数规则】: "eq"# eq 表示计数准确， gte表示计数不准确
     },
"max_score【匹配度分值】" : 1.0,
"hits【命中结果集合】" : [
       。。。
      }
    ]
  }
}

2）匹配查询

match匹配类型查询，会把查询条件进行分词，然后进行查询，多个词条之间是or的关系
向ES服务器发GET请求：http://127.0.0.1:9200/student/_search

{
"query": {
"match": {
"name":"zhangsan"
    }
  }
}

图片.png
响应结果：

{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1,
            "relation": "eq"
        },
        "max_score": 1.3862942,
        "hits": [
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1001",
                "_score": 1.3862942,
                "_source": {
                    "name": "zhangsan",
                    "nickname": "zhangsan",
                    "sex": "男",
                    "age": 30
                }
            }
        ]
    }
}

3）字段匹配查询

multi_match与match类似，不同的是它可以在多个字段中查询。
向ES服务器发GET请求：http://127.0.0.1:9200/student/_search

{
"query": {
"multi_match": {
"query": "zhangsan",
"fields": ["name","nickname"]
    }
  }
}

响应结果：

{
    "took": 42,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1,
            "relation": "eq"
        },
        "max_score": 1.3862942,
        "hits": [
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1001",
                "_score": 1.3862942,
                "_source": {
                    "name": "zhangsan",
                    "nickname": "zhangsan",
                    "sex": "男",
                    "age": 30
                }
            }
        ]
    }
}

4）关键字精准查询

term查询，精确的关键词匹配查询，不对查询条件进行分词。
向ES服务器发GET请求：http://127.0.0.1:9200/student/_search

{
"query": {
"term": {
"name": {
"value": "zhangsan"
      }
    }
  }
}

图片.png
响应结果：

{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1,
            "relation": "eq"
        },
        "max_score": 1.3862942,
        "hits": [
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1001",
                "_score": 1.3862942,
                "_source": {
                    "name": "zhangsan",
                    "nickname": "zhangsan",
                    "sex": "男",
                    "age": 30
                }
            }
        ]
    }
}

5）多关键词精准查询

terms 查询和 term 查询一样，但它允许你指定多值进行匹配。
如果这个字段包含了指定值中的任何一个值，那么这个文档满足条件，类似于mysql的in
向ES服务器发GET请求：http://127.0.0.1:9200/student/_search

{
"query": {
"terms": {
"name": ["zhangsan","lisi"]
    }
  }
}

图片.png
响应结果：

{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 2,
            "relation": "eq"
        },
        "max_score": 1.0,
        "hits": [
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1001",
                "_score": 1.0,
                "_source": {
                    "name": "zhangsan",
                    "nickname": "zhangsan",
                    "sex": "男",
                    "age": 30
                }
            },
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1002",
                "_score": 1.0,
                "_source": {
                    "name": "lisi",
                    "nickname": "lisi",
                    "sex": "男",
                    "age": 20
                }
            }
        ]
    }
}

6）指定查询字段

默认情况下，Elasticsearch在搜索的结果中，会把文档中保存在_source的所有字段都返回。
如果我们只想获取其中的部分字段，我们可以添加_source的过滤
向ES服务器发GET请求：http://127.0.0.1:9200/student/_search

{
"_source": ["name","nickname"],  
"query": {
"terms": {
"nickname": ["zhangsan"]
    }
  }
}

图片.png 响应结果：

{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1,
            "relation": "eq"
        },
        "max_score": 1.0,
        "hits": [
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1001",
                "_score": 1.0,
                "_source": {
                    "name": "zhangsan",
                    "nickname": "zhangsan"
                }
            }
        ]
    }
}

区别term和match的区别

matchQuery： 会将搜索词分词，再与目标查询字段进行匹配，若分词中的任意一个词与目标字段匹配上，则可查询到。 termQuery： 不会对搜索词进行分词处理，而是作为一个整体与目标字段进行匹配，若完全匹配，则可查询到。term 查询被用于精确值匹配

7）过滤字段

我们也可以通过：
Ø includes：来指定想要显示的字段
Ø excludes：来指定不想要显示的字段
向ES服务器发GET请求：http://127.0.0.1:9200/student/_search

{
"_source": {
"includes": ["name","nickname"]
  },  
"query": {
"terms": {
"nickname": ["zhangsan"]
    }
  }
}

图片.png 响应结果：

{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1,
            "relation": "eq"
        },
        "max_score": 1.0,
        "hits": [
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1001",
                "_score": 1.0,
                "_source": {
                    "name": "zhangsan",
                    "nickname": "zhangsan"
                }
            }
        ]
    }
}

8）组合查询

bool把各种其它查询通过must（必须）、must_not（必须不）、should（应该）的方式进行组合
向ES服务器发GET请求：http://127.0.0.1:9200/student/_search

{
    "query": {
        "bool": {
            "must": [
                {
                    "match": {
                        "name": "zhangsan"
                    }
                }
            ],
            "must_not": [
                {
                    "match": {
                        "age": "40"
                    }
                }
            ],
            "should": [
                {
                    "match": {
                        "sex": "男"
                    }
                }
            ]
        }
    }
}

图片.png 响应结果：

{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1,
            "relation": "eq"
        },
        "max_score": 2.261763,
        "hits": [
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1001",
                "_score": 2.261763,
                "_source": {
                    "name": "zhangsan",
                    "nickname": "zhangsan",
                    "sex": "男",
                    "age": 30
                }
            }
        ]
    }
}

9）范围查询

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

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

向ES服务器发GET请求：http://127.0.0.1:9200/student/_search

{
"query": {
"range": {
"age": {
"gte": 30,
"lte": 35
      }
    }
  }
}

图片.png
响应结果：

{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 2,
            "relation": "eq"
        },
        "max_score": 1.0,
        "hits": [
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1001",
                "_score": 1.0,
                "_source": {
                    "name": "zhangsan",
                    "nickname": "zhangsan",
                    "sex": "男",
                    "age": 30
                }
            },
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1005",
                "_score": 1.0,
                "_source": {
                    "name": "zhangsan2",
                    "nickname": "zhangsan2",
                    "sex": "女",
                    "age": 30
                }
            }
        ]
    }
}

10）模糊查询

返回包含与搜索字词相似的字词的文档。
编辑距离是将一个术语转换为另一个术语所需的一个字符更改的次数。这些更改可以包括：
l 更改字符（box → fox）
l 删除字符（black → lack）
l 插入字符（sic → sick）
l 转置两个相邻字符（act → cat）
为了找到相似的术语，fuzzy查询会在指定的编辑距离内创建一组搜索词的所有可能的变体或扩展。然后查询返回每个扩展的完全匹配。
通过fuzziness修改编辑距离。一般使用默认值AUTO，根据术语的长度生成编辑距离。
向ES服务器发GET请求：http://127.0.0.1:9200/student/_search

{
"query": {
"fuzzy": {
"title": {
"value": "zhangsan"
      }
    }
  }
}

11）单字段排序

sort 可以让我们按照不同的字段进行排序，并且通过order指定排序的方式。desc降序，asc升序。
向ES服务器发GET请求：http://127.0.0.1:9200/student/_search

{
"query": {
"match": {
"name":"zhangsan"
    }
  },
"sort": [{
"age": {
"order":"desc"
    }
  }]
}

图片.png
响应结果：

{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1,
            "relation": "eq"
        },
        "max_score": null,
        "hits": [
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1001",
                "_score": null,
                "_source": {
                    "name": "zhangsan",
                    "nickname": "zhangsan",
                    "sex": "男",
                    "age": 30
                },
                "sort": [
                    30
                ]
            }
        ]
    }
}

12）多字段排序

假定我们想要结合使用 age和 _score进行查询，并且匹配的结果首先按照年龄排序，然后按照相关性得分排序
向ES服务器发GET请求：http://127.0.0.1:9200/student/_search

{
"query": {
"match_all": {}
  },
"sort": [
    {
"age": {
"order": "desc"
      }
    },
    {
"_score":{
"order": "desc"
      }
    }
  ]
}

图片.png
响应结果：

{
    "took": 0,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 5,
            "relation": "eq"
        },
        "max_score": null,
        "hits": [
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1004",
                "_score": 1.0,
                "_source": {
                    "name": "zhangsan1",
                    "nickname": "zhangsan1",
                    "sex": "女",
                    "age": 50
                },
                "sort": [
                    50,
                    1.0
                ]
            },
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1003",
                "_score": 1.0,
                "_source": {
                    "name": "wangwu",
                    "nickname": "wangwu",
                    "sex": "女",
                    "age": 40
                },
                "sort": [
                    40,
                    1.0
                ]
            },
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1001",
                "_score": 1.0,
                "_source": {
                    "name": "zhangsan",
                    "nickname": "zhangsan",
                    "sex": "男",
                    "age": 30
                },
                "sort": [
                    30,
                    1.0
                ]
            },
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1005",
                "_score": 1.0,
                "_source": {
                    "name": "zhangsan2",
                    "nickname": "zhangsan2",
                    "sex": "女",
                    "age": 30
                },
                "sort": [
                    30,
                    1.0
                ]
            },
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1002",
                "_score": 1.0,
                "_source": {
                    "name": "lisi",
                    "nickname": "lisi",
                    "sex": "男",
                    "age": 20
                },
                "sort": [
                    20,
                    1.0
                ]
            }
        ]
    }
}

13）高亮查询

在进行关键字搜索时，搜索出的内容中的关键字会显示不同的颜色，称之为高亮。
Ø 在百度搜索”京东”
图片.png
Elasticsearch可以对查询内容中的关键字部分，进行标签和样式(高亮)的设置。
在使用match查询的同时，加上一个highlight属性：
l pre_tags：前置标签
l post_tags：后置标签
l fields：需要高亮的字段
l title：这里声明title字段需要高亮，后面可以为这个字段设置特有配置，也可以空
向ES服务器发GET请求：http://127.0.0.1:9200/student/_search

{
"query": {
"match": {
"name": "zhangsan"
    }
  },
"highlight": {
"pre_tags": "<font color='red'>",
"post_tags": "</font>",
"fields": {
"name": {}
    }
  }
}

图片.png
响应结果：

{
    "took": 1,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1,
            "relation": "eq"
        },
        "max_score": 1.3862942,
        "hits": [
            {
                "_index": "student",
                "_type": "_doc",
                "_id": "1001",
                "_score": 1.3862942,
                "_source": {
                    "name": "zhangsan",
                    "nickname": "zhangsan",
                    "sex": "男",
                    "age": 30
                },
                "highlight": {
                    "name": [
                        "<font color='red'>zhangsan</font>"
                    ]
                }
            }
        ]
    }
}

14）分页查询

from：当前页的起始索引，默认从0开始。 from = (pageNum - 1) size
size：每页显示多少条
向ES服务器发*GET请求：http://127.0.0.1:9200/student/_search

{
"query": {
"match_all": {}
  },
"sort": [
    {
"age": {
"order": "desc"
      }
    }
  ],
"from": 0,
"size": 2
}

15）聚合查询
聚合允许使用者对es文档进行统计分析，类似与关系型数据库中的group by，当然还有很多其他的聚合，例如取最大值、平均值等等。
Ø 对某个字段取最大值max
向ES服务器发GET请求：http://127.0.0.1:9200/student/_search

{
"aggs":{
"max_age":{
"max":{"field":"age"}
      }
    },
"size":0
}

结果：

{
    "took": 1,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 5,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "max_age": {
            "value": 50.0
        }
    }
}

15）桶聚合查询

桶聚和相当于sql中的group by语句
Ø terms聚合，分组统计
向ES服务器发GET请求：http://127.0.0.1:9200/student/_search

{
"aggs":{
"age_groupby":{
"terms":{"field":"age"}
      }
    },
"size":0
}

结果：

{
    "took": 1,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 5,
            "relation": "eq"
        },
        "max_score": null,
        "hits": []
    },
    "aggregations": {
        "age_groupby": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
                {
                    "key": 30,
                    "doc_count": 2
                },
                {
                    "key": 20,
                    "doc_count": 1
                },
                {
                    "key": 40,
                    "doc_count": 1
                },
                {
                    "key": 50,
                    "doc_count": 1
                }
            ]
        }
    }
}

4、Java API

参考链接

5、安装环境

6、核心概念

6.1、索引（Index）

一个索引是一个几份相似的文档集合，一个索引由一个名字来标识（必须全是小写字母），可理解为新欢字典前面的目录。Elasticsearch索引的精髓：一切设计都是为了提高搜索的性能。

6.2、类型（Type）

在一个索引中，你可以定义一种或多种类型。一个类型是你的索引一个逻辑上的分类/分区。注：7.x后默认不再支持自定义索引类型（默认类型为：_doc）

6.3、文档（Document）

一个文档是一个可被索引的基础信息单元，也就是一条数据，文档以JSON（Javascript Object Notation）。在一个index/type里面，你可以存储任意多的文档。

6.4、字段（Field）

相当于是数据表的字段，对文档数据根据不同属性进行的分类标识。

6.5、映射（Mapping）

mapping是处理数据的方式和规则方面做一些限制。如：某个字段的数据类型、默认值、分析器、是否被索引等等。

6.6、分片（Shards）

Elasticsearch提供了将索引划分成多份的能力，每一份就称之为分片。设定你要想的数量，每个分片本身也是一个功能完善并且独立的“索引”，这个“索引”可以被放置到集群中的任何节点上。即索引是分片对的集合。

优点：

1）允许你水平分割/扩展你的内容容量。 2）允许你在分片之上进行分布式的、并行的操作，进而提高性能/吞吐量。注：内部由ElasticSearch管理，都是透明的，你无需过分关心。

注意：

1）分片数量不超过节点的3倍 2）主分片不能变，但是副本数量可以改变 3）若分片数量为3，副本为3，则6台机器就可以满足。

6.7、副本（Replicas）

故障转移机制，Elasticsearch允许你创建分片的一份或多份拷贝，这些拷贝叫做复制分片(副本)。存在主分片和复制分片。分片和复制的数量可以在索引创建的时候指定。可改变复制数量，但是不能改变分片的数量，

特点：

1）高可用 2）扩展你的搜索量/吞吐量

6.8、分配（Allocation）

将分片分配给某个节点的过程，包括分配主分片或者副本。如果是副本，还包含从主分片复制数据的过程。这个过程是由master节点完成的。

7、Flink框架集成

参考文档

8、底层概念和原理

8.1、水平扩容

我们这个拥有6个分片（3个主分片和3个副本分片）的索引可以最大扩容到6个节点，每个节点上存在一个分片，并且每个分片拥有所在节点的全部资源。主分片在创建索引的时候就确认好了，但是副本可以改变，如果在不同的节点上增加副本，可以增大吞吐量，但是在相同的节点上增加副本并不能提高性能。

8.2、路由计算

当索引一个文档的时候，文档会被存储到一个主分片中。这个存储不是随机的，是根据路由计算规则，公式如下：

routing 是一个可变值，默认是文档的 _id ，也可以设置成一个自定义的值。 routing 通过 hash 函数生成一个数字，然后这个数字再除以 number_of_primary_shards （主分片的数量）后得到余数。这个分布在 0 到 number_of_primary_shards-1 之间的余数，就是我们所寻求的文档所在分片的位置。

这就解释了为什么我们要在创建索引的时候就确定好主分片的数量并且永远不会改变这个数量：因为如果数量变化了，那么所有之前路由的值都会无效，文档也再也找不到了。所有的文档 API（ get 、 index 、 delete 、 bulk 、 update 以及 mget ）都接受一个叫做 routing 的路由参数，通过这个参数我们可以自定义文档到分片的映射。一个自定义的路由参数可以用来确保所有相关的文档——例如所有属于同一个用户的文档——都被存储到同一个分片中。

8.3、分片原理（倒排索引）

正向索引（forward index）：正常的索引，就是搜索引擎会将待搜索的文件都对应一个文件ID，搜索时将这个ID和搜索关键字进行对应，形成K-V对，然后对关键字进行统计计数。反向索引（inverted index）：适用于快速的全文搜索，也就是倒排索引，

词条：索引中最小存储和查询单元。
词典：词典是词条的集合，B+树、Hash树。
倒排表：

8.4、分词器

# GET http://localhost:9200/_analyze
{
    "text":"测试单词",
    "analyzer":"ik_max_word"
}

l ik_max_word：会将文本做最细粒度的拆分 l ik_smart：会将文本做最粗粒度的拆分

8.5、乐观锁和悲观锁

悲观锁：这种方法被关系型数据库广泛使用，它假定有变更冲突可能发生，因此阻塞访问资源以防止冲突。一个典型的例子是读取一行数据之前先将其锁住，确保只有放置锁的线程能够对这行数据进行修改。乐观锁：Elasticsearch 中使用的这种方法假定冲突是不可能发生的，并且不会阻塞正在尝试的操作。

新版本用：if_seq_no和if_primary_term控制。

9、优化

9.1、硬件选择

1）使用 SSD 2）使用 RAID 0(磁盘矩阵)。条带化 RAID 会提高磁盘 I/O，代价显然就是当一块硬盘故障时整个就故障了。不要使用镜像或者奇偶校验 RAID 因为副本已经提供了这个功能。 3）使用多块硬盘，并允许 Elasticsearch 通过多个 path.data 目录配置把数据条带化分配到它们上面。 4）不要使用远程挂载的存储，比如 NFS 或者 SMB/CIFS。这个引入的延迟对性能来说完全是背道而驰的。

9.2、分片策略

1）每个分片占用的硬盘容量不超过ES的最大JVM的堆空间设置（一般设置不超过32G，参考下文的JVM设置原则）。 2）一般都设置分片数不超过节点数的3倍。 3）主分片，副本和节点最大数之间数量，我们分配的时候可以参考以下关系：节点数<=主分片数*（副本数+1）

9.3、路由选择

查询的时候，可以直接根据 routing 信息定位到某个分配查询，不需要查询所有的分配，经过协调节点排序。

9.4、写入速度优化

如果对查询要求高，对写入要求不高，则默认配置即可。

9.5、内存优化

默认是1G，在jvm.option 文件中，Xms 表示堆的初始大小，Xmx 表示可分配的最大内存。这个两个参数尽量保持一致。ES堆内存遵循以下两个原则： 1）不要超过物理内存的 50% 2）堆内存的大小最好不要超过32GB：在 Java 中，所有对象都分配在堆上经验公式： -Xms 31g -Xmx 31g

9.6、重要配置

参数名	参数值	说明
cluster.name	elasticsearch	配置 ES 的集群名称，默认值是ES，建议改成与所存数据相关的名称，ES 会自动发现在同一网段下的集群名称相同的节点
node.name	node-1	集群中的节点名，在同一个集群中不能重复。节点的名称一旦设置，就不能再改变了。当然，也可以设置成服务器的主机名称，例如 node.name:${HOSTNAME}。
node.master	true	指定该节点是否有资格被选举成为 Master 节点，默认是 True，如果被设置为 True，则只是有资格成为 Master 节点，具体能否成为 Master 节点，需要通过选举产生。
node.data	true	指定该节点是否存储索引数据，默认为 True。数据的增、删、改、查都是在 Data 节点完成的。
index.number_of_shards	1	设置都索引分片个数，默认是 1 片。也可以在创建索引时设置该值，具体设置为多大都值要根据数据量的大小来定。如果数据量不大，则设置成 1 时效率最高
index.number_of_replicas	1	设置默认的索引副本个数，默认为 1 个。副本数越多，集群的可用性越好，但是写索引时需要同步的数据越多。
transport.tcp.compress	true	设置在节点间传输数据时是否压缩，默认为 False，不压缩
discovery.zen.minimum_master_nodes	1	设置在选举 Master 节点时需要参与的最少的候选主节点数，默认为 1。如果使用默认值，则当网络不稳定时有可能会出现脑裂。合理的数值为(master_eligible_nodes/2)+1，其中 master_eligible_nodes 表示集群中的候选主节点数
discovery.zen.ping.timeout	3s	设置在集群中自动发现其他节点时 Ping 连接的超时时间，默认为 3 秒。在较差的网络环境下需要设置得大一点，防止因误判该节点的存活状态而导致分片的转移

10、生产中遇到的问题

10.1、分词不生效

问题复现：

#匹配查询(34条)
GET contentelementtag/_search
{
    "query": {
        "match": {
            "tags": "火锅"
        }
    }
}
#匹配查询(17条)
GET contentelementtag/_search
{
    "query": {
        "match": {
            "tags.keyword": "火锅"
        }
    }
}

注意：一个是text类型的field，当我们想把他当成关键字的时候。可以像上面那样指定为关键字。代码中指定如下。但是不能用termquery去（）查询

ELK

一、简介

1、RESTful

2、数据格式

3、HTTP操作

查看es版本

3.1、索引操作

1）创建索引

2）查看所有索引

3） 查看单个索引

3） 删除索引

3.2、文档操作

1）创建文档

2）查看文档

3）修改文档

4）修改字段

5）删除文档

6）条件删除文档

3.3、映射操作

1）创建映射

2）查看映射

3）索引映射关联

4）补充

3.4、高级查询

1）查询所有文档

2） 匹配查询

3）字段匹配查询

4）关键字精准查询

5）多关键词精准查询

6）指定查询字段

区别term和match的区别

7）过滤字段

8）组合查询

9）范围查询

10）模糊查询

11）单字段排序

12）多字段排序

13）高亮查询

14）分页查询

15）桶聚合查询

4、Java API

5、安装环境

6、核心概念

6.1、索引（Index）

6.2、类型（Type）

6.3、文档（Document）

6.4、字段（Field）

6.5、映射（Mapping）

6.6、分片（Shards）

6.7、副本（Replicas）

6.8、分配（Allocation）

7、Flink框架集成

8、底层概念和原理

8.1、水平扩容

8.2、路由计算

8.3、分片原理（倒排索引）

8.4、分词器

8.5、乐观锁和悲观锁

9、优化

9.1、硬件选择

9.2、分片策略

9.3、路由选择

9.4、写入速度优化

9.5、内存优化

9.6、重要配置

10、生产中遇到的问题

10.1、分词不生效

11、sql使用

12、Kinaba使用

3）查看单个索引

3）删除索引

2）匹配查询