黑马-Cloud21版-实用篇05：分布式搜索引擎03：数据聚合，自动补全，数据同步，集群

分布式搜索引擎03

0.学习目标

1.数据聚合

聚合（aggregations） 可以让我们极其方便的实现对数据的统计、分析、运算。例如：

• 什么品牌的手机最受欢迎？
• 这些手机的平均价格、最高价格、最低价格？
• 这些手机每月的销售情况如何？

实现这些统计功能的比数据库的sql要方便的多，而且查询速度非常快，可以实现近实时搜索效果。

1.1.聚合的种类

聚合常见的有三类：

• 桶（Bucket）聚合：用来对文档做分组

  • TermAggregation：按照文档字段值分组，例如按照品牌值分组、按照国家分组
  • Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组

• 度量（Metric）聚合：用以计算一些值，比如：最大值、最小值、平均值等

  • Avg：求平均值
  • Max：求最大值
  • Min：求最小值
  • Stats：同时求max、min、avg、sum等

• 管道（pipeline）聚合：其它聚合的结果为基础做聚合

注意：参加聚合的字段必须是keyword、日期、数值、布尔类型
原因：针对字符串的聚合，不能分词，分词后有好几个字段，没法分组，所以不能用text类型的数据聚合

1.2.DSL实现聚合

现在，我们要统计所有数据中的酒店品牌有几种，其实就是按照品牌对数据分组。此时可以根据酒店品牌的名称做聚合，也就是Bucket聚合。

1.2.1.Bucket聚合语法

语法如下：

GET /hotel/_search
{
  "size": 0,  // 设置size为0，结果中不包含文档，只包含聚合结果
  "aggs": { // 定义聚合，里面可以定义多个聚合
    "brandAgg": { //给聚合起个名字
      "terms": { // 聚合的类型，按照品牌值聚合，所以选择term
        "field": "brand", // 参与聚合的字段
        "size": 20 // 希望获取的聚合结果数量
      }
    }
  }
}

结果如图：

1.2.2.聚合结果排序

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

我们可以指定order属性，自定义聚合的排序方式：

GET /hotel/_search
{
  "size": 0, 
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "order": {
          "_count": "asc" // 按照_count升序排列
        },
        "size": 20
      }
    }
  }
}

1.2.3.限定聚合范围

默认情况下，Bucket聚合是对索引库的所有文档做聚合，但真实场景下，用户会输入搜索条件，因此聚合必须是对搜索结果聚合。那么聚合必须添加限定条件。

我们可以限定要聚合的文档范围，只要添加query条件即可：

GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "lte": 200 // 只对200元以下的文档聚合
      }
    }
  }, 
  "size": 0, 
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20
      }
    }
  }
}

这次，聚合得到的品牌明显变少了：

1.2.4.Metric聚合语法

上节课，我们对酒店按照品牌分组，形成了一个个桶。现在我们需要对桶内的酒店做运算，获取每个品牌的用户评分的min、max、avg等值。

这就要用到Metric聚合了，例如stat聚合：就可以获取min、max、avg等结果。

语法如下：

GET /hotel/_search
{
  "size": 0, 
  "aggs": {
    "brandAgg": { 
      "terms": { 
        "field": "brand", 
        "size": 20
      },
      "aggs": { // 是brands聚合的子聚合，也就是分组后对每组分别计算
        "score_stats": { // 聚合名称
          "stats": { // 聚合类型，这里stats可以计算min、max、avg等
            "field": "score" // 聚合字段，这里是score
          }
        }
      }
    }
  }
}

这次的score_stats聚合是在brandAgg的聚合内部嵌套的子聚合。因为我们需要在每个桶分别计算。

另外，我们还可以给聚合结果做个排序，例如按照每个桶的酒店平均分做排序：

1.2.5.小结

aggs代表聚合，与query同级，此时query的作用是？

• 限定聚合的的文档范围

聚合必须的三要素：

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

聚合可配置属性有：

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

1.3.RestAPI实现聚合

1.3.1.API语法

聚合条件与query条件同级别，因此需要使用request.source()来指定聚合条件。

聚合条件的语法：

聚合的结果也与查询结果不同，API也比较特殊。不过同样是JSON逐层解析：

单元测试：

    @Test
    void testAggregation() throws IOException {
        //1.准备Request
        SearchRequest request = new SearchRequest("hotelssss");
        //2.准备DSL
        //2.1设置size
        request.source().size(0);
        //2.2聚合
        request.source().aggregation(AggregationBuilders
                .terms("brandAgg")
                .field("brand")
                .size(20));

        //3.发出请求
        SearchResponse response = client.search(request,RequestOptions.DEFAULT);
        //4.解析结果
        Aggregations aggregations = response.getAggregations();
        //4.1根据聚合名称获取聚合结果(因为聚合的类型是Terms类型，所以它的返回类型也是Terms类型)
        Terms brandTerms = aggregations.get("brandAgg");
        //4.2获取buckets
        List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
        //4.3遍历
        for (Terms.Bucket bucket : buckets) {
            //4.4获取key
            String key = bucket.getKeyAsString();//是字符串就用字符串，是数字就用数字类型的方法去获取
            System.out.println(key);

        }
    }

1.3.2. 案例测试

1）业务需求

需求：搜索页面的品牌、城市等信息不应该是在页面写死，而是通过聚合索引库中的酒店数据得来的：

分析：

目前，页面的城市列表、星级列表、品牌列表都是写死的，并不会随着搜索结果的变化而变化。但是用户搜索条件改变时，搜索结果会跟着变化。

例如：用户搜索“东方明珠”，那搜索的酒店肯定是在上海东方明珠附近，因此，城市只能是上海，此时城市列表中就不应该显示北京、深圳、杭州这些信息了。

也就是说，搜索结果中包含哪些城市，页面就应该列出哪些城市；搜索结果中包含哪些品牌，页面就应该列出哪些品牌。

如何得知搜索结果中包含哪些品牌？如何得知搜索结果中包含哪些城市？

使用聚合功能，利用Bucket聚合，对搜索结果中的文档基于品牌分组、基于城市分组，就能得知包含哪些品牌、哪些城市了。

返回值类型就是页面要展示的最终结果：

结果是一个Map结构：

• key是字符串，城市、星级、品牌、价格
• value是集合，例如多个城市的名称

2）业务实现-多条件聚合

在cn.itcast.hotel.service.IHotelService中定义新方法：

Map<String, List<String>> filters();

