Elasticsearch快速入门

Elasticsearch入门学习

      • 一.初识Elasticsearch
        • 1.什么是Elasticsearch
        • 2.正向索引和倒排索引
        • 3.安装ES
        • 4.安装Kibana
        • 5.安装IK分词器
      • 二.索引库操作
        • 1.创建索引库
        • 2.查询索引库
        • 3.删除索引库
        • 4.添加新字段
      • 三.文档操作
        • 1.新增文档
        • 2.查询文档
        • 3.删除文档
        • 4.修改文档
      • 四.RestClient操作索引库
        • 1.创建索引库
        • 2.删除索引库、判断索引库是否存在
      • 五.RestClient操作文档
        • 1.新增文档
        • 2.查询文档
        • 3.更新文档
        • 4.删除文档
        • 5.批量导入文档
      • 五.DSL查询文档
        • 1.查询基本语法
        • 2.搜索结果处理(排序、分页、高亮)
        • 3.RestClient查询文档
        • 4.RestClient处理搜索结果
      • 六.数据聚合
        • 1.聚合的分类
        • 2.Bucket聚合与Metrics聚合
        • 3.RestAPI实现聚合(包含嵌套聚合的使用)
        • 4.多条件聚合
      • 七.自动补全
        • 1.安装拼音分词器
        • 2.自定义分词器
        • 3.实现自动补全
      • 八.数据同步
      • 九.ES集群
        • 1.搭建ES集群环境
        • 2.集群状态监控
        • 3.脑裂及解决
        • 4.集群新增数据及查询流程
        • 5.故障转移
      • 十.小结

一.初识Elasticsearch

1.什么是Elasticsearch
  • elasticsearch是一款非常强大的开源搜索引擎,可以帮助我们从海量数据中快速找到需要的内容
  • elasticsearch结合kibana、Logstash、Beats,也就是elastic stack(ELK)。被广泛应用在日志数据分析、实时监控等领域
  • elasticsearch是elastic stack的核心,负责存储、搜索、分析数据
    Elasticsearch快速入门_第1张图片
2.正向索引和倒排索引

1.正向索引
基于文档(每一条数据就是一个文档 )id创建索引。查询词条时必须先找到文档,而后判断是否包含词条
Elasticsearch快速入门_第2张图片
2.倒排索引
对文档内容分词,对词条(对文档中的内容分词,得到的词语就是词条)创建索引,并记录词条所在文档的信息。查询时先根据词条查询到文档id,而后获取到文档
Elasticsearch快速入门_第3张图片
elasticsearch是面向文档存储的,可以是数据库中的一条商品数据,一个订单信息。文档数据会被序列化为json格式后存储在elasticsearch中
Elasticsearch快速入门_第4张图片
3.ES与MySQL基本概念的对比

MySQL:擅长事务类型操作,可以确保数据的安全和一致性
Elasticsearch:擅长海量数据的搜索、分析、计算
Elasticsearch快速入门_第5张图片
将数据写入MySQL后,通过某种方法将数据同步到ES,以后从ES搜索数据,这样达到了ES和MySQL互补的效果
Elasticsearch快速入门_第6张图片

3.安装ES

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

docker network create es-net

在这里插入图片描述

3.2 拉取镜像并部署单点ES

docker pull elasticsearch:7.12.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

命令解释:

  • -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安装成功。
Elasticsearch快速入门_第7张图片

4.安装Kibana

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

4.1 拉取kibana镜像并创建容器

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

4.2 访问IP:5601
Elasticsearch快速入门_第8张图片
kibana中提供了一个DevTools界面,这个界面中可以编写DSL来操作elasticsearch。并且对DSL语句有自动补全功能。
Elasticsearch快速入门_第9张图片

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

IK分词器包含两种模式:

  • ik_smart:最少切分

  • ik_max_word:最细切分

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

POST /_analyze
{
  "text": "广州大学冲双一流!",
  "analyzer": "ik_max_word/ik_smart"
}

Elasticsearch快速入门_第10张图片

Elasticsearch快速入门_第11张图片

二.索引库操作

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

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"
          }
        }
      },
      // ...}
  }
}

示例:

PUT /gzhu
{
  "mappings": {
    "properties": {
      "name":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "email":{
        "type": "keyword",
        "index": "false"
      },
      "admin":{
        "properties": {
          "firstName": {
            "type": "keyword"
          },
          "lasttName": {
            "type": "keyword"
          }
        }
      }
    }
  }
}
2.查询索引库

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

3.删除索引库

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

4.添加新字段

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

PUT /索引库名/_mapping
{
  "properties": {
    "新字段名":{
      "type": "integer"
    }
  }
}

三.文档操作

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

示例:

POST /gzhu/_doc/1
{
  "name":"计算机科学与网络工程学院",
  "email":"[email protected]",
  "admin":{
    "firstName":"张",
    "lastName":"三"
  }
}
2.查询文档

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

3.删除文档

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

4.修改文档

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

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

4.2 局部修改文档:

POST /索引库名/_update/文档id
{
    "doc": {
         "字段名": "新的值",
    }
}

四.RestClient操作索引库

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

1.创建索引库

1.1 引入依赖

<dependency>
    <groupId>org.elasticsearch.clientgroupId>
    <artifactId>elasticsearch-rest-high-level-clientartifactId>
dependency>

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

<properties>
    <maven.compiler.source>8maven.compiler.source>
    <maven.compiler.target>8maven.compiler.target>
    <elasticsearch.version>7.12.1elasticsearch.version>
properties>

1.2 创建一个表示DSL的常量(根据数据库和实际需求编写)
ID统一为keyword,对象为object,和实体类保持一致,text类型要指定具体的分词器。
Elasticsearch快速入门_第12张图片

{
  "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"
        }
      }
    }
  }
}

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.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);
    }
}
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);
}

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.初始化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);

}
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);
}
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);
}
4.删除文档
@Test
void testDeleteDocumentById() throws IOException {
    // 1.准备Request      // DELETE /order/_doc/{id}
    DeleteRequest request = new DeleteRequest("order", "101");
    // 2.发送请求
    client.delete(request, RequestOptions.DEFAULT);
}

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);
}

五.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 全文检索(full text)查询

  • match查询,查询字段name中包含5G的文档
GET /order/_search
{
  "query":{
    "match": {
      "name": "5G"
    }
  }
}
  • multi_match查询,返回字段name或者user.address.keyword包含天津市的文档
GET /order/_search
{
  "query":{
    "multi_match": {
      "query": "天津市",
      "fields": ["user.address.keyword","name"]
   }
  }
}

1.3 精确查询

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

  • term:根据词条精确值查询,不会分词
    查询价格字段为359900的文档,多一块少一块都查不到
GET /order/_search
{
  "query":{
    "term": {
      "price": {
        "value": "359900"
      }
    }
  }
}
  • range:根据值的范围查询,比如日期,数字
    查询字段价格在0-1000000的文档
GET /order/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 0,
        "lte": 10000000
      }
    }
  }
}

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.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"
    }
  ]
}

2.2 分页

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

GET /order/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0, //分页的开始,默认为0
  "size":13, //每页的文档数
  "sort":[
    {
      "price":"asc"
    }
  ]
}

from+size原理:如果要查询第990-1000条文档,则先查询前1000条,再截取990-1000条文档。
Elasticsearch快速入门_第13张图片
但在实际环境中ES是集群部署的,数据分布在不同的ES服务器中,如果查询页数太深,对内存要求会很高。
Elasticsearch快速入门_第14张图片

首先在每个数据分片上都排序并查询前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"
      }
    }
  }
}
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);
   }
}

3.2 全文检索(full text)查询

  • match查询
    只需要修改3.1的DSL语句
// 2.准备DSL     
request.source().query(QueryBuilders.matchQuery("name","Apple"));
  • multi_match查询
// 2.准备DSL
request.source().query(QueryBuilders.multiMatchQuery("Apple","name","price"));

3.3 精确查询

  • term 慎用,在Java API 有时会失效
request.source().query(QueryBuilders.termQuery("price","6999"));
  • range
request.source().query(QueryBuilders.rangeQuery("price").gte(100).lte(150));

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);
4.RestClient处理搜索结果

4.1 分页、排序

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

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.聚合的分类

