RabbitMQ和Elasticsearch的使用筆記

CooperMiNi發表於2021-08-23
MQElasticsearch筆記

 

RabbitMQ介紹

微服務間通訊有同步和非同步兩種方式：

同步通訊：就像打電話，需要實時響應（Feign呼叫就屬於同步方式）。

非同步通訊：就像發郵件，不需要馬上回復（RabbitMQ）。

RabbitMQ中的一些角色：

  • publisher：生產者

  • consumer：消費者

  • exchange個：交換機，負責訊息路由

  • queue：佇列，儲存訊息

  • virtualHost：虛擬主機，隔離不同租戶的exchange、queue、訊息的隔離

RabbitMQ安裝（基於Docker）

從docker倉庫拉去

docker pull rabbitmq:3-management

安裝

docker run \
 -e RABBITMQ_DEFAULT_USER=itcast \
 -e RABBITMQ_DEFAULT_PASS=123321 \
 --name mq \
 --hostname mq1 \
 -p 15672:15672 \
 -p 5672:5672 \
 -d \
 rabbitmq:3-management

　　這裡第二行是設定登入管理介面的使用者名稱，第三行是密碼，第四行是容器名字，第五行是主機名稱，第六行是管理介面所需要暴露的埠，第七行是RabbitMQ程式埠。

Elasticsearch介紹

elasticsearch是一款非常強大的開源搜尋引擎，具備非常多強大功能，可以幫助我們從海量資料中快速找到需要的內容

Elasticsearch 使用一種稱為 倒排索引 的結構，它適用於快速的全文搜尋。一個倒排索引由文件中所有不重複詞的列表構成，對於其中每個詞，有一個包含它的文件列表。

elasticsearch是面向文件（Document）儲存的，可以是資料庫中的一條商品資料，一個訂單資訊。文件資料會被序列化為json格式後儲存在elasticsearch中，而Json文件中往往包含很多的欄位（Field），類似於資料庫中的列。

索引（Index），就是相同型別的文件的集合。

 資料庫的表會有約束資訊，用來定義表的結構、欄位的名稱、型別等資訊。因此，索引庫中就有對映（mapping），是索引中文件的欄位約束資訊，類似表的結構約束。

和MYSQL對比：

  • Mysql：擅長事務型別操作，可以確保資料的安全和一致性

  • Elasticsearch：擅長海量資料的搜尋、分析、計算.

Elasticsearch安裝（基於Docker）

在用elasticsearch之前可以安裝kibana（視覺化圖形工具）

因為我們還需要部署kibana容器，因此需要讓es和kibana容器互聯。這裡先建立一個網路：

docker network create es-net

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

第三行是kibana的地址，es是上面建立的網路，來確保兩個在同一網路環境

es拉取

docker pull elasticsearch:7.12.1

　　es安裝

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

第三行是指定es的執行記憶體大小，可根據自己的機器修改，第四行是指定為非叢集模式，五六行是掛在資料卷的位置。

RabbitMQ使用

通過SpringAMQP是基於RabbitMQ封裝的一套模板，並且還利用SpringBoot對其實現了自動裝配。

匯入SpringAMQP依賴

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

　　

rabbitMQ---yml配置

spring:
  rabbitmq:
    host: 你的伺服器ip地址
    port: 5672
    username: 配置時設定的使用者名稱
    password: 密碼
    virtual-host: /

　

Basic Queue 簡單佇列模型

訊息傳送（publisher）

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {


@Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSimpleQueue() {
        // 佇列名稱
        String queueName = "simple.queue";
        // 訊息
        String message = "hello, spring amqp!";
        // 傳送訊息
        rabbitTemplate.convertAndSend(queueName, message);
    }
}

訊息接收（consumer）

在consumer服務的listener包中新建一個類SpringRabbitListener

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage(String msg) throws InterruptedException {
        System.out.println("spring 消費者接收到訊息：【" + msg + "】");
    }
}

WorkQueue

WorkQueue也被稱為（Task queues），任務模型。簡單來說就是讓多個消費者繫結到一個佇列，共同消費佇列中的訊息。

訊息傳送

@Test
public void testWorkQueue() throws InterruptedException {
    // 佇列名稱
    String queueName = "simple.queue";
    // 訊息
    String message = "hello, message_";
    for (int i = 0; i < 50; i++) {
        // 傳送訊息
        rabbitTemplate.convertAndSend(queueName, message + i);
        Thread.sleep(20);
    }
}

訊息接收

