Elasticsearch快速入门

一.初识Elasticsearch

1.什么是Elasticsearch

• elasticsearch是一款非常强大的开源搜索引擎，可以帮助我们从海量数据中快速找到需要的内容
• elasticsearch结合kibana、Logstash、Beats，也就是elastic stack（ELK）。被广泛应用在日志数据分析、实时监控等领域
• elasticsearch是elastic stack的核心，负责存储、搜索、分析数据
  

2.正向索引和倒排索引

1.正向索引
基于文档（每一条数据就是一个文档 ）id创建索引。查询词条时必须先找到文档，而后判断是否包含词条

2.倒排索引
对文档内容分词，对词条（对文档中的内容分词，得到的词语就是词条）创建索引，并记录词条所在文档的信息。查询时先根据词条查询到文档id，而后获取到文档

elasticsearch是面向文档存储的，可以是数据库中的一条商品数据，一个订单信息。文档数据会被序列化为json格式后存储在elasticsearch中

3.ES与MySQL基本概念的对比

MySQL：擅长事务类型操作，可以确保数据的安全和一致性
Elasticsearch：擅长海量数据的搜索、分析、计算

将数据写入MySQL后，通过某种方法将数据同步到ES，以后从ES搜索数据，这样达到了ES和MySQL互补的效果

3.安装ES

3.1 创建网络
因为我们还需要部署kibana容器，因此需要让es和kibana容器互联。这里先创建一个网络：

docker network create es-net
1

3.2 拉取镜像并部署单点ES

docker pull elasticsearch:7.12.1
1

docker run -d \
	--name es \
    -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
    -e "discovery.type=single-node" \
    -v es-data:/usr/share/elasticsearch/data \
    -v es-plugins:/usr/share/elasticsearch/plugins \
    --privileged \
    --network es-net \
    -p 9200:9200 \
    -p 9300:9300 \
elasticsearch:7.12.1
1
2
3
4
5
6
7
8
9
10
11

命令解释：

• -e "cluster.name=es-docker-cluster"：设置集群名称
• -e "http.host=0.0.0.0"：监听的地址，可以外网访问
• -e "ES_JAVA_OPTS=-Xms512m -Xmx512m"：内存大小
• -e "discovery.type=single-node"：非集群模式
• -v es-data:/usr/share/elasticsearch/data：挂载逻辑卷，绑定es的数据目录
• -v es-logs:/usr/share/elasticsearch/logs：挂载逻辑卷，绑定es的日志目录
• -v es-plugins:/usr/share/elasticsearch/plugins：挂载逻辑卷，绑定es的插件目录
• --privileged：授予逻辑卷访问权
• --network es-net ：加入一个名为es-net的网络中
• -p 9200:9200：端口映射配置，供用户访问

访问IP:9200，可以看到ES安装成功。

4.安装Kibana

kibana可以给我们提供一个elasticsearch的可视化界面，便于我们学习

4.1 拉取kibana镜像并创建容器

docker pull kibana:7.12.1
1

docker run -d \
	--name kibana \
	-e ELASTICSEARCH_HOSTS=http://es:9200 \
	--network=es-net \
	-p 5601:5601  \
	kibana:7.12.1
1
2
3
4
5
6

• --network es-net ：加入一个名为es-net的网络中，与elasticsearch在同一个网络中
• -e ELASTICSEARCH_HOSTS=http://es:9200"：设置elasticsearch的地址，因为kibana已经与elasticsearch在一个网络，因此可以用容器名直接访问elasticsearch
• -p 5601:5601：端口映射配置

4.2 访问IP:5601

kibana中提供了一个DevTools界面，这个界面中可以编写DSL来操作elasticsearch。并且对DSL语句有自动补全功能。

5.安装IK分词器

# 进入容器内部
docker exec -it es /bin/bash

# 在线下载并安装
./bin/elasticsearch-plugin  install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.12.1/elasticsearch-analysis-ik-7.12.1.zip

#退出
exit
#重启容器
docker restart es
1
2
3
4
5
6
7
8
9
10

IK分词器包含两种模式：

• ik_smart：最少切分

• ik_max_word：最细切分

或者直接将解压好的ik文件上传到 /var/lib/docker/volumes/es-plugins/_data目录下，然后重启es即可！

POST /_analyze
{
  "text": "广州大学冲双一流！",
  "analyzer": "ik_max_word/ik_smart"
}
1
2
3
4
5

二.索引库操作

索引库，类似于数据库的表，各种字段都定义好了属性，类似于一张空表

1.创建索引库

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