在cn.itcast.hotel.service.impl.HotelService中实现该方法：

    @Override
    public Map<String, List<String>> filters()  {
        try {
            //1.准备Request
            SearchRequest request = new SearchRequest("hotelssss");
            //2.准备DSL
            //2.1设置size
            request.source().size(0);
            //2.2聚合
            buildBasicQuery(request);

            //3.发出请求
            SearchResponse response = client.search(request,RequestOptions.DEFAULT);
            //4.解析结果
            Map<String, List<String>> result = new HashMap<>();
            Aggregations aggregations = response.getAggregations();
            // 4.1.根据品牌名称，获取品牌结果
            List<String> brandList = getAggByName(aggregations, "brandAgg");
            result.put("品牌",brandList);//放入map
            // 4.2.根据城市名称，获取城市结果
            List<String> cityList = getAggByName(aggregations, "cityAgg");
            result.put("城市", cityList);
            // 4.3.根据星级名称，获取星级结果
            List<String> starList = getAggByName(aggregations, "starAgg");
            result.put("星级", starList);

            return result;
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }



    //抽取聚合条件的构建
    private void buildBasicQuery(SearchRequest request) {
        request.source().aggregation(AggregationBuilders
                .terms("brandAgg")   //品牌
                .field("brand")
                .size(100));
        request.source().aggregation(AggregationBuilders
                .terms("cityAgg")  //城市
                .field("city")
                .size(100)
        );
        request.source().aggregation(AggregationBuilders
                .terms("starAgg")  //星级
                .field("starName")
                .size(100)
        );
    }

    //抽取解析过程的代码，获得聚合的结果
    private List<String> getAggByName(Aggregations aggregations,String aggName) {
        //根据聚合名称获取聚合结果(因为聚合的类型是Terms类型，所以它的返回类型也是Terms类型)
        Terms brandTerms = aggregations.get(aggName);
        //获取buckets
        List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
        //遍历
        List<String> brandList = new ArrayList<>();
        for (Terms.Bucket bucket : buckets) {
            //获取key
            String key = bucket.getKeyAsString();//是字符串就用字符串，是数字就用数字类型的方法去获取
            brandList.add(key);

        }
        return brandList;
    }

单元测试：

3）业务实现-对接前端接口（带过滤条件的聚合）

点击页面的搜索按钮发现，此时前端会发生2个请求：

• 查询酒店数据
  
  

• 查询酒店过滤项：前端页面会向服务端发起请求，查询品牌、城市、星级等字段的聚合结果
  
  

可以看到2个请求除了请求路径不同，他们的请求参数一模一样。

问题：那为什么我在查询过滤项的时候也要带过滤条件呢？？？过滤项查询是通过聚合来实现，聚合一旦加了条件是在限定聚合的范围，那为什么要限定聚合的范围呢，直接对整个索引库聚合不行吗？

• 如果搜索时没有加任何条件 搜索到的是索引库的所有数据，这个时候对索引库的所有数据去做聚合，得到城市和品牌没有问题。
• 如果搜索时带了查询条件 比如虹桥，那我得到的结果一定是跟上海虹桥火车站有关的结果，它对应的城市一定是上海，但是你却对索引库的所有数据去做聚合，你得到的城市一定包含所有城市，这个时候用户就很奇怪了， 我搜的是虹桥明明是上海的怎么还出现北京了呢。

解决：你不应该多索引库的所有数据聚合，用户的条件是虹桥，那么你就应该对虹桥相关的酒店去做聚合，也就是要限定聚合的范围，即加上查询条件，在查询酒店用的什么条件你在聚合时也用的什么样的查询条件，这样就是在酒店结果的基础上做聚合了，这样聚合的结果就更准确了。因此在查询酒店数据和查询酒店过滤项时要用到相同的查询条件。

例如：用户搜索“外滩”，价格在300~600，那聚合必须是在这个搜索条件基础上完成。

因此我们需要：

1. 编写controller接口，接收该请求
2. 修改IUserService#getFilters()方法，添加RequestParam参数
3. 修改getFilters方法的业务，聚合时添加query条件

在cn.itcast.hotel.web包的HotelController中添加一个方法，遵循下面的要求：

• 请求方式：POST
• 请求路径：/hotel/filters
• 请求参数：RequestParams，与搜索文档的参数一致
• 返回值类型：Map<String, List<String>>

代码：

    @PostMapping("filters")
    public Map<String, List<String>> getFilters(@RequestBody RequestParams params){
        return hotelService.getFilters(params);
    }

修改业务层接口：

修改实现类：

	@Override
    public Map<String, List<String>> filters(RequestParams params)  {
        try {
            //1.准备Request
            SearchRequest request = new SearchRequest("hotelssss");
            //2.准备DSL
            // 2.1.query
            buildBasicQuery(params, request);
            //2.2设置size
            request.source().size(0);
            //2.3聚合
            buildBasicQuery(request);

            //3.发出请求
            SearchResponse response = client.search(request,RequestOptions.DEFAULT);
            //4.解析结果
            Map<String, List<String>> result = new HashMap<>();
            Aggregations aggregations = response.getAggregations();
            // 4.1.根据品牌名称，获取品牌结果
            List<String> brandList = getAggByName(aggregations, "brandAgg");
            result.put("brand",brandList);//放入map
            // 4.2.根据城市名称，获取城市结果
            List<String> cityList = getAggByName(aggregations, "cityAgg");
            result.put("city", cityList);
            // 4.3.根据星级名称，获取星级结果
            List<String> starList = getAggByName(aggregations, "starAgg");
            result.put("starName", starList);

            return result;
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }


    //抽取封装多个查询条件的代码
    private void buildBasicQuery(RequestParams params, SearchRequest request) {
        // 1.构建BooleanQuery
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        // 1.1关键字搜索
        String key = params.getKey();
        // 健壮性判断：如果key为空，代表没有查询条件，则使用matchAllQuery 查询所有
        if (key == null || "".equals(key)) {
            boolQuery.must(QueryBuilders.matchAllQuery());
        } else { //有条件，在做全文检索的单个字段
            boolQuery.must(QueryBuilders.matchQuery("all",key));
        }
        // 1.2城市条件
        if (params.getCity() != null && !params.getCity().equals("")) {
            boolQuery.filter(QueryBuilders.termQuery("city", params.getCity()));
        }
        // 1.3品牌条件
        if (params.getBrand() != null && !params.getBrand().equals("")) {
            boolQuery.filter(QueryBuilders.termQuery("brand", params.getBrand()));
        }
        // 1.4星级条件
        if (params.getStarName() != null && !params.getStarName().equals("")) {
            boolQuery.filter(QueryBuilders.termQuery("starName", params.getStarName()));
        }
        // 1.5价格
        if (params.getMinPrice() != null && params.getMaxPrice() != null) {
            boolQuery.filter(QueryBuilders
                    .rangeQuery("price")
                    .gte(params.getMinPrice())
                    .lte(params.getMaxPrice())
            );
        }

        //2.算分控制
        FunctionScoreQueryBuilder functionScoreQuery =
                QueryBuilders.functionScoreQuery(
                        // 原始查询，相关性算分的查询
                        boolQuery,
                        // function score的数组（因为是内部类，所以需要点的方式创建）
                        new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{
                                // 其中的一个function score 元素
                                new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                                        // 过滤条件（布尔类型使用term查询）
                                        QueryBuilders.termQuery("isAD", true),
                                        // 算分函数
                                        ScoreFunctionBuilders.weightFactorFunction(10)
                                )
                        });

        // 3.放入source
        request.source().query(functionScoreQuery);
    }
    



    //抽取聚合条件的构建
    private void buildBasicQuery(SearchRequest request) {
        request.source().aggregation(AggregationBuilders
                .terms("brandAgg")   //品牌
                .field("brand")
                .size(100));
        request.source().aggregation(AggregationBuilders
                .terms("cityAgg")  //城市
                .field("city")
                .size(100)
        );
        request.source().aggregation(AggregationBuilders
                .terms("starAgg")  //星级
                .field("starName")
                .size(100)
        );
    }

    //抽取解析过程的代码，获得聚合的结果
    private List<String> getAggByName(Aggregations aggregations,String aggName) {
        //根据聚合名称获取聚合结果(因为聚合的类型是Terms类型，所以它的返回类型也是Terms类型)
        Terms brandTerms = aggregations.get(aggName);
        //获取buckets
        List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
        //遍历
        List<String> brandList = new ArrayList<>();
        for (Terms.Bucket bucket : buckets) {
            //获取key
            String key = bucket.getKeyAsString();//是字符串就用字符串，是数字就用数字类型的方法去获取
            brandList.add(key);

        }
        return brandList;
    }

测试：可以看到根据搜索条件动态的显示过滤项

2.自动补全

当用户在搜索框输入字符时，我们应该提示出与该字符有关的搜索项，如图：

这种根据用户输入的字母，提示完整词条的功能，就是自动补全了。

因为需要根据拼音字母来推断，因此要用到拼音分词功能。

2.1.拼音分词器

要实现根据字母做补全，就必须对文档按照拼音分词。在GitHub上恰好有elasticsearch的拼音分词插件。地址：https://github.com/medcl/elasticsearch-analysis-pinyin

课前资料中也提供了拼音分词器的安装包：

安装方式与IK分词器一样，分三步：详细安装步骤可以参考IK分词器的安装过程。

​ ①解压

​ ②上传到虚拟机中，elasticsearch的plugin目录

​ ③重启elasticsearch

​ ④测试

测试用法如下：

POST /_analyze  #请求路径
{
  "text": "如家酒店还不错", #要分词的内容
  "analyzer": "pinyin"   #分词器类型：拼音分词器
}

结果：

2.2.自定义分词器

2.2.1 为什么要自定义分词器

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

默认的拼音分词器存在的问题：

• 不会分词： “如家酒店还不错” 的全拼首字母放在一块了，说明这句话没有被分词而是作为整体出现了。
  
• 每个字都分词：“如家酒店还不错” 的每一个字都形成了拼音，这没什么用还不如形成全品呢，比如 rujia。
  
• 没有汉字只剩拼音：大部分用的还是使用中文搜索而不是拼音搜索，有拼音只是锦上添花但你不能把汉字扔了。
  

2.2.2 分词器的构成

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

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

文档分词时会依次由这三部分来处理文档：

上图是如何解决拼音分词器不会分词的：

• 先交给ik分词器进行分词，再交给拼音分词器作为过滤处理形成拼音。

2.2.3 自定义分词器语法

我们可以在创建索引库时，通过settings来配置自定义的analyzer（分词器）：

说明：由于是在创建索引库的时候指定配置，所以这个配置只对当前索引库有效。

说明：

• 这里只定义了 tokenizer、tokenizer filter，没有定义character filters（对特殊字符处理），因为这里的词条没有包含特殊字符。所以不一定3个都要有，可以是只包含其中的一部分。
• 先经过ik分词器进行分词，在将分好的词交给拼音分词器进一步的处理，这样就解决了拼音分词器不能分词的问题。

PUT /test
{
  "settings": { //索引库配置
    "analysis": { //分析
      "analyzer": { // 自定义分词器
        "my_analyzer": {  // 分词器名称
          "tokenizer": "ik_max_word", //tokenizer：先经过分词器进行分词（ik分词器，细粒度的分词）
          "filter": "pinyin"    //tokenizer filter：在将分词的词条进一步的处理（使用拼音分词器进一步的分词）
        }
      }
     }
   }
}

那么剩下的2个问题（1.它会把分好的词语转化为拼音的时候，是一个字一个字的转化为拼音。2.会把中文去掉）--------解决：对拼音分词器做进一 步的定制（通过可选参数控制拼音分词器的一个效果）。

PUT /test
{
  "settings": { //索引库配置
    "analysis": { //分析
      "analyzer": { // 自定义分词器
        "my_analyzer": {  // 分词器名称
          "tokenizer": "ik_max_word", //tokenizer：先经过分词器进行分词（ik分词器，细粒度的分词）
          "filter": "py"    //tokenizer filter：在将分词的词条进一步的处理
        }
      },
      "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
        }
      }
    }
  },
  //上面分词器定义好了肯定是要用的，那么如何用呢？？？
  //肯定是在定义mapping映射的时候使用（定义索引库字段的时候用）
  "mappings": {
    "properties": {
      "name": {
        "type": "text",  //字段数据类型
        "analyzer": "my_analyzer", //使用自定义的分词器
      }
    }
  }
}