@RabbitListener(queues = "simple.queue")
public void listenWorkQueue1(String msg) throws InterruptedException {
    System.out.println("消費者1接收到訊息：【" + msg + "】" + LocalTime.now());
    Thread.sleep(20);
}

@RabbitListener(queues = "simple.queue")
public void listenWorkQueue2(String msg) throws InterruptedException {
    System.err.println("消費者2........接收到訊息：【" + msg + "】" + LocalTime.now());
    Thread.sleep(200);
}

　　

釋出/訂閱模型

在訂閱模型中，多了一個exchange角色，Exchange（交換機）只負責轉發訊息，不具備儲存訊息的能力。

訂閱模型不像簡單佇列模型它需要將佇列繫結在交換機上

Fanout模型

 

繫結佇列和交換機在消費者consumer服務中

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FanoutConfig {
    /**
     * 宣告交換機
     * @return Fanout型別交換機
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("itcast.fanout");
    }

    /**
     * 第1個佇列
     */
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }

    /**
     * 繫結佇列和交換機
     */
    @Bean
    public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }

    /**
     * 第2個佇列
     */
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("fanout.queue2");
    }

    /**
     * 繫結佇列和交換機
     */
    @Bean
    public Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }
}

　　訊息傳送

@Test
public void testFanoutExchange() {
// 佇列名稱
String exchangeName = "itcast.fanout";
// 訊息
String message = "hello, everyone!";
rabbitTemplate.convertAndSend(exchangeName, "", message);
}

　　訊息接收

@RabbitListener(queues = "fanout.queue1")
public void listenFanoutQueue1(String msg) {
    System.out.println("消費者1接收到Fanout訊息：【" + msg + "】");
}

@RabbitListener(queues = "fanout.queue2")
public void listenFanoutQueue2(String msg) {
    System.out.println("消費者2接收到Fanout訊息：【" + msg + "】");
}

　　

Direct模型

基於註解宣告佇列和交換機和接收訊息

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "direct.queue1"),
    exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
    key = {"red", "blue"}
))
public void listenDirectQueue1(String msg){
    System.out.println("消費者接收到direct.queue1的訊息：【" + msg + "】");
}

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "direct.queue2"),
    exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
    key = {"red", "yellow"}
))
public void listenDirectQueue2(String msg){
    System.out.println("消費者接收到direct.queue2的訊息：【" + msg + "】");
}

　　

訊息傳送

@Test
public void testSendDirectExchange() {
    // 交換機名稱
    String exchangeName = "itcast.direct";
    // 訊息
    String message = "message ";
    // 傳送訊息
    rabbitTemplate.convertAndSend(exchangeName, "red", message);
}

配置JSON轉換器

顯然，JDK序列化方式並不合適。我們希望訊息體的體積更小、可讀性更高，因此可以使用JSON方式來做序列化和反序列化。

在publisher和consumer兩個服務中都引入依賴：

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>
</dependency>

　　

配置訊息轉換器。

在啟動類中新增一個Bean即可：

@Bean
public MessageConverter jsonMessageConverter(){
    return new Jackson2JsonMessageConverter();
}

　　

小結：服務者publisher訊息傳送只需要管要傳送的交換機名字、Binding和訊息，而消費者需要監聽是否收到訊息

elasticsearch使用

索引庫的CRUD

首先開啟ip:5601

 

 

 

建立索引庫和對映

PUT /索引庫名稱
{
  "mappings": {
    "properties": {
      "欄位名":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "欄位名2":{
        "type": "keyword",
        "index": "false"
      },
      "欄位名3":{
        "properties": {
          "子欄位": {
            "type": "keyword"
          }
        }
      },
      // ...略
    }
  }
}

　　

查詢索引庫

GET /索引庫名

　　

修改索引庫

PUT /索引庫名/_mapping
{
  "properties": {
    "新欄位名":{
      "type": "integer"
    }
  }
}

　

刪除索引庫

DELETE /索引庫名

　

文件操作

新增文件

POST /索引庫名/_doc/文件id
{
    "欄位1": "值1",
    "欄位2": "值2",
    "欄位3": {
        "子屬性1": "值3",
        "子屬性2": "值4"
    },
    // ...
}

　　例：

POST /test/_doc/1
{
    "info": "Java講師",
    "email": "123@qq.cn",
    "name": {
        "firstName": "雲",
        "lastName": "趙"
    }
}

　　

查詢文件

GET /{索引庫名稱}/_doc/{id}

　　例：