聚合(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个
      }
    }
  }
}

Elasticsearch快速入门_第15张图片

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

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

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

GET /order/_search
{
  "query": {
    "term": {
      "num": 1
    }
  }, 
  "size": 0, 
  "aggs": {
    "userCount": {
      "terms": {
        "field": "userId",
        "size": 5
      }
    }
  }
}

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"  //聚合字段
          }
        }
      }
    }
  }
}

Elasticsearch快速入门_第16张图片

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);
    }
}

图解请求:
Elasticsearch快速入门_第17张图片
解析聚合结果:
Elasticsearch快速入门_第18张图片
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);
    }
}

Elasticsearch快速入门_第19张图片
Elasticsearch快速入门_第20张图片

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.安装拼音分词器

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

②将解压文件上传到目录/var/lib/docker/volumes/es-plugins/_data
在这里插入图片描述
③重启es容器
④测试
Elasticsearch快速入门_第21张图片

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"
      }
    }
  }
}
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"
      }
      }
    }
}

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

Elasticsearch快速入门_第22张图片
创建好索引库,插入文档即可
Elasticsearch快速入门_第23张图片

GET /order/_search
{
  "suggest": {
    "my_suggestions": {
      "text": "b",
      "completion": {
        "field": "suggestion",
        "skip_duplicates": true, // 跳过重复的
        "size":10
      }
    }
  }
}

Elasticsearch快速入门_第24张图片

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);
    }

}

Elasticsearch快速入门_第25张图片
Elasticsearch快速入门_第26张图片

八.数据同步

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

  • 引入依赖

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-amqpartifactId>
dependency>
  • 配置yml配置文件
spring:
  rabbitmq:
    host: 192.168.10.129
    port: 5672
    username: itcast
    password: 123321
    virtual-host: /
  • 定义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";

}
  • 使用配置文件方式声明交换机和队列
@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);
    }
}
  • 在增删改的同时向相应的队列发送消息
@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);
    }
}
  • 创建一个消息监听类,实现对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);
    }
}

九.ES集群

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

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

  • 首先对数据分片,存储到不同节点
  • 然后对每个分片进行备份,放到对方节点,完成互相备份
    Elasticsearch快速入门_第27张图片
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

否则部署的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
  • 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

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

2.集群状态监控

利用cerebro进行监控

  • 拉取镜像
 docker pull lmenezes/cerebro
  • 运行容器
docker run -d --name cerebro -p 9100:9000 lmenezes/cerebro
  • 访问IP:9100
    Elasticsearch快速入门_第28张图片
  • 输入 http://192.168.10.129:9200 (任意节点服务器即可),可以看到刚才部署的es集群的3个节点信息
    Elasticsearch快速入门_第29张图片
3.脑裂及解决

脑裂是因为集群中的节点失联导致的
例如一个集群中,主节点与其它节点失联
Elasticsearch快速入门_第30张图片
此时,node2和node3认为node1宕机,就会重新选主
Elasticsearch快速入门_第31张图片
当node3当选后,集群继续对外提供服务,node2和node3自成集群,node1自成集群,两个集群数据不同步,出现数据差异

当网络恢复后,因为集群中有两个master节点,集群状态的不一致,出现脑裂的情况
Elasticsearch快速入门_第32张图片
解决脑裂的方案是,要求选票超过 ( eligible节点数量 + 1 )/ 2 才能当选为主,因此eligible节点数量最好是奇数。对应配置项是discovery.zen.minimum_master_nodes,在es7.0以后,已经成为默认配置,因此一般不会发生脑裂问题

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

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

  • 查询流程:
    Elasticsearch快速入门_第34张图片
    协调节点会把请求分发到每一个分片,称为分散阶段。协调节点汇总data node的结果,称为聚集阶段,并处理结果集返回给用户

5.故障转移

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

Elasticsearch快速入门_第35张图片
Elasticsearch快速入门_第36张图片
Elasticsearch快速入门_第37张图片
以上es会自动完成故障转移操作,特别注意的是,如果宕机的节点又恢复正常了,则当前的主节点会把相应的分片再分发回去,十分强大!

十.小结

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

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

你可能感兴趣的:(微服务,elasticsearch)