分布式搜索引擎03_Java-终身学习网

文章目录

前言
- 聚合的种类
一、DSL实现聚合
- 1)Bucket聚合
- 2)Metric聚合
- 3)RestAPI实现聚合
二、自动补全
- 1)拼音分词器
- 2)自定义分词器
- 3)自动补全
三、数据同步
- 1）同步调用
- 2）异步通知
- 3）监听binlog

前言聚合的种类

聚合常见的有三类：

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

注意：参加聚合的字段必须是keyword、日期、数值、布尔类型
可分词的字段不能参与聚合(会影响聚合的结果)

一、DSL实现聚合

aggs代表聚合，与query同级，此时query的作用是------ 限定聚合的的文档范围

聚合必须的三要素：

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

聚合可配置属性有：

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

1)Bucket聚合

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

GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
       "gte": 100,
        "lte": 200 
      }
    }
  }, 
  "size": 0,  // 设置size为0，结果中不包含文档，只包含聚合结果
  "aggs": { // 定义聚合
    "brandAgg": { //给聚合起个名字
      "terms": { // 聚合的类型，按照品牌值聚合，所以选择term
        "field": "brand", // 参与聚合的字段
        "size": 20 ,// 希望获取的聚合结果数量
      	"order": {
          "_count": "asc" // 按照_count升序排列
        }
      }
    }
  }
}

2)Metric聚合

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "size": 0, 
  "aggs": {
    "brandAgg": { 
      "terms": { 
        "field": "brand", 
        "size": 20,
        "order": {
          "price_status.avg": "asc" //# 可以根据聚合函数处理的结果进行排序
      },
      "aggs": { // 是brands聚合的子聚合，也就是分组后对每组分别计算
        "price_status": { // 聚合名称
          "stats": { // 聚合类型，这里stats可以计算min、max、avg等
            "field": "price" // 聚合字段，这里是score
          }
        },
        "price_avg": {
          "avg": {
            "field": "price"
          }
        },
        "price_max": {
          "max": {
            "field": "price"
          }
        }
      }
    }
  }
}

3)RestAPI实现聚合

聚合条件的语法：

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

@Test
   void testAggs() throws IOException {
       // 1.准备Request
       SearchRequest request = new SearchRequest("hotel");
       // 2.准备DSL
       request.source().size(0);
       request.source().aggregation(AggregationBuilders
               .terms("brand_agg") // 聚合名称 获取聚合数据时使用
               .field("brand") // 参与聚合的字段
               .size(20)); // 显示聚合数量
       // 3.发送请求
       SearchResponse response = client.search(request, RequestOptions.DEFAULT);
       // 4.解析响应
       // 获取所有的聚合结果
       Aggregations aggregations = response.getAggregations();
       // 根据聚合名称获取指定的聚合结果
       Terms brandTerms = aggregations.get("brand_agg");
       // 获取桶数据
       List buckets = brandTerms.getBuckets();
       // 遍历
       for (Terms.Bucket bucket : buckets) {
           String brandName = bucket.getKeyAsString();
           long docCount = bucket.getDocCount();
           System.out.println(brandName+" : "+docCount);
       }
   }

二、自动补全 1)拼音分词器

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

安装拼音分词器

下载pinyin分词器
进入之前安装es时的/usr/soft/elasticsearch/plugins目录
创建一个pinyin目录
将上述地址中的压缩包解压在该位置
重启elasticsearch

2)自定义分词器

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

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

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

创建一个索引库的自定义分词器

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

①character filter

②tokenizer

③filter

PUT /test
{
  "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)自动补全

自动补全DSL对应的对应的JavaAPI

@SpringBootTest
public class Hotel06SuggestionTests {

  private RestHighLevelClient client;
  
  @Test
  public void test01() throws IOException {
      //1.创建请求语义对象
      SearchRequest request = new SearchRequest("test");
      //2.自动补全
      request.source().suggest(
              new SuggestBuilder().addSuggestion(
                      "title_suggest",
                      SuggestBuilders.completionSuggestion("suggestion")
                      .prefix("s").skipDuplicates(true).size(10))
      );
      //3.发送请求
      SearchResponse response = client.search(request, RequestOptions.DEFAULT);
      //4.解析结果
      Suggest suggest = response.getSuggest();
      CompletionSuggestion suggestion = suggest.getSuggestion("title_suggest");
      // 遍历自动补全结果
      for (CompletionSuggestion.Entry.Option option : suggestion.getOptions()) {
          System.out.println(option.getText().string());
      }

    @BeforeEach
    public void init() {
        client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("192.168.200.128", 9200, "http")
                        //new HttpHost("localhost", 9201, "http")
                ));
        System.out.println(client);
    }
    
    @AfterEach
    public void destory() throws Exception{
        if (client!=null){
            client.close();
        }
    }

  }

三、数据同步

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

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

同步调用
异步通知
监听binlog

1）同步调用

优点：实现简单，粗暴
缺点：业务耦合度高
hotel-demo对外提供接口，用来修改elasticsearch中的数据
酒店管理服务在完成数据库操作后，直接调用hotel-demo提供的接口

2）异步通知

优点：低耦合，实现难度一般
缺点：依赖mq的可靠性
hotel-admin对mysql数据库数据完成增、删、改后，发送MQ消息
hotel-demo监听MQ，接收到消息后完成elasticsearch数据修改

MQ结构图

3）监听binlog

优点：完全解除服务间耦合
缺点：开启binlog增加数据库负担、实现复杂度高
给mysql开启binlog功能
mysql完成增、删、改操作都会记录在binlog中
hotel-demo基于canal监听binlog变化，实时更新elasticsearch中的内容

实现数据同步

例：

1）引入依赖

//引入rabbitmq的依赖：


    org.springframework.boot
    spring-boot-starter-amqp

2）声明队列交换机名称

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";
    
    public final static String HOTEL_INSERT_KEY = "hotel.insert";
    
    public final static String HOTEL_DELETE_KEY = "hotel.delete";
}

3）声明队列交换机

@Configuration
public class MqConfig {
    @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(){
        return BindingBuilder.bind(insertQueue()).to(topicExchange()).with(MqConstants.HOTEL_INSERT_KEY);
    }

    @Bean
    public Binding deleteQueueBinding(){
        return BindingBuilder.bind(deleteQueue()).to(topicExchange()).with(MqConstants.HOTEL_DELETE_KEY);
    }
}

4）发送MQ消息

  @PostMapping
    public void saveHotel(@RequestBody Hotel hotel){
        hotelService.save(hotel);
        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);
        rabbitTemplate.convertAndSend(MqConstants.HOTEL_EXCHANGE,MqConstants.HOTEL_DELETE_KEY,id);
    }

5）接收MQ消息

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

@Override
public void insertById(Long id) {
    try {
        // 0.根据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);
    }
}

6）编写监听器

@Component
public class HotelListener {

    @Autowired
    private IHotelService hotelService;

    
    @RabbitListener(queues = MqConstants.HOTEL_INSERT_QUEUE)
    public void listenHotelInsertOrUpdate(Long id){
        hotelService.insertById(id);
    }

    
    @RabbitListener(queues = MqConstants.HOTEL_DELETE_QUEUE)
    public void listenHotelDelete(Long id){
        hotelService.deleteById(id);
    }
}

分布式搜索引擎03

Java相关栏目本月热门文章