GET /test/_doc/1

刪除文件

DELETE /{索引庫名}/_doc/id值

　　

修改文件

全量修改---全量修改是覆蓋原來的文件

PUT /{索引庫名}/_doc/文件id
{
    "欄位1": "值1",
    "欄位2": "值2",
    // ... 略
}

增量修改---增量修改是隻修改指定id匹配的文件中的部分欄位

POST /heima/_update/1
{
  "doc": {
    "email": "ZhaoYun@qq.cn"
  }
}

　　

RestAPI---forJava

建立索引庫

PUT /hotel
{
  "mappings": {
    "properties": {
      "id": {
        "type": "keyword"
      },
      "name":{
        "type": "text",
        "analyzer": "ik_max_word",
        "copy_to": "all"
      },
      "address":{
        "type": "keyword",
        "index": false
      },
      "price":{
        "type": "integer"
      },
      "score":{
        "type": "integer"
      },
      "brand":{
        "type": "keyword",
        "copy_to": "all"
      },
      "city":{
        "type": "keyword",
        "copy_to": "all"
      },
      "starName":{
        "type": "keyword"
      },
      "business":{
        "type": "keyword"
      },
      "location":{
        "type": "geo_point"
      },
      "pic":{
        "type": "keyword",
        "index": false
      },
      "all":{
        "type": "text",
        "analyzer": "ik_max_word"
      }
    }
  }
}

　　

幾個特殊欄位說明：

  • location：地理座標，裡面包含精度、緯度

  • all：一個組合欄位，其目的是將多欄位的值 利用copy_to合併，提供給使用者搜尋

初始化RestClient

引入es的RestHighLevelClient依賴

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>

　　因為SpringBoot預設的ES版本是7.6.2，所以我們需要覆蓋預設的ES版本

<properties>
    <java.version>1.8</java.version>
    <elasticsearch.version>7.12.1</elasticsearch.version>
</properties>

　　初始化RestHighLevelClient

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestHighLevelClient;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.io.IOException;

public class HotelIndexTest {
    private RestHighLevelClient client;

    @BeforeEach
    void setUp() {
        this.client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://192.168.150.101:9200")
        ));
    }

    @AfterEach
    void tearDown() throws IOException {
        this.client.close();
    }
}

　　

建立索引庫

@Test
void createHotelIndex() throws IOException {
    // 1.建立Request物件
    CreateIndexRequest request = new CreateIndexRequest("hotel");
    // 2.準備請求的引數：DSL語句
    request.source(*DSL語句*, XContentType.JSON);
    // 3.傳送請求
    client.indices().create(request, RequestOptions.DEFAULT);
}

刪除索引庫

@Test
void testDeleteHotelIndex() throws IOException {
    // 1.建立Request物件
    DeleteIndexRequest request = new DeleteIndexRequest("hotel");
    // 2.傳送請求
    client.indices().delete(request, RequestOptions.DEFAULT);
}

　　

判斷索引庫是否存在

@Test
void testExistsHotelIndex() throws IOException {
    // 1.建立Request物件
    GetIndexRequest request = new GetIndexRequest("hotel");
    // 2.傳送請求
    boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
    // 3.輸出
    System.err.println(exists ? "索引庫已經存在！" : "索引庫不存在！");
}

　　

RestClient操作文件

新增文件

@Test
void testAddDocument() throws IOException {
    // 1.根據id查詢酒店資料
    Hotel hotel = hotelService.getById(61083L);


    // 2.將hotel 轉json
    String json = JSON.toJSONString(hotel );

    // 1.準備Request物件
    IndexRequest request = new IndexRequest("hotel").id(hotelDoc.getId().toString());
    // 2.準備Json文件
    request.source(json, XContentType.JSON);
    // 3.傳送請求
    client.index(request, RequestOptions.DEFAULT);
}

　　

查詢文件（根據id）

@Test
void testGetDocumentById() throws IOException {
    // 1.準備Request
    GetRequest request = new GetRequest("hotel", "61082");
    // 2.傳送請求，得到響應
    GetResponse response = client.get(request, RequestOptions.DEFAULT);
    // 3.解析響應結果
    String json = response.getSourceAsString();

    HotelDoc hotel = JSON.parseObject(json, Hotel.class);
    System.out.println(hotel);
}

　　

刪除文件

@Test
void testDeleteDocument() throws IOException {
    // 1.準備Request
    DeleteRequest request = new DeleteRequest("hotel", "61083");
    // 2.傳送請求
    client.delete(request, RequestOptions.DEFAULT);
}

　