• “type”: “pinyin”：指定使用拼音过滤器进行拼音转换。
• “keep_full_pinyin”: false：表示不保留完整的拼音。如果设置为true，则会将完整的拼音保留下来。
• “keep_joined_full_pinyin”: true：表示保留连接的完整拼音。当设置为true时，如果某个词的拼音有多个音节，那么它们将被连接在一起作为一个完整的拼音。
• “keep_original”: true：表示保留原始词汇。当设置为true时，原始的中文词汇也会保留在分词结果中。
• “limit_first_letter_length”: 16：限制拼音首字母的长度。默认为16，即只保留拼音首字母的前16个字符。
• “remove_duplicated_term”: true：表示移除重复的拼音词汇。如果设置为true，则会移除拼音结果中的重复词汇。
• “none_chinese_pinyin_tokenize”: false：表示是否对非中文文本进行拼音分词处理。当设置为false时，非中文文本将保留原样，不进行拼音分词处理

测试：

//使用自定义的分词器进行分词
//注意：上述的settings配置只对当前索引库有效，所以这里需要指定使用的是哪个索引库
POST /test/_analyze
{
  "text": "如家酒店还不错",
  "analyzer": "my_analyzer"
}

从上图中可以看出：

1.不光有拼音，还有中文分词.

2.还有中文分词后的英文全拼，以及分词首字母.