PUT /索引库名称
{
  "mappings": {
    "properties": {
      "字段名":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "字段名2":{
        "type": "keyword",
        "index": "false"
      },
      "字段名3":{
        "properties": {
          "子字段": {
            "type": "keyword"
          }
        }
      },
      // ...略
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

示例：

PUT /gzhu
{
  "mappings": {
    "properties": {
      "name":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "email":{
        "type": "keyword",
        "index": "false"
      },
      "admin":{
        "properties": {
          "firstName": {
            "type": "keyword"
          },
          "lasttName": {
            "type": "keyword"
          }
        }
      }
    }
  }
}
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

2.查询索引库

查询索引库：GET /索引库名

3.删除索引库

删除索引库：DELETE /索引库名

4.添加新字段

添加字段：PUT /索引库名/_mapping

PUT /索引库名/_mapping
{
  "properties": {
    "新字段名":{
      "type": "integer"
    }
  }
}
1
2
3
4
5
6
7
8

三.文档操作

1.新增文档

POST /索引库名/_doc/文档id
{
    "字段1": "值1",
    "字段2": "值2",
    "字段3": {
        "子属性1": "值3",
        "子属性2": "值4"
    },
    // ...
}
1
2
3
4
5
6
7
8
9
10

示例：

POST /gzhu/_doc/1
{
  "name":"计算机科学与网络工程学院",
  "email":"gzhucom@edu.com",
  "admin":{
    "firstName":"张",
    "lastName":"三"
  }
}
1
2
3
4
5
6
7
8
9

2.查询文档

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

3.删除文档

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

4.修改文档

4.1 全量修改：删除旧文档，添加新文档，若文档不存在，也可以添加文档

PUT /索引库名/_doc/文档id
{
    "字段1": "值1",
    "字段2": "值2",
    // ... 略
}
1
2
3
4
5
6

4.2 局部修改文档：

POST /索引库名/_update/文档id
{
    "doc": {
         "字段名": "新的值",
    }
}
1
2
3
4
5
6

四.RestClient操作索引库

ES官方提供了各种不同语言的客户端，用来操作ES。这些客户端的本质就是组装DSL语句，通过http请求发送给ES。

1.创建索引库

1.1 引入依赖

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>
1
2
3
4

要在properties标签下声明版本，否在引入的依赖版本不匹配。

<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <elasticsearch.version>7.12.1</elasticsearch.version>
</properties>
1
2
3
4
5

1.2 创建一个表示DSL的常量（根据数据库和实际需求编写）
ID统一为keyword，对象为object，和实体类保持一致，text类型要指定具体的分词器。

{
  "order" : {
    "mappings" : {
      "properties" : {
        "id" : {
          "type" : "keyword"
        },
        "name" : {
          "type" : "text",
          "analyzer" : "ik_max_word"
        },
        "num" : {
          "type" : "integer"
        },
        "price" : {
          "type" : "long"
        },
        "user" : {
          "properties" : {
            "address" : {
              "type" : "text",
              "fields" : {
                "keyword" : {
                  "type" : "keyword",
                  "ignore_above" : 256
                }
              }
            },
            "id" : {
              "type" : "long"
            },
            "username" : {
              "type" : "text",
              "fields" : {
                "keyword" : {
                  "type" : "keyword",
                  "ignore_above" : 256
                }
              }
            }
          }
        },
        "userId" : {
          "type" : "keyword"
        }
      }
    }
  }
}

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

package com.gzhu.constants;

public class IndexConstants {
    public static final String MAPPING_STRING= "{\n" +
            "  \"mappings\": {\n" +
            "    \"properties\": {\n" +
            "      \"id\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"userId\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"name\":{\n" +
            "        \"type\": \"text\",\n" +
            "        \"analyzer\": \"ik_max_word\"\n" +
            "      },\n" +
            "      \"price\":{\n" +
            "        \"type\": \"long\"\n" +
            "      },\n" +
            "      \"num\":{\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"user\":{\n" +
            "        \"type\": \"object\"\n" +
            "      }\n" +
            "  }\n" +
            "}\n" +
            "}";
}
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

1.3 初始化RestHighLevelClient并发送请求

@SpringBootTest
public class IndexTest {

    private final RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
            HttpHost.create("http://192.168.10.128:9200")));

    @Test
    public void testCreateIndex() throws IOException {
        // 1.准备Request      PUT /order
        CreateIndexRequest request = new CreateIndexRequest("order");
        // 2.准备请求参数
        request.source(IndexConstants.MAPPING_STRING, XContentType.JSON);
        // 3.发送请求
        client.indices().create(request, RequestOptions.DEFAULT);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.删除索引库、判断索引库是否存在

2.1删除索引库

@Test
public void testDeleteIndex() throws IOException {
    // 1.准备Request      PUT /order
    DeleteIndexRequest request = new DeleteIndexRequest("order");
    // 3.发送请求
    client.indices().delete(request, RequestOptions.DEFAULT);
}
1
2
3
4
5
6
7

2.2 判断索引库是否存在

@Test
void testExistsIndex() throws IOException {
    // 1.准备Request
    GetIndexRequest request = new GetIndexRequest("order");
    // 3.发送请求
    boolean isExists = client.indices().exists(request, RequestOptions.DEFAULT);
    System.out.println(isExists ? "存在" : "不存在");
}
1
2
3
4
5
6
7
8

索引库操作的基本步骤：
1.初始化RestHighLevelClient

2.创建XxxIndexRequest，XXX是Create、Get、Delete

3.准备DSL（Create时需要）

4.发送请求。调用RestHighLevelClient#indices().xxx()方法，xxx是create、exists、delete

五.RestClient操作文档

1.新增文档

private final RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
        HttpHost.create("http://192.168.10.128:9200")));

@Test
public void testAddDoc() throws IOException {
    // 1.从数据库查询订单信息
    Order order = orderService.queryOrderById(101L);
    // 2.准备request对象 ==> POST /order/_doc/101
    IndexRequest request = new IndexRequest("order").id(order.getId().toString());
    // 3.准备JSON文档，要求JSON格式（推荐使用fastjson）
    request.source(JSON.toJSONString(order), XContentType.JSON);
    // 4.发送添加请求
    client.index(request, RequestOptions.DEFAULT);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.查询文档

@Test
void testGetDocumentById() throws IOException {
    // 1.准备Request      // GET /order/_doc/{id}
    GetRequest request = new GetRequest("order", "101");
    // 2.发送请求
    GetResponse response = client.get(request, RequestOptions.DEFAULT);
    // 3.解析响应结果
    String json = response.getSourceAsString();

    Order order = JSON.parseObject(json, Order.class);
    System.out.println("order= " + order);
}
1
2
3
4
5
6
7
8
9
10
11
12

3.更新文档

@Test
void testUpdateById() throws IOException {
    // 1.准备Request
    UpdateRequest request = new UpdateRequest("order", "101");
    // 2.准备参数
    request.doc(
            "num", "2"
    );
    // 3.发送请求
    client.update(request, RequestOptions.DEFAULT);
}
1
2
3
4
5
6
7
8
9
10
11

4.删除文档

@Test
void testDeleteDocumentById() throws IOException {
    // 1.准备Request      // DELETE /order/_doc/{id}
    DeleteRequest request = new DeleteRequest("order", "101");
    // 2.发送请求
    client.delete(request, RequestOptions.DEFAULT);
}

1
2
3
4
5
6
7
8

5.批量导入文档

@Test
void testBulkRequest() throws IOException {
    // 查询所有的订单数据
    List<Order> list = orderService.findAll();

    // 1.准备Request
    BulkRequest request = new BulkRequest();
    // 2.准备参数
    for (Order order : list) {
        // 2.1 转json
        String json = JSON.toJSONString(order);
        // 2.2 添加请求
        request.add(new IndexRequest("order").id(order.getId().toString()).source(json, XContentType.JSON));
    }

    // 3.发送请求
    client.bulk(request, RequestOptions.DEFAULT);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

五.DSL查询文档

1.查询基本语法

Elasticsearch提供了基于JSON的DSL（Domain Specific Language）来定义查询。常见的查询类型包括：

• 查询所有：查询出所有数据，一般测试用。例如：match_all

• 全文检索（full text）查询：利用分词器对用户输入内容分词，然后去倒排索引库中匹配。例如：
  match_query
  multi_match_query

• 精确查询：根据精确词条值查找数据，一般是查找keyword、数值、日期、boolean等类型字段。例如：
  ids
  range
  term

• 地理（geo）查询：根据经纬度查询。例如：
  geo_distance
  geo_bounding_box

• 复合（compound）查询：复合查询可以将上述各种查询条件组合起来，合并查询条件。例如：
  bool
  function_score

1.1 查询所有文档

GET /order/_search
{
  "query":{
    "match_all":{}
  }
}
1
2
3
4
5
6

1.2 全文检索（full text）查询

• match查询，查询字段name中包含5G的文档

GET /order/_search
{
  "query":{
    "match": {
      "name": "5G"
    }
  }
}
1
2
3
4
5
6
7
8

• multi_match查询，返回字段name或者user.address.keyword包含天津市的文档

GET /order/_search
{
  "query":{
    "multi_match": {
      "query": "天津市",
      "fields": ["user.address.keyword","name"]
   }
  }
}
1
2
3
4
5
6
7
8
9

1.3 精确查询

精确查询一般是查找keyword、数值、日期、boolean等类型字段。所以不会对搜索条件分词。

• term：根据词条精确值查询，不会分词
  查询价格字段为359900的文档，多一块少一块都查不到

GET /order/_search
{
  "query":{
    "term": {
      "price": {
        "value": "359900"
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10

• range：根据值的范围查询，比如日期，数字
  查询字段价格在0-1000000的文档

GET /order/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 0,
        "lte": 10000000
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11

gte包含等于，gt不包含等于。

1.4 Function score query详解
https://segmentfault.com/a/1190000037700644

示例：查询所有文档中name中包含Apple关键字的，并且将name中包含6s中的文档分数加权10（默认关系是乘法）

GET /order/_search
{
  "query": {
   "function_score": {
     "query": {
       "match": {
         "name": "Apple"
       }
     },
     "functions": [
       {"filter": {
         "term": {
           "name": "6s"
         }
       },
         "weight": 10
       }
     ]
   }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

1.5 复合查询 Boolean Query

• must：必须匹配的条件，可以理解为“与”
• should：选择性匹配的条件，可以理解为“或”
• must_not：必须不匹配的条件，不参与打分
• filter：必须匹配的条件，不参与打分

2.搜索结果处理（排序、分页、高亮）

2.1 排序

查询所有name包含Apple的文档，按照价格降序，数量升序的规则输出

GET /order/_search
{
  "query":{
    "match": {
      "name": "Apple"
    }
  },
  "sort": [
    {
      "price":"desc"
    },
    {
      "num":"asc"
    }
  ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.2 分页

从第一个开始，每页查询13条文档

GET /order/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0, //分页的开始，默认为0
  "size":13, //每页的文档数
  "sort":[
    {
      "price":"asc"
    }
  ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13

from+size原理：如果要查询第990-1000条文档，则先查询前1000条，再截取990-1000条文档。

但在实际环境中ES是集群部署的，数据分布在不同的ES服务器中，如果查询页数太深，对内存要求会很高。

首先在每个数据分片上都排序并查询前1000条文档。
然后将所有节点的结果聚合，在内存中重新排序选出前1000条文档。
最后从这1000条中，选取从990开始的10条文档。

ES限制查询分页总数必须小于等于10000，例如京东、淘宝、百度等他们的查询结果也不会超过10000。

如果真要查询10000以上的数据怎么办？
可以使用after search：
优点：没有查询上限（单次查询的size不超过10000）
缺点：只能向后逐页查询，不支持随机翻页
场景：没有随机翻页需求的搜索，例如手机向下滚动翻页

2.3 高亮

默认情况下，搜索字段必须和高亮字段一致，“require_field_match”: "false"可以取消此设定 name和name要一样（下面的示例一样，不用加false也可以高亮）

GET /order/_search
{
  "query": {
    "match": {
      "name": "Apple"
    }
  },
  "highlight": {
    "fields": {
      "name": {
        "require_field_match": "false"
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.RestClient查询文档

3.1 查询所有文档并转化成对象

@Test
void testMatchAll() throws IOException {
   // 1.准备Request，指定要查询的索引库
   SearchRequest request = new SearchRequest("order");
   // 2.准备DSL
   request.source().query(QueryBuilders.matchAllQuery());
   // 3.发送请求，默认返回JSON数据
   SearchResponse response = client.search(request, RequestOptions.DEFAULT);
   // 4.解析响应
   SearchHits searchHits = response.getHits();
   // 4.1.获取总条数
   Long total = searchHits.getTotalHits().value;
   System.out.println("共搜索到"+ total + "条文档");
   // 4.2.文档数组
   SearchHit[] hits = searchHits.getHits();
   // 4.3.遍历
   for(SearchHit hit : hits){
       // 获取文档source
       String json = hit.getSourceAsString();
       // 反序列化
       Order order = JSON.parseObject(json, Order.class);
       System.out.println(order);
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

3.2 全文检索（full text）查询

• match查询
  只需要修改3.1的DSL语句

// 2.准备DSL     
request.source().query(QueryBuilders.matchQuery("name","Apple"));
1
2

• multi_match查询

// 2.准备DSL
request.source().query(QueryBuilders.multiMatchQuery("Apple","name","price"));
1
2

3.3 精确查询

• term 慎用，在Java API 有时会失效

request.source().query(QueryBuilders.termQuery("price","6999"));
1

• range

request.source().query(QueryBuilders.rangeQuery("price").gte(100).lte(150));
1

3.4 Boolean Query查询

// 2.准备DSL
// 2.1 准备BooleanQuery
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
// 2.2 准备条件
boolQueryBuilder.must(QueryBuilders.termQuery("userId","1"));
boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").lte(1000));
request.source().query(boolQueryBuilder);
1
2
3
4
5
6
7

4.RestClient处理搜索结果

4.1 分页、排序

request.source().query(QueryBuilders.matchQuery("name","Apple"));
// sort
request.source().sort("prcie",SortOrder.ASC);
// 分页
request.source().from(0).size(12);
1
2
3
4
5

4.2 高亮

@Test
void testHighlight() throws IOException {
    // 1.准备Request，指定要查询的索引库
    SearchRequest request = new SearchRequest("order");
    // 2.准备DSL
    request.source().query(QueryBuilders.matchQuery("name","Apple"));
    // 2.1 query
    request.source().highlighter(new HighlightBuilder().field("name").requireFieldMatch(false));
    // 3.发送请求，默认返回JSON数据
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    SearchHits searchHits = response.getHits();
    // 4.1.获取总条数
    Long total = searchHits.getTotalHits().value;
    System.out.println("共搜索到"+ total + "条文档");
    // 4.2.文档数组
    SearchHit[] hits = searchHits.getHits();
    // 4.3.遍历
    for(SearchHit hit : hits){
        // 获取文档source
        String json = hit.getSourceAsString();
        // 反序列化
        Order order = JSON.parseObject(json, Order.class);
        // 获取高亮结果
        Map<String, HighlightField> highlightFields = hit.getHighlightFields();
        if(!CollectionUtils.isEmpty(highlightFields)){
            // 根据字段名获取结果
            HighlightField highlightField = highlightFields.get("name");
            if(highlightField != null){
                // 获取高亮值
                String name = highlightField.getFragments()[0].string();
                // 覆盖非高亮结果
                order.setName(name);
                System.out.println(order);
            }
        }
    }
}
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

六.数据聚合

1.聚合的分类

聚合（aggregations）可以实现对文档数据的统计、分析、运算。聚合常见的有三类：

• 桶（Bucket）聚合：用来对文档做分组
  TermAggregation：按照文档字段值分组
  Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组
• 度量（Metric）聚合：用以计算一些值，比如：最大值、最小值、平均值等
  Avg：求平均值
  Max：求最大值
  Min：求最小值
  Stats：同时求max、min、avg、sum等
• 管道（pipeline）聚合：其它聚合的结果为基础做聚合

参与聚合的字段类型必须是：

• keyword
• 数值
• 日期
• 布尔

2.Bucket聚合与Metrics聚合

2.1 Bucket聚合（几组，每组几个）
需求：查询索引库中有几个用户下过订单，分别下了几次订单

GET /order/_search
{
  "size": 0, //不显示文档
  "aggs": {
    "userCount": { // 聚合的名字，自定义
      "terms": { 
        "field": "userId", // 聚合的关键字
        "size": 5 // 显示的聚合数，假如有10个用户，只会显示5个
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12

默认情况下，Bucket聚合会统计Bucket内的文档数量，记为_count，并且按照_count降序排序。

默认情况下，Bucket聚合是对索引库的所有文档做聚合，我们可以限定要聚合的文档范围，只要添加query条件即可

需求：查询索引库中有几个用户下过订单，分别下了几次订单，只统计订单数目为1的文档

GET /order/_search
{
  "query": {
    "term": {
      "num": 1
    }
  }, 
  "size": 0, 
  "aggs": {
    "userCount": {
      "terms": {
        "field": "userId",
        "size": 5
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

aggs代表聚合，与query同级，此时query的作用是限定聚合的的文档范围
聚合必须的三要素：

• 聚合名称
• 聚合类型
• 聚合字段

聚合可配置属性有：

• size：指定聚合结果数量
• order：指定聚合结果排序方式
• field：指定聚合字段

2.2 Metrics聚合
需求：求每个用户消费的最大值、最小值、平均值、总金额

GET /order/_search
{
  "size": 0, 
  "aggs": {
    "userCount": {
      "terms": {
        "field": "userId",
        "size": 6
      },
      "aggs": {
        "price_stats": {  //聚合名字
          "stats": {    //聚合类型
            "field": "price"  //聚合字段
          }
        }
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3.RestAPI实现聚合（包含嵌套聚合的使用）

3.1 Bucket聚合

@Test
void tesBuckettAgg() throws IOException {
    // 1.请求
    SearchRequest request = new SearchRequest("order");
    // 2.DSL
    request.source().size(0);
    request.source().aggregation(AggregationBuilders
           .terms("userCount")
           .field("userId")
           .size(6));
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析结果
    Aggregations aggregations = response.getAggregations();
    Terms userCount = aggregations.get("userCount");
    List<? extends Terms.Bucket> buckets = userCount.getBuckets();
    for(Terms.Bucket bucket : buckets){
        String userId = bucket.getKeyAsString();
        long doc_count = bucket.getDocCount();
        System.out.println("key:"+userId+ " "+ "doc_count:"+doc_count);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

图解请求：

解析聚合结果：

3.2 Metrics聚合（包含嵌套聚合）

@Test
void testMetricAgg() throws IOException {
    // 1.请求
    SearchRequest request = new SearchRequest("order");
    // 2.DSL
    request.source().size(0);
    request.source().aggregation(AggregationBuilders
            .terms("userCount")
            .field("userId")
            .size(6).subAggregation(AggregationBuilders
                    .stats("price_stats")
                    .field("price")));
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析结果
    Aggregations aggregations = response.getAggregations();

    Terms userCount = aggregations.get("userCount");
    List<? extends Terms.Bucket> buckets = userCount.getBuckets();
    for(Terms.Bucket bucket : buckets){
        String userId = bucket.getKeyAsString();
        long doc_count = bucket.getDocCount();
        Stats price_stats = bucket.getAggregations().get("price_stats");
        double avg = price_stats.getAvg();
        System.out.println("key:"+userId+ " "+ "doc_count:"+doc_count+ " "+"avg"+ avg);
    }
}
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

4.多条件聚合

同时对用户id和订单价格聚合，实际开发中可以返回一个Map集合，同样的，可以通过添加查询语句限定查询范围：request.source().query(QueryBuilders.termQuery(“num”,4));

@Test
void testMulConditions() throws IOException {
    SearchRequest request = new SearchRequest("order");
    request.source().size(0);
    buildAgg(request);
    // 发出请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);

    Map<String, List<String>> result = new HashMap<>();
    Aggregations aggregations = response.getAggregations();

    List<String> userList = getAggByName(aggregations, "userAgg");
    result.put("用户", userList);


    List<String> priceList = getAggByName(aggregations, "priceAgg");
    result.put("价格", priceList);

    System.out.println(priceList);
}

private void buildAgg(SearchRequest request) {
    request.source().aggregation(AggregationBuilders
            .terms("userAgg")
            .field("userId")
            .size(6));
    request.source().aggregation(AggregationBuilders
            .terms("priceAgg")
            .field("price")
            .size(13));
}

private List<String> getAggByName(Aggregations aggregations, String aggName) {
    // 根据聚合名称获取聚合结果
    Terms terms = aggregations.get(aggName);
    // 获取buckets
    List<? extends Terms.Bucket> buckets = terms.getBuckets();
    // 遍历
    List<String> list = new ArrayList<>();
    for (Terms.Bucket bucket : buckets) {
        // 获取key
        String key = bucket.getKeyAsString();
        list.add(key);
    }
    return list;
}
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

七.自动补全

1.安装拼音分词器

①下载并解压：https://github.com/medcl/elasticsearch-analysis-pinyin/tags

②将解压文件上传到目录/var/lib/docker/volumes/es-plugins/_data

③重启es容器
④测试

2.自定义分词器

默认的拼音分词器会将每个汉字单独分为拼音，而我们希望的是每个词条形成一组拼音，需要对拼音分词器做个性化定制，形成自定义分词器

elasticsearch中分词器（analyzer）的组成包含三部分：

• character filters：在tokenizer之前对文本进行处理。例如删除字符、替换字符
• tokenizer：将文本按照一定的规则切割成词条（term）。例如keyword，就是不分词；还有ik_smart
• tokenizer filter：将tokenizer输出的词条做进一步处理。例如大小写转换、同义词处理、拼音处理等

自定义分词器要在创建索引库时定义，例如，创建order索引库。为了避免搜索到同音字，搜索时不要使用拼音分词器，创建倒排索引时才使用自定义分词器

PUT /order
{
  "settings": {
    "analysis": {
      "analyzer": { // 自定义分词器
        "my_analyzer": {  // 分词器名称
          "tokenizer": "ik_max_word",
          "filter": "py"
        }
      },
      "filter": { // 自定义tokenizer filter
        "py": { // 过滤器名称
          "type": "pinyin", // 过滤器类型，这里是pinyin
		  "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "name": {
        "type": "text",
        "analyzer": "my_analyzer",
        "search_analyzer": "ik_smart"
      }
    }
  }
}
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

3.实现自动补全

3.1 控制台实现
elasticsearch提供了Completion Suggester查询来实现自动补全功能。这个查询会匹配以用户输入内容开头的词条并返回。为了提高补全查询的效率，对于文档中字段的类型有一些约束：

• 参与补全查询的字段必须是completion类型

• 字段的内容一般是用来补全的多个词条形成的数组

PUT /order
{
  "settings": {
    "analysis": {
      "analyzer": {
        "text_anlyzer": {
          "tokenizer": "ik_max_word",
          "filter": "py"
        },
        "completion_analyzer": {
          "tokenizer": "keyword",
          "filter": "py"
        }
      },
      "filter": {
        "py": {
          "type": "pinyin",
          "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        }
      }
    }
  },
    
  "mappings" : {
      "properties" : {
        "id" : {
          "type" : "keyword"
        },
        "name" : {
          "type" : "text",
          "analyzer" : "text_anlyzer",
          "search_analyzer": "ik_smart"
        },
        "num" : {
          "type" : "integer"
        },
        "price" : {
          "type" : "long"
        },
        "user" : {
          "properties" : {
            "address" : {
              "type" : "text",
              "fields" : {
                "keyword" : {
                  "type" : "keyword",
                  "ignore_above" : 256
                }
              }
            },
            "id" : {
              "type" : "long"
            },
            "username" : {
              "type" : "text",
              "fields" : {
                "keyword" : {
                  "type" : "keyword",
                  "ignore_above" : 256
                }
              }
            }
          }
        },
        "userId" : {
          "type" : "keyword"
        },
        "suggestion":{
          "type": "completion",
          "analyzer": "completion_analyzer"
      }
      }
    }
}
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

由于自动补全一般是几个关键字组成的数组，所以对应Java实体类可以是一个String类型的List集合，集合里面放参加补全的字段

创建好索引库，插入文档即可

GET /order/_search
{
  "suggest": {
    "my_suggestions": {
      "text": "b",
      "completion": {
        "field": "suggestion",
        "skip_duplicates": true, // 跳过重复的
        "size":10
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

3.2 RestAPI实现

@Test
public void testSuggest() throws IOException {
    // 准备request
    SearchRequest request = new SearchRequest("order");
    // 准备DSL
    request.source().suggest(new SuggestBuilder().addSuggestion(
            "my_suggestions",
            SuggestBuilders.completionSuggestion("suggestion")
                    .prefix("b")
                    .skipDuplicates(true)
                    .size(10)
    ));
    // 发起请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);

    // 解析结果
    Suggest suggest = response.getSuggest();
    CompletionSuggestion my_suggestions = suggest.getSuggestion("my_suggestions");
    List<CompletionSuggestion.Entry.Option> options = my_suggestions.getOptions();
    for (CompletionSuggestion.Entry.Option option : options){
        String text = option.getText().toString();
        System.out.println(text);
    }

}
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

八.数据同步

采用MQ异步通知的方式完成数据同步，即当对数据库进行操作时，发送一条消息到队列，对ES的相关操作监听这个队列，有消息就完成ES的修改。

• 引入依赖

<!--amqp-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
1
2
3
4
5

• 配置yml配置文件

spring:
  rabbitmq:
    host: 192.168.10.129
    port: 5672
    username: itcast
    password: 123321
    virtual-host: /
1
2
3
4
5
6
7

• 定义MQ的相关常量

public class mqConstants {
    // 采用话题交换机
    public static final String ORDER_EXCHANGE = "order.topic";
    // 新增或修改的消息队列
    public static final String ORDER_QUEUE_INSERT = "order.insert.queue";
    // 删除的消息队列
    public static final String ORDER_QUEUE_DELETE = "order.delete.queue";
    // 新增或修改的RoutingKey
    public final static String ORDER_INSERT_KEY = "order.insert";
    // 删除的RoutingKey
    public final static String ORDER_DELETE_KEY = "order.delete";

}
1
2
3
4
5
6
7
8
9
10
11
12
13

• 使用配置文件方式声明交换机和队列

@Configuration
public class MqConfig {
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange(MqConstants.ORDER_EXCHANGE, true, false);
    }

    @Bean
    public Queue insertQueue(){
        return new Queue(MqConstants.ORDER_INSERT_QUEUE, true);
    }

    @Bean
    public Queue deleteQueue(){
        return new Queue(MqConstants.ORDER_DELETE_QUEUE, true);
    }

    @Bean
    public Binding insertQueueBinding(){
        return BindingBuilder.bind(insertQueue()).to(topicExchange()).with(MqConstants.ORDER_INSERT_KEY);
    }

    @Bean
    public Binding deleteQueueBinding(){
        return BindingBuilder.bind(deleteQueue()).to(topicExchange()).with(MqConstants.ORDER_DELETE_KEY);
    }
}
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

• 在增删改的同时向相应的队列发送消息

@Controller
public class OrderController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Autowired
    private OrderService orderService;

    @GetMapping("/order/{id}")
    public Order queryById(@PathVariable("id") Long id){
       return orderService.queryOrderById(id);
    }

    @PostMapping("/order/insert")
    public void insertOrder(){
        Long id = 666L;
        Long userId = 2L;
        String name = "刘刘求";
        Long price = 3999L;
        Integer num = 1;
        String address = "重庆";

        Order order = new Order();
        order.setId(id);
        order.setUserId(userId);
        order.setName(name);
        order.setPrice(price);
        order.setNum(num);
        order.setAddress(address);

        orderService.insertOrder(order);
        rabbitTemplate.convertAndSend(MqConstants.ORDER_EXCHANGE,MqConstants.ORDER_INSERT_KEY,order.getId());
    }

    @PutMapping("/order/update/{id}")
    public void updateOrder(@PathVariable("id") Long id){
        Order order = queryById(id);
        order.setPrice(6666L);
        orderService.updateOrder(order);
        rabbitTemplate.convertAndSend(MqConstants.ORDER_EXCHANGE,MqConstants.ORDER_INSERT_KEY,order.getId());
    }
    @DeleteMapping("/order/delete/{id}")
    public void deleteOrder(@PathVariable("id") Long id){
        orderService.deleteOrder(id);
        rabbitTemplate.convertAndSend(MqConstants.ORDER_EXCHANGE,MqConstants.ORDER_DELETE_KEY,id);
    }
}
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

• 创建一个消息监听类，实现对ES的更改

@Component
public class MqListener {
    @Autowired
    private OrderService orderService;
    private final RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
            HttpHost.create("http://192.168.10.129:9200")));

    @RabbitListener(queues = MqConstants.ORDER_INSERT_QUEUE)
    public void listenHotelInsertOrUpdate(Long id) throws IOException {
        // 1.从数据库查询订单信息
        Order order = orderService.queryOrderById(id);
        // 2.准备request对象  POST /order/_doc/101
        IndexRequest request = new IndexRequest("order").id(order.getId().toString());
        // 3.准备JSON文档，要求JSON格式（推荐使用fastjson）
        request.source(JSON.toJSONString(order), XContentType.JSON);
        // 4.发送添加请求
        client.index(request, RequestOptions.DEFAULT);
    }

    @RabbitListener(queues = MqConstants.ORDER_DELETE_QUEUE)
    public void listenHotelDelete(Long id) throws IOException {
        // 1.准备Request      // DELETE /order/_doc/{id}
        DeleteRequest request = new DeleteRequest("order", String.valueOf(id));
        // 2.发送请求
        client.delete(request, RequestOptions.DEFAULT);
    }
}
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

九.ES集群

数据备份可以保证高可用，但是每个分片备份一份，所需要的节点数量就会翻一倍，成本实在是太高了！

为了在高可用和成本间寻求平衡，我们可以这样做：

• 首先对数据分片，存储到不同节点
• 然后对每个分片进行备份，放到对方节点，完成互相备份
  

1.搭建ES集群环境

首先准备三台服务器，每台服务器先要有ES的镜像

重要设置

#创建conf
grep vm.max_map_count /etc/sysctl.conf
#文件里设置参数
vim /etc/sysctl.conf
#设置
vm.max_map_count=262144
#永久生效
echo vm.max_map_count=262144>>/etc/sysctl.conf
#查看
sysctl -p
1
2
3
4
5
6
7
8
9
10

否则部署的ES会报78错误码，如果设置了此参数依旧78错误码，重启服务器

在根目录下创建文件
/es/config/esX.yml（其中X=1、2、3，对应三台服务器，下同），配置信息如下

cluster.name: elasticsearch-cluster
node.name: es-nodeX
network.host: 0.0.0.0
network.publish_host: 192.168.10.131
http.port: 9200
transport.tcp.port: 9300
http.cors.enabled: true
http.cors.allow-origin: "*"
cluster.initial_master_nodes: ["es-node1","es-node2","es-node3"]
node.master: true
node.data: true
discovery.zen.ping.unicast.hosts: ["192.168.10.129:9300","192.168.10.130:9300"]
discovery.zen.minimum_master_nodes: 2
1
2
3
4
5
6
7
8
9
10
11
12
13

• cluster.name必须一致，代表一个集群
• node.name必须不一致，代表三个节点
• network.publish_host代表本机IP
• cluster.initial_master_nodes: [“es-nodeX”]和node.name必须一致

节点角色：

• node.master：备选主节点，主节点可以管理和记录集群状态、决定分片在哪个节点、处理创建和删除索引库的请求
• node.data：数据节点，存储数据、搜索、聚合、CRUD
• node.ingest：数据存储之前的预处理
• coordinating：路由请求到其他节点，合并其他节点处理的结果，返回给用户

运行容器

docker run -e ES_JAVA_OPTS="-Xms256m -Xmx256m" -d -p 9200:9200 -p 9300:9300 -v /es/config/es3.yml:/usr/share/elasticsearch/config/elasticsearch.yml  --name es03 elasticsearch:7.12.1
1

如果以上无误，其实包含三个节点的es集群已经搭建起来了！

2.集群状态监控

利用cerebro进行监控

• 拉取镜像

 docker pull lmenezes/cerebro
1

• 运行容器

docker run -d --name cerebro -p 9100:9000 lmenezes/cerebro
1

• 访问IP:9100
  
• 输入 http://192.168.10.129:9200 （任意节点服务器即可），可以看到刚才部署的es集群的3个节点信息
  

3.脑裂及解决

脑裂是因为集群中的节点失联导致的
例如一个集群中，主节点与其它节点失联

此时，node2和node3认为node1宕机，就会重新选主

当node3当选后，集群继续对外提供服务，node2和node3自成集群，node1自成集群，两个集群数据不同步，出现数据差异

当网络恢复后，因为集群中有两个master节点，集群状态的不一致，出现脑裂的情况

解决脑裂的方案是，要求选票超过 ( eligible节点数量 + 1 ）/ 2 才能当选为主，因此eligible节点数量最好是奇数。对应配置项是discovery.zen.minimum_master_nodes，在es7.0以后，已经成为默认配置，因此一般不会发生脑裂问题

例如：3个节点形成的集群，选票必须超过 （3 + 1） / 2 ，也就是2票。node3得到node2和node3的选票，当选为主。node1只有自己1票，没有当选。集群中依然只有1个主节点，没有出现脑裂

4.集群新增数据及查询流程

• 新增流程：
  
  当用户新增一条文档时，首先要经过某种哈希运算计算要分配到哪个分片上，shard=hash(_routing)%number_of_shards，_routing默认是文档的id，可见，算法与分片数量有关，所以索引库一旦创建，分片数量不可以修改！确定好哪个分片后，路由节点到相应的节点，相应的分片保存数据，并将数据同步到副本节点，以上完成后，返回成功的信息给路由节点，路由节点再返回给用户成功的信息

• 查询流程：
  
  协调节点会把请求分发到每一个分片，称为分散阶段。协调节点汇总data node的结果，称为聚集阶段，并处理结果集返回给用户

5.故障转移

集群的master节点会监控集群中的节点状态，如果发现有节点宕机，会立即将宕机节点的分片数据迁移到其它节点，确保数据安全，这个叫做故障转移

以上es会自动完成故障转移操作，特别注意的是，如果宕机的节点又恢复正常了，则当前的主节点会把相应的分片再分发回去，十分强大！

十.小结

以上都经过验证，确保无误，相应示例简单，适合入门
2021年12月2日 广州

相关文件：
链接：https://pan.baidu.com/s/1vFe3zs0hiUL9vWiuSOkcww
提取码：eabj