修改文件

　

@Test
void testUpdateDocument() throws IOException {
    // 1.準備Request
    UpdateRequest request = new UpdateRequest("hotel", "61083");
    // 2.準備請求引數
    request.doc(
        "price", "952",
        "starName", "四鑽"
    );
    // 3.傳送請求
    client.update(request, RequestOptions.DEFAULT);
}

　　

批量匯入文件

@Test
void testBulkRequest() throws IOException {
    // 批量查詢酒店資料
    List<Hotel> hotels = hotelService.list();

    // 1.建立Request
    BulkRequest request = new BulkRequest();
    // 2.準備引數，新增多個新增的Request
    for (Hotel hotel : hotels) {

        // 2.1.建立新增文件的Request物件
        request.add(new IndexRequest("hotel")
                    .id(hotel.getId().toString())
                    .source(JSON.toJSONString(hotel), XContentType.JSON));
    }
    // 3.傳送請求
    client.bulk(request, RequestOptions.DEFAULT);
}

　　

DSL查詢分類

  • 查詢所有：查詢出所有資料，一般測試用。例如：match_all

  • 全文檢索（full text）查詢：利用分詞器對使用者輸入內容分詞，然後去倒排索引庫中匹配。例如：

    • match查詢：單欄位查詢

    • multi_match查詢：多欄位查詢，任意一個欄位符合條件就算符合查詢條件

      • match和multi_match的區別是什麼？

        • 　　match：根據一個欄位查詢

        • 　　multi_match：根據多個欄位查詢，參與查詢欄位越多，查詢效能越差

  • 精確查詢：根據精確詞條值查詢資料，一般是查詢keyword、數值、日期、boolean等型別欄位。例如：

    • ids 根據id查詢

    • range  根據值的範圍查詢

    • term 根據詞條精確值查詢

  • 地理（geo）查詢：根據經緯度查詢。例如：

    • geo_distance 附近查詢，也叫做距離查詢

    • geo_bounding_box  矩形範圍查詢

  • 複合（compound）查詢：複合查詢可以將上述各種查詢條件組合起來，合併查詢條件。例如：

    • 　　fuction score：算分函式查詢，可以控制文件相關性算分，控制文件排名

    • 　　bool query：布林查詢，利用邏輯關係組合多個其它的查詢，實現複雜搜尋

 

　　　　相關性算分

 

　　　　當我們利用match查詢時，文件結果會根據與搜尋詞條的關聯度打分（_score），返回結果時按照分值降序排列

function score 查詢中包含四部分內容：

  • 原始查詢條件：query部分，基於這個條件搜尋文件，並且基於BM25演算法給文件打分，原始算分（query score)

  • 過濾條件：filter部分，符合該條件的文件才會重新算分

  • 算分函式：符合filter條件的文件要根據這個函式做運算，得到的函式算分（function score），有四種函式

    • weight：函式結果是常量

    • field_value_factor：以文件中的某個欄位值作為函式結果

    • random_score：以隨機數作為函式結果

    • script_score：自定義算分函式演算法

  • 運算模式：算分函式的結果、原始查詢的相關性算分，兩者之間的運算方式，包括：

    • multiply：相乘

    • replace：用function score替換query score

    • 其它，例如：sum、avg、max、min

 

function score的執行流程如下：

  • 1）根據原始條件查詢搜尋文件，並且計算相關性算分，稱為原始算分（query score）

  • 2）根據過濾條件，過濾文件

  • 3）符合過濾條件的文件，基於算分函式運算，得到函式算分（function score）

  • 4）將原始算分（query score）和函式算分（function score）基於運算模式做運算，得到最終結果，作為相關性算分。

 

因此，其中的關鍵點是：

  • 過濾條件：決定哪些文件的算分被修改

  • 算分函式：決定函式算分的演算法

  • 運算模式：決定最終算分結果

示例：

GET /hotel/_search
{
  "query": {
    "function_score": {
      "query": {  .... }, // 原始查詢，可以是任意條件
      "functions": [ // 算分函式
        {
          "filter": { // 滿足的條件，品牌必須是如家
            "term": {
              "brand": "如家"
            }
          },
          "weight": 2 // 算分權重為2
        }
      ],
      "boost_mode": "sum" // 加權模式，求和
    }
  }
}

　　

布林查詢（bool）