2.2.4 面临的问题和解决办法

准备数据：

//插入2条文档
POST /test/_doc/1
{
  "id": 1,
  "name": "狮子"
}
POST /test/_doc/2
{
  "id": 2,
  "name": "虱子"
}

//全文检索的单个字段查询
GET /test/_search
{
  "query": {
    "match": {
      "name": "掉入狮子笼咋办"
    }
  }
}

测试：

• 使用拼音搜索：搜到2个完全正确
  

• 使用中文汉字搜索：明明搜的是狮子，为什么虱子也能搜索到呢？？？
  

原因：拼音分词器适合在创建倒排索引的时候使用，但不能在搜索的时候使用。

• 创建倒排索引时：插入狮子文档 按照分词方式会分为狮子、shizi、SZ，然后创建倒排索引形成文词条和文档编号。插入的是虱子文档时按词条会分为虱子、shizi、SZ，除了中文以外剩下的拼音都一样，所以在创建倒排索引时虱子会形成一个单独的词条，剩下的2个已经存在了它只会记录新的文档id，这样会导致这2个文档的拼音是一样的。
• 搜索时，用户搜索“狮子”：搜索时也用的是拼音分词器，中文狮子也被分成了拼音shizi，这样就搜索出来了是2个文档
• 因此创建倒排索引时使用拼音分词器没有问题，但你在搜索的时候不应该用拼音分词器，搜索的时候用户如果输入的是中文，你就应该使用中文去搜，用户输入的是拼音 你才能拿拼音去搜，所以创建和搜索时我们应该使用不同的分词器。

解决：

因此字段在创建倒排索引时应该用my_analyzer分词器；字段在搜索时应该使用ik_smart分词器;

PUT /test
{
  "settings": {
    "analysis": {
      "analyzer": { 
        "my_analyzer": { 
          "tokenizer": "ik_max_word",
          "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": {
      "name": {
        "type": "text",
        "analyzer": "my_analyzer", //创建倒排索引使用 my_analyzer 分词器.
        "search_analyzer": "ik_smart"  //搜索时使用 ik_smart 分词器.
      }
    }
  }
}

测试：把之前的test索引库删除后，在修改创建索引库的语法，之后重新插入数据查询，发现现在正确只显示狮子。

2.2.5 总结：

如何使用拼音分词器？

• ①下载pinyin分词器

• ②解压并放到elasticsearch的plugin目录

• ③重启即可

如何自定义分词器？

• ①创建索引库时，在settings中配置，可以包含三部分

• ②character filter

• ③tokenizer

• ④filter

拼音分词器注意事项？

• 为了避免搜索到同音字，搜索时不要使用拼音分词器

2.3.自动补全查询

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

• 参与补全查询的字段必须是completion类型（专门用来做自动补全查询的）。
  

• 字段的内容一般是用来补全的多个词条形成的数组。[“Sony”, “WH-1000XM3”]

  • 例如第一条数据，如果是一个词条"SonyWH-1000XM3"，将来在做自动补全时只能使用s来补全， 用户输入w的时候是不可能补全出产品名称的。如果分为2个词[“Sony”, “WH-1000XM3”]，用户输入s时可以补全Sony，用户输入w时可以补全产品名称，更加人性化。
  • 即：尽量把词语分成一个个的词条放到数组当中
    

比如，一个这样的索引库：

// 创建索引库
PUT test
{
  "mappings": {
    "properties": {
      "title":{
        "type": "completion"
      }
    }
  }
}

然后插入下面的数据：

// 示例数据
POST test/_doc
{
  "title": ["Sony", "WH-1000XM3"]
}
POST test/_doc
{
  "title": ["SK-II", "PITERA"]
}
POST test/_doc
{
  "title": ["Nintendo", "switch"]
}

查询的DSL语句如下：

// 自动补全查询
GET /test/_search
{
  "suggest": { //自动补全
    "title_suggest": { //自动补全的查询名称
      "text": "s", // 用户在搜索框中输入的关键字，可以理解为前缀
      "completion": {//自动补全的类型（有3种，这里使用的是其中的1种）
        "field": "title", //这里的字段名指向的是一个数组（字段必须是 completion 类型），就是要根据数组中的字段进行查询，然后自动补全
        "skip_duplicates": true, //如果查询时有重复的词条，是否自动跳过(true 为跳过)
        "size": 10 // 获取前10条结果
      }
    }
  }
}

2.4.实现酒店搜索框自动补全

现在，我们的hotel索引库还没有设置拼音分词器，需要修改索引库中的配置。但是我们知道索引库是无法修改的，只能删除然后重新创建。

另外，我们需要添加一个字段，用来做自动补全，将brand、suggestion、city等都放进去，作为自动补全的提示。

因此，总结一下，我们需要做的事情包括：

1. 修改hotel索引库结构，设置自定义拼音分词器

2. 修改索引库的name、all字段，使用自定义分词器

3. 索引库添加一个新字段suggestion，类型为completion类型，使用自定义的分词器

4. 给HotelDoc类添加suggestion字段，内容包含brand、business

5. 重新导入数据到hotel库

2.4.1.修改酒店映射结构

代码如下：

// 酒店数据索引库
PUT /hotel
{
  "settings": {
    "analysis": {
      "analyzer": {
        "text_anlyzer": {//做全文检索用的
          "tokenizer": "ik_max_word",
          "filter": "py"
        },
        "completion_analyzer": {//做自动补全用的
        //keyword：不分词，也就是说它的词条直接作为一个整体，因为我们将来在做自动补全的时候，肯定是固定的一个个的
        //  词条，我们会把这些词条放到数组当中，它本身就是一个词条因此没必要再分词了
          "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",//创建倒排索引使用 text_anlyze 自定义分词器
        "search_analyzer": "ik_smart",//搜索时使用 ik_smart 分词器
        "copy_to": "all"
      },
      "address":{
        "type": "keyword",
        "index": false
      },
      "price":{
        "type": "integer"
      },
      "score":{
        "type": "integer"
      },
      "brand":{
        "type": "keyword",
        "copy_to": "all"
      },
      "city":{
        "type": "keyword"
      },
      "starName":{
        "type": "keyword"
      },
      "business":{
        "type": "keyword",
        "copy_to": "all"
      },
      "location":{
        "type": "geo_point"
      },
      "pic":{
        "type": "keyword",
        "index": false
      },
      "all":{
        "type": "text",
        "analyzer": "text_anlyzer",//创建倒排索引使用 text_anlyze 自定义分词器
        "search_analyzer": "ik_smart"//搜索时使用 ik_smart 分词器
      },
      "suggestion":{//做自动补全的字段
          "type": "completion", //做自动补全所需的类型
          "analyzer": "completion_analyzer"//使用自定义的分词器completion_analyzer：不分词直接转拼音
      }
    }
  }
}

2.4.2.修改HotelDoc实体

HotelDoc中要添加一个字段，用来做自动补全，内容可以是酒店品牌、城市、商圈等信息。按照自动补全字段的要求，最好是这些字段的数组。

因此我们在HotelDoc中添加一个suggestion字段，类型为List<String>，然后将brand、city、business等信息放到里面。

代码如下：

package cn.itcast.hotel.pojo;

import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Arrays;
import java.util.List;

@Data
@NoArgsConstructor
public class HotelDoc {
    private Long id;
    private String name;
    private String address;
    private Integer price;
    private Integer score;
    private String brand;
    private String city;
    private String starName;
    private String business;
    private String location;
    private String pic;
    // 排序时的 距离值
    private Object distance;
    //广告标记
    private Boolean isAD;
    //自动补全
    private List<String> suggestion;

    public HotelDoc(Hotel hotel) {
        this.id = hotel.getId();
        this.name = hotel.getName();
        this.address = hotel.getAddress();
        this.price = hotel.getPrice();
        this.score = hotel.getScore();
        this.brand = hotel.getBrand();
        this.city = hotel.getCity();
        this.starName = hotel.getStarName();
        this.business = hotel.getBusiness();
        this.location = hotel.getLatitude() + ", " + hotel.getLongitude();
        this.pic = hotel.getPic();
        //组装suggestion
        this.suggestion = Arrays.asList(this.brand,this.business);
    }
}

2.4.3.重新导入

重新执行之前编写的导入数据功能，可以看到新的酒店数据中包含了suggestion：

问题：像这样中间以/或者、分隔的商圈信息，这样将来只能根据第一个词的首字母g来提示，而不能使用w来提示。

解决：应该把商圈数据拆分为2个词条作为数组中的元素，而不是像现在这样拼成一个字符串。

修改HotelDoc 代码：

package cn.itcast.hotel.pojo;

import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

@Data
@NoArgsConstructor
public class HotelDoc {
    private Long id;
    private String name;
    private String address;
    private Integer price;
    private Integer score;
    private String brand;
    private String city;
    private String starName;
    private String business;
    private String location;
    private String pic;
    private Object distance;
    private Boolean isAD;
    private List<String> suggestion;

    public HotelDoc(Hotel hotel) {
        this.id = hotel.getId();
        this.name = hotel.getName();
        this.address = hotel.getAddress();
        this.price = hotel.getPrice();
        this.score = hotel.getScore();
        this.brand = hotel.getBrand();
        this.city = hotel.getCity();
        this.starName = hotel.getStarName();
        this.business = hotel.getBusiness();
        this.location = hotel.getLatitude() + ", " + hotel.getLongitude();
        this.pic = hotel.getPic();
        // 组装suggestion
        if(this.business.contains("/")){
            // business有多个值，需要切割
            String[] arr = this.business.split("/");
            // 添加元素
            this.suggestion = new ArrayList<>();
            this.suggestion.add(this.brand);
            Collections.addAll(this.suggestion, arr);
        }else {
            this.suggestion = Arrays.asList(this.brand, this.business);
        }
    }
}

重新运行批量导入的单元测试方法，再次查询：发现之前的商圈信息分为3个词条了

测试自动补全功能：

2.4.4.自动补全查询的JavaAPI

之前我们学习了自动补全查询的DSL，而没有学习对应的JavaAPI，这里给出一个示例：

而自动补全的结果也比较特殊，解析的代码如下：

单元测试：

    @Test
    void testSuggest() throws IOException {
        //1.准备Request
        SearchRequest request = new SearchRequest("hotel");
        //2.准备DSL
        request.source().suggest(new SuggestBuilder().addSuggestion(
                "suggestions",
                SuggestBuilders.completionSuggestion("suggestion")
                        .prefix("h")
                        .skipDuplicates(true)
                        .size(10)
        ));
        //3.发起请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.解析结果
        Suggest suggest = response.getSuggest();
        //4.1根据补全查询名称，获取补全结果
        CompletionSuggestion suggestions = suggest.getSuggestion("suggestions");
        //4.2获取options
        List<CompletionSuggestion.Entry.Option> options = suggestions.getOptions();
        //4.3遍历
        for(CompletionSuggestion.Entry.Option Option : options){
            String text = Option.getText().toString();
            System.out.println(text);
        }
    }

2.4.5.实现搜索框自动补全

查看前端页面，可以发现当我们在输入框键入时，前端会发起ajax请求：

返回值是补全词条的集合，类型为List<String>

1）在cn.itcast.hotel.web包下的HotelController中添加新接口，接收新的请求：

@GetMapping("suggestion")
public List<String> getSuggestions(@RequestParam("key") String prefix) {
    return hotelService.getSuggestions(prefix);
}

2）在cn.itcast.hotel.service包下的IhotelService中添加方法：

List<String> getSuggestions(String prefix);

3）在cn.itcast.hotel.service.impl.HotelService中实现该方法：

@Override
public List<String> getSuggestions(String prefix) {
    try {
        // 1.准备Request
        SearchRequest request = new SearchRequest("hotel");
        // 2.准备DSL
        request.source().suggest(new SuggestBuilder().addSuggestion(
            "suggestions",
            SuggestBuilders.completionSuggestion("suggestion")
            .prefix(prefix)
            .skipDuplicates(true)
            .size(10)
        ));
        // 3.发起请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 4.解析结果
        Suggest suggest = response.getSuggest();
        // 4.1.根据补全查询名称，获取补全结果
        CompletionSuggestion suggestions = suggest.getSuggestion("suggestions");
        // 4.2.获取options
        List<CompletionSuggestion.Entry.Option> options = suggestions.getOptions();
        // 4.3.遍历
        List<String> list = new ArrayList<>(options.size());
        for (CompletionSuggestion.Entry.Option option : options) {
            String text = option.getText().toString();
            list.add(text);
        }
        return list;
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

测试：

3.数据同步

elasticsearch中的酒店数据来自于mysql数据库，因此mysql数据发生改变时，elasticsearch也必须跟着改变，这个就是elasticsearch与mysql之间的数据同步。

3.1.思路分析

常见的数据同步方案有三种：

• 同步调用
• 异步通知
• 监听binlog

3.1.1.同步调用

方案一：同步调用

基本步骤如下：

• hotel-demo对外提供接口，用来修改elasticsearch中的数据
• 酒店管理服务在完成数据库操作后，直接调用hotel-demo提供的接口，

说明：

• 场景：假设现在有2个微服务admin、demo，2个服务之间不能互相不能访问对方的数据库，admin只能访问mysql，demo只能访问es
• 步骤：当有人做新增 删除 修改业务时，首先把业务写到数据库里，之后调用对外暴露的更新es的接口，demo服务自己去更新es。
• 由原来的一步（admin服务写入数据库）变为现在的三步（写入数据库、调接口、demo服务更新es），由于是同步调用所以这3个步骤是依次执行。

缺点：

• 数据耦合：原来是写入到数据库中就结束了，现在写入完数据库后还要加上调用demo服务的代码，并且这个调用demo服务的业务跟我们新增的业务没有关系，硬把这两个不相干的业务耦合在一块了，业务耦合必然影响性能。
  • 业务耦合必然影响性能：原先写入到数据库就结束了耗时50毫秒，现在还要调用接口（50毫秒）、demo服务还要更新es（50毫秒），一共变为150毫秒性能降低。
  • 如果步骤2或步骤3任意一个地方出现了异常，整个服务就出现了问题。

3.1.2.异步通知

方案二：异步通知

流程如下：

• hotel-admin对mysql数据库数据完成增、删、改后，发送MQ消息
• hotel-demo监听MQ，接收到消息后完成elasticsearch数据修改

说明：

• 步骤：基于之前学习的mq来实现，当有人来做新增时，我先去写数据库写完之后不去调用任何人的接口，而是发一条消息通知以下别人（我这数据新增了），至于谁监听这个消息、 监听之后做什么 、什么时候做都跟步骤一没有关系，这样业务的耦合就解除了。并且步骤2步骤3更新耗时多少秒跟步骤1没有关系，步骤1写完数据库发完消息就结束了，所以性能得到了提升解决了方案一的同步调用问题。
• 缺点：
  • 依赖mq的可靠性
  • 引入了新的中间件，所以实现起来复杂性有一定的提升。

3.1.3.监听binlog

方案三：监听binlog

流程如下：

• 给mysql开启binlog功能
• mysql完成增、删、改操作都会记录在binlog中
• hotel-demo基于canal监听binlog变化，实时更新elasticsearch中的内容

说明：

• 通过监听binlog二进制日志文件来实现
• binlog：mysql里面binlog默认是关闭的，一旦开启每当mysql在做crud时，都会将相应的操作记录在binlog当中。
• 也就是说只要数据变化了binlog就会变化，之后在通过canal这样的中间件去监听binlog，一旦返现binlog发生变化立马通知对应的微服务，demo服务知道有数据变更了就可以更新es了。
• 优点：实现方式完全依赖于canal中间件和mysql，跟我们的酒店管理服务没有任何的关系，当有人来新增时酒店服务写数据 写完之后结束，admin服务既不用发消息也不用调任何人，完全的解除了服务之间的耦合。
• 缺点：需要开启mysql的binlog日志，所以mysql的压力增加了，需要引入一个新的中间件，学习的成本和部署的复杂度都变高了。

3.1.4.选择

方式一：同步调用

• 优点：实现简单，粗暴
• 缺点：业务耦合度高

方式二：异步通知

• 优点：低耦合，实现难度一般
• 缺点：依赖mq的可靠性

方式三：监听binlog

• 优点：完全解除服务间耦合
• 缺点：开启binlog增加数据库负担、实现复杂度高

3.2.实现数据同步（异步通知）

3.2.1.思路

说明：

• 数据同步一定是一个服务操作mysql，一个服务操作es，操作es的搜索服务已经写好了，所以还缺少一个操作mysql的这样一个数据管理的服务。

• 利用课前资料提供的hotel-admin项目作为酒店管理的微服务。当酒店数据发生增、删、改时，要求对elasticsearch中数据也要完成相同操作。

步骤：

• 导入课前资料提供的hotel-admin项目，启动并测试酒店数据的CRUD

• 声明exchange（交换机）、queue（队列）、RoutingKey（路由键：根据一定的规则将消息发送到匹配的队列中）

• 在hotel-admin中的增、删、改业务中完成消息发送

• 在hotel-demo中完成消息监听，并更新elasticsearch中数据

• 启动并测试数据同步功能

3.2.2.导入demo

导入课前资料提供的hotel-admin项目：

运行后，访问 http://localhost:8099

其中包含了酒店的CRUD功能：

3.2.3.声明交换机、队列

问题：需要声明什么样类型的交换机、几个队列、什么样的RoutingKey呢？？？

• 业务：当酒店数据发生增、删、改时，要求对elasticsearch中数据也要完成相同操作。
• 分析业务可知：消息只要3种（增、删、改），看似有3种类型的消息但是对于es来说，不管是增还是改都是往索引库中插入数据，因为在es中往里面插入数据如果id不存在就是新增，id如果存在就是修改，所以完全可以把增合改合成一个业务，因此这2种业务发生消息可以认为是同一种消息，综上所述消息的类型有2种，一类是增或改的消息、一类是删的消息，因此队列有2种，每个队列对应一个RoutingKey即可。
• 1个交换机：Topic类型为例（通配符，把消息交给符合routing pattern（路由模式） 的队列）
• 2个队列：hotel.insert.queue（增、改），hotel.delete.queue（删）
• 2个RoutingKey：hotel.insert（增、改），hotel.delete（删）

MQ结构如图：

1）引入依赖

在hotel-admin、hotel-demo中引入rabbitmq的依赖：

<!--amqp-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

2）yml添加mq配置

在hotel-admin、hotel-demo中的yml中配置mq：

spring:
  rabbitmq:
    host: 192.168.10.161 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 123321 # 密码

3）声明队列交换机名称

在hotel-admin和hotel-demo中的cn.itcast.hotel.constatnts包下新建一个类MqConstants：

package cn.itcast.hotel.constatnts;

    public class MqConstants {
    /**
     * 交换机
     */
    public final static String HOTEL_EXCHANGE = "hotel.topic";
    /**
     * 监听新增和修改的队列
     */
    public final static String HOTEL_INSERT_QUEUE = "hotel.insert.queue";
    /**
     * 监听删除的队列
     */
    public final static String HOTEL_DELETE_QUEUE = "hotel.delete.queue";
    /**
     * 新增或修改的RoutingKey
     */
    public final static String HOTEL_INSERT_KEY = "hotel.insert";
    /**
     * 删除的RoutingKey
     */
    public final static String HOTEL_DELETE_KEY = "hotel.delete";
}

4）声明队列交换机

说明：队列和交换机一般声明在消费者中。

在hotel-demo中，定义配置类，声明队列、交换机：

package cn.itcast.hotel.config;

import cn.itcast.hotel.constants.MqConstants;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MqConfig {
    //声明Topic类型的交换机
    @Bean
    public TopicExchange topicExchange(){
        //交换机的名称、持久化、自动删除
        return new TopicExchange(MqConstants.HOTEL_EXCHANGE, true, false);
    }

    //定义新增的队列
    @Bean
    public Queue insertQueue(){
        //队列名字、持久化
        return new Queue(MqConstants.HOTEL_INSERT_QUEUE, true);
    }

    //定义删除的队列
    @Bean
    public Queue deleteQueue(){
        //队列名字、持久化
        return new Queue(MqConstants.HOTEL_DELETE_QUEUE, true);
    }

    //绑定新增队列和交换机
    @Bean
    public Binding insertQueueBinding(){
        //队列、交换机、RoutingKey
        return BindingBuilder.bind(insertQueue()).to(topicExchange()).with(MqConstants.HOTEL_INSERT_KEY);
    }

    //绑定删除队列和交换机
    @Bean
    public Binding deleteQueueBinding(){
        //队列、交换机、RoutingKey
        return BindingBuilder.bind(deleteQueue()).to(topicExchange()).with(MqConstants.HOTEL_DELETE_KEY);
    }
}

3.2.4.发送MQ消息

在hotel-admin中的增、删、改业务中分别发送MQ消息：

为了简单起见这里业务写到了控制层。

@RestController
@RequestMapping("hotel")
public class HotelController {

    @Autowired
    private IHotelService hotelService;

    @Autowired
    private RabbitTemplate rabbitTemplate;



    //新增
    @PostMapping
    public void saveHotel(@RequestBody Hotel hotel){
        hotelService.save(hotel);

        /*
        * 发送消息: 告诉hotel-demo有数据发生新增了
        *   交换机名称
        *   RoutingKey
        *   消息内容：新增一个数据是不是直接把这个新增的对象发送过去？？？
        *           答：最好不要这样，因为你发送的消息将来要在mq中保存的，mq是基于内存的，如果把整个对象
        *           发过去比较消耗内存，很容易把队列占满，所以建议发送消息时消息体建议小一点。
        *           解决：只发送酒店的id，id发送过去demo服务可以通过酒店的id查询到酒店数据。
        * */
        rabbitTemplate.convertAndSend(MqConstants.HOTEL_EXCHANGE,MqConstants.HOTEL_INSERT_KEY, hotel.getId());
    }

    //修改
    @PutMapping()
    public void updateById(@RequestBody Hotel hotel){
        if (hotel.getId() == null) {
            throw new InvalidParameterException("id不能为空");
        }
        hotelService.updateById(hotel);

        //修改和新增一样
        rabbitTemplate.convertAndSend(MqConstants.HOTEL_EXCHANGE,MqConstants.HOTEL_INSERT_KEY, hotel.getId());
    }

    //删除
    @DeleteMapping("/{id}")
    public void deleteById(@PathVariable("id") Long id) {
        hotelService.removeById(id);

        //id是直接传过来了
        rabbitTemplate.convertAndSend(MqConstants.HOTEL_EXCHANGE,MqConstants.HOTEL_DELETE_KEY, id);
    }
}

3.2.5.接收MQ消息

hotel-demo接收到MQ消息要做的事情包括：

• 新增消息：根据传递的hotel的id查询hotel信息，然后新增一条数据到索引库
• 删除消息：根据传递的hotel的id删除索引库中的一条数据

1）首先在hotel-demo的cn.itcast.hotel.service包下的IHotelService中新增新增、删除业务

    void insertById(Long id);

    void deleteById(Long id);

2）给hotel-demo中的cn.itcast.hotel.service.impl包下的HotelService中实现业务：

    //新增
    @Override
    public void insertById(Long id) {
        try {
            // 0.根据id查询酒店数据
            // HotelService类继承了ServiceImpl<HotelMapper, Hotel>类,并且通过继承来获得了getById(id)方法的实现。
            Hotel hotel = getById(id);
            // 转换为文档类型
            HotelDoc hotelDoc = new HotelDoc(hotel);

            // 1.准备Request对象
            IndexRequest request = new IndexRequest("hotel").id(hotel.getId().toString());
            // 2.准备Json文档
            request.source(JSON.toJSONString(hotelDoc), XContentType.JSON);
            // 3.发送请求
            client.index(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    //删除
    @Override
    public void deleteById(Long id) {
        try {
            // 1.准备Request
            DeleteRequest request = new DeleteRequest("hotel", id.toString());
            // 2.发送请求
            client.delete(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

3）编写监听器

在hotel-demo中的cn.itcast.hotel.mq包新增一个类：

package cn.itcast.hotel.mq;


import cn.itcast.hotel.constants.MqConstants;
import cn.itcast.hotel.service.IHotelService;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component 这个类需要让spring知道
public class HotelListener {

    @Autowired
    private IHotelService hotelService;

    /**
     * 消费者1：
     * 监听酒店新增或修改的业务
     * @param id 酒店id
     */
    @RabbitListener(queues = MqConstants.HOTEL_INSERT_QUEUE)  //需要知道监听到那个队列
    public void listenHotelInsertOrUpdate(Long id){ //用什么类型传递的就用什么类型接收，spring会自动接收到消息
        hotelService.insertById(id);
    }

    /**
     * 消费者2：
     * 监听酒店删除的业务
     * @param id 酒店id
     */
    @RabbitListener(queues = MqConstants.HOTEL_DELETE_QUEUE) //需要知道监听到那个队列
    public void listenHotelDelete(Long id){ //用什么类型传递的就用什么类型接收，spring会自动接收到消息
        hotelService.deleteById(id);
    }
}

3.2.6.测试

先启动消费者 ，在启动生产者

查看队列：创建成功

查看交换机：创建成功

查看绑定关系：

测试修改：

• 原来的数据：
  
  
• 修改后的数据
  
  

测试删除：

• 删除前
  

• 删除后
  
  

4.集群

单机的elasticsearch做数据存储，必然面临两个问题：

• 海量数据存储问题：单机存储的数据能力是有限的
• 单点故障问题：数据存在一台机器上，如果这台机器挂了就会导致数据丢失了。
• 解决：集群。

具体方案：

• 海量数据存储问题：将索引库从逻辑上拆分为N个分片（shard），存储到多个节点
  • es基于内存存储，一台机器上的内存是有限的，把数据拆分到多个机器上存储，这样机器越多存储能力越大。
• 单点故障问题：将分片数据在不同节点备份（replica ）

  • 注意：将每一个分片的数据拷贝一份做个备份，如果这个备份的数据还是放在相同的分片上，比如：shard0和shard1都放在node1节点上，node1挂了这2个shard0和shard1数据还是都丢失了，数据整体就不完整了。
    

  • 解决：分片数据做备份后放到不同的节点上，也就是说一个节点的主分片和副分片绝对不能放到同一个节点上，这个时候即使node1节点挂了，node2+node3依然是完整数据，一定程度上可以解决单点故障。
    

ES集群相关概念:

• 集群（cluster）：一组拥有共同的 cluster name 的 节点。

• 节点（node) ：集群中的一个 Elasticearch 实例

• 分片（shard）：索引可以被拆分为不同的部分进行存储，称为分片。在集群环境下，一个索引的不同分片可以拆分到不同的节点中

  解决问题：数据量太大，单点存储量有限的问题。

  

  此处，我们把数据分成3片：shard0、shard1、shard2

• 主分片（Primary shard）：相对于副本分片的定义。

• 副本分片（Replica shard）每个主分片可以有一个或者多个副本，数据和主分片一样。

  ​

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

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

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

这样可以大大减少所需要的服务节点数量，如图，我们以3分片，每个分片备份一份为例：

现在，每个分片都有1个备份，存储在3个节点：

• node0：保存了分片0和1
• node1：保存了分片0和2
• node2：保存了分片1和2

4.1.搭建ES集群

说明：计划搭建由3台机器形成的集群，我们并没有3台电脑所以使用docker容器来模拟节点，因为docker容器之间相互隔离，用它来模拟机器是没有任何问题的。

参考课前资料：https://blog.csdn.net/aa35434/article/details/138261790

其中的第四章节：

4.2.集群脑裂问题

4.2.1.集群职责划分

elasticsearch中集群节点有不同的职责划分：

候选节点、数据节点、预处理节点、协调节点

默认情况下，集群中的任何一个节点都同时具备上述四种角色。

但是真实的集群一定要将集群职责分离：

• master节点：对CPU要求高，但是内存要求第
• data节点：对CPU和内存要求都高
• coordinating节点：对网络带宽、CPU要求高

职责分离可以让我们根据不同节点的需求分配不同的硬件去部署。而且避免业务之间的互相干扰。

一个典型的es集群职责划分如图：

4.2.2.脑裂问题

脑裂是因为集群中的节点失联导致的。

例如一个集群中，主节点与其它节点失联：

此时，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.2.3.小结

master eligible节点的作用是什么？

• 参与集群选主
• 主节点可以管理集群状态、管理分片信息、处理创建和删除索引库的请求

data节点的作用是什么？

• 数据的CRUD

coordinator节点的作用是什么？

• 路由请求到其它节点

• 合并查询到的结果，返回给用户

4.3.集群分布式存储

当新增文档时，应该保存到不同分片，保证数据均衡，那么coordinating node（协调节点）如何确定数据该存储到哪个分片呢？

协调节点：做请求路由，当一个crud的请求到达协调节点时，它会把请求路由到数据节点完成对应的业务操作。

4.3.1.分片存储测试

因为没有启动kibana，所以只能通过一个redtful的工具来做数据的crud。

插入三条数据：都是在9200这个es01节点上插入的，其它节点没有插入

测试可以看到，三条数据分别在不同分片：

结果每个节点上都能查到这3条数据，这些数据到底是存在那个分片上呢？？？

可以通过explain命令查看查询结果到底是在哪里

结果：刚好每个分片上都插入了一条数据

我明明是在9200（es01节点）上插入的，为什么每个节点上都有呢，说明我们的协调节点确实是工作了，那么它是怎么工作的？？？

具体查看4.3.2分片存储原理

4.3.2.分片存储原理

当新增文档时，应该保存到不同分片，保证数据均衡，那么coordinating node（协调节点）如何确定数据该存储到哪个分片呢？

elasticsearch会通过hash算法来计算文档应该存储到哪个分片：

分片 = hash(文档的id) %(取余) 分片的数量

说明：

• _routing默认是文档的id
• 算法与分片数量有关，因此索引库一旦创建，分片数量不能修改！
  • hash运算算完是一个数字，那这个数字对分片的数量去取余，例如我们这个集群分片的数量是3，数字对3取余结果只会为0、1、2，因此只要这个_routing值发生变化算出来的这个分片值也在变化，是不是就把数据均衡的分散到了不同分片去了。
  • 因为这个算法跟分片的数量有关，将来做查询也是通过这种算法方式知道你在哪个分片，在那个分片上找到对应的文档，如果在这个过程中有人把分片数量改了，比如原来是3个分片现在改为4个了，此时我插入的是3个分片查询的时候变为4个分片，使用相同的算法就不能算出相同的结果了，所以这个索引库一旦创建，分片数量不能修改，一改就找不到了。

新增文档的流程如下：

解读：

• 1）新增一个id=1的文档
• 2）对id做hash运算，假如得到的是2，则应该存储到shard-2
• 3）shard-2的主分片在node3节点，将数据路由到node3
• 4）保存文档
• 5）同步给shard-2的副本replica-2，在node2节点
• 6）返回结果给coordinating-node节点

总结：凡是根据id操作都是以上流程，但是刚刚演示的时候没有id是通过match_all查询的，当我们发起请求的那一刻不知道数据在那个分片上，这个时候协调节点又是怎么工作的呢？？？

查看4.4.

4.4.集群分布式查询

elasticsearch的查询分成两个阶段：

• scatter phase：分散阶段，coordinating node会把请求分发到每一个分片

  • 因为不知道id所以没办法确定数据在那个分片上，不知道在哪只能是去每个分片上去查。
  • 每个分片上都去查，这样可以保证查到的数据是完整的。

• gather phase：聚集阶段，coordinating node汇总data node的搜索结果，并处理为最终结果集返回给用户

  • 每个分片查到的结果会返回给协调节点，这个协调节点呢他会去汇总他们查到的结果，然后把它处理完返回给用户。

总结：

• 这个协调节点画了个虚线框：说明它可以是这3个节点中的任意一个，也可以单独再用一个协调节点。
• 无论是访问node1还是node2、node3，那么他们都会把这个请求分发给每一个分片，它们查完把结果汇总然后返回给用户，因此就出现刚才测试的效果了，你去访问任何4个机器的时候发现都能查得到。

4.5.集群故障转移

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

1）例如一个集群结构如图：

现在，node1是主节点，其它两个节点是从节点。

2）突然，node1发生了故障：

P：主分片，R：副分片

P1对应R1，P2对应R3，P3对应R3

宕机后的第一件事，需要重新选主，例如选中了node2：

node2成为主节点后，会检测集群监控状态，发现：shard-1、shard-0没有副本节点(节点2和3上，P1没有对应R1，P0没有对应的R0)。因此需要将node1上的数据迁移到node2、node3：

测试：

• 目前3个节点是健康的，02是主节点，把主节点停掉（docker-compose stop es02）
  
  

• 集群变黄不健康了，选举es01为主节点
  

• 等待了一会时间后，会自动进行故障迁移，把故障节点的数据迁移到这2个正常节点上了，这样数据整体有完整了，集群变为绿色。
  

• 再次查询数据没有丢失
  

• 在重启es02节点启动（docker-compose start es02），因为有主节点了02现在是副节点，主节点又把分片给迁移回去了，确保每个节点上都会有数据。