布林查詢是一個或多個查詢子句的組合，每一個子句就是一個子查詢。子查詢的組合方式有：

  • must：必須匹配每個子查詢，類似“與”

  • should：選擇性匹配子查詢，類似“或”

  • must_not：必須不匹配，不參與算分，類似“非”

  • filter：必須匹配，不參與算分

每一個不同的欄位，其查詢的條件、方式都不一樣，必須是多個不同的查詢，而要組合這些查詢，就必須用bool查詢了。

 

需要注意的是，搜尋時，參與打分的欄位越多，查詢的效能也越差。因此這種多條件查詢時，建議這樣做：

  • 搜尋框的關鍵字搜尋，是全文檢索查詢，使用must查詢，參與算分

  • 其它過濾條件，採用filter查詢。不參與算分

示例

GET /hotel/_search
{
  "query": {
    "bool": {
      "must": [
        {"term": {"city": "上海" }}
      ],
      "should": [
        {"term": {"brand": "皇冠假日" }},
        {"term": {"brand": "華美達" }}
      ],
      "must_not": [
        { "range": { "price": { "lte": 500 } }}
      ],
      "filter": [
        { "range": {"score": { "gte": 45 } }}
      ]
    }
  }
}

　　

查詢的語法基本一致：

GET /indexName/_search
{
  "query": {
    "查詢型別": {
      "查詢條件": "條件值"
    }
  }
}

　　

搜尋結果處理

排序

普通欄位排序

排序條件是一個陣列，也就是可以寫多個排序條件。按照宣告的順序，當第一個條件相等時，再按照第二個條件排序，以此類推

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "FIELD": "desc"  // 排序欄位、排序方式ASC、DESC
    }
  ]
}

　　

地理座標排序

　

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "_geo_distance" : {
          "FIELD" : "緯度，經度", // 文件中geo_point型別的欄位名、目標座標點
          "order" : "asc", // 排序方式
          "unit" : "km" // 排序的距離單位
      }
    }
  ]
}

　　

這個查詢的含義是：

  • 指定一個座標，作為目標點

  • 計算每一個文件中，指定欄位（必須是geo_point型別）的座標 到目標點的距離是多少

  • 根據距離排序

分頁

基本的分頁

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0, // 分頁開始的位置，預設為0
  "size": 10, // 期望獲取的文件總數
  "sort": [
    {"price": "asc"}
  ]
}

深度分頁問題

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "from": 990, // 分頁開始的位置，預設為0
  "size": 10, // 期望獲取的文件總數
  "sort": [
    {"price": "asc"}
  ]
}

　

高亮

GET /hotel/_search
{
  "query": {
    "match": {
      "FIELD": "TEXT" // 查詢條件，高亮一定要使用全文檢索查詢
    }
  },
  "highlight": {
    "fields": { // 指定要高亮的欄位
      "FIELD": {
        "pre_tags": "<em>",  // 用來標記高亮欄位的前置標籤
        "post_tags": "</em>" // 用來標記高亮欄位的後置標籤
      }
    }
  }
}

　　

RestClient查詢文件

基本步驟：

  • 第一步，建立SearchRequest物件，指定索引庫名

  • 第二步，利用request.source()構建DSL，DSL中可以包含查詢、分頁、排序、高亮等

    • query()：代表查詢條件，利用QueryBuilders.matchAllQuery()構建一個match_all查詢的DSL

  • 第三步，利用client.search()傳送請求，得到響應

  • 第四步，解析響應

示例：

@Test
void testMatchAll() throws IOException {
    // 1.準備Request
    SearchRequest request = new SearchRequest("hotel");
    // 2.準備DSL
    request.source()
        .query(QueryBuilders.matchAllQuery());
    // 3.傳送請求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);

    // 4.解析響應
    handleResponse(response);
}

private void handleResponse(SearchResponse response) {
    // 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();
        // 反序列化
        HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
        System.out.println("hotelDoc = " + hotelDoc);
    }
}

match查詢

@Test
void testMatch() throws IOException {
    // 1.準備Request
    SearchRequest request = new SearchRequest("hotel");
    // 2.準備DSL
    request.source()
        .query(QueryBuilders.matchQuery("all", "如家"));
    // 3.傳送請求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析響應
    handleResponse(response);

}

　

精確查詢

同上換成

QueryBuilders.termQuery（“欄位”，“值”）；
QueryBuilders.rangeQuery（“欄位”）.gte(min).lte(max);
　

布林查詢

與其它查詢的差別同樣是在查詢條件的構建，QueryBuilders，結果解析等其他程式碼完全不變。

@Test
void testBool() throws IOException {
    // 1.準備Request
    SearchRequest request = new SearchRequest("hotel");
    // 2.準備DSL
    // 2.1.準備BooleanQuery
    BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    // 2.2.新增term
    boolQuery.must(QueryBuilders.termQuery("city", "杭州"));
    // 2.3.新增range
    boolQuery.filter(QueryBuilders.rangeQuery("price").lte(250));

    request.source().query(boolQuery);
    // 3.傳送請求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析響應
    handleResponse(response);

}

　　

　

排序、分頁

@Test
void testPageAndSort() throws IOException {
    // 頁碼，每頁大小
    int page = 1, size = 5;

    // 1.準備Request
    SearchRequest request = new SearchRequest("hotel");
    // 2.準備DSL
    // 2.1.query
    request.source().query(QueryBuilders.matchAllQuery());
    // 2.2.排序 sort
    request.source().sort("price", SortOrder.ASC);
    // 2.3.分頁 from、size
    request.source().from((page - 1) * size).size(5);
    // 3.傳送請求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析響應
    handleResponse(response);

}

　　

高亮

@Test
void testHighlight() throws IOException {
    // 1.準備Request
    SearchRequest request = new SearchRequest("hotel");
    // 2.準備DSL
    // 2.1.query
    request.source().query(QueryBuilders.matchQuery("all", "如家"));
    // 2.2.高亮
    request.source().highlighter(new HighlightBuilder().field("name").requireFieldMatch(false));
    // 3.傳送請求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析響應
    handleResponse(response);

}

　　高粱結果解析

private void handleResponse(SearchResponse response) {
    // 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();
        // 反序列化
        HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.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();
                // 覆蓋非高亮結果
                hotelDoc.setName(name);
            }
        }
        System.out.println("hotelDoc = " + hotelDoc);
    }
}

　　

資料聚合

聚合（aggregations）可以讓我們極其方便的實現對資料的統計、分析、運算。例如：

  • 什麼品牌的手機最受歡迎？

  • 這些手機的平均價格、最高價格、最低價格？

  • 這些手機每月的銷售情況如何？

實現這些統計功能的比資料庫的sql要方便的多，而且查詢速度非常快，可以實現近實時搜尋效果。

聚合常見的有三類：

  • 桶（Bucket）聚合：用來對文件做分組

    • TermAggregation：按照文件欄位值分組，例如按照品牌值分組、按照國家分組

    • Date Histogram：按照日期階梯分組，例如一週為一組，或者一月為一組

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

    • Avg：求平均值

    • Max：求最大值

    • Min：求最小值

    • Stats：同時求max、min、avg、sum等

  • 管道（pipeline）聚合：其它聚合的結果為基礎做聚合 

注意：參加聚合的欄位必須是keyword、日期、數值、布林型別

　DSL實現

GET /hotel/_search
{
  "size": 0,  // 設定size為0，結果中不包含文件，只包含聚合結果
  "aggs": { // 定義聚合
    "brandAgg": { //給聚合起個名字
      "terms": { // 聚合的型別，按照品牌值聚合，所以選擇term
        "field": "brand", // 參與聚合的欄位
        "size": 20 // 希望獲取的聚合結果數量
      }
    }
  }
}

聚合結果排序

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

　　

限定聚合範圍

預設情況下，Bucket聚合是對索引庫的所有文件做聚合，但真實場景下，使用者會輸入搜尋條件，因此聚合必須是對搜尋結果聚合。那麼聚合必須新增限定條件。

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

　　RestAPI

@Override
public Map<String, List<String>> filters(RequestParams params) {
    try {
        // 1.準備Request
        SearchRequest request = new SearchRequest("hotel");
        // 2.準備DSL
        // 2.1.query
        buildBasicQuery(params, request);
        // 2.2.設定size
        request.source().size(0);
        // 2.3.聚合
        buildAggregation(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);
        // 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 buildAggregation(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) {
    // 4.1.根據聚合名稱獲取聚合結果
    Terms brandTerms = aggregations.get(aggName);
    // 4.2.獲取buckets
    List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
    // 4.3.遍歷
    List<String> brandList = new ArrayList<>();
    for (Terms.Bucket bucket : buckets) {
        // 4.4.獲取key
        String key = bucket.getKeyAsString();
        brandList.add(key);
    }
    return brandList;
}

　　

網路釋義
Kibana: 可芭納
kibana field: 值

相關文章