elasticsearch 基礎介紹及使用（high-level-client）

一、ElasticSearch 簡介

中文官方文檔鏈接

https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.6/java-rest-high-getting-started.html

1、簡介
ElasticSearch 是一個基於 Lucene 的搜索服務器。它提供了一個分佈式多員工能力的全文搜索引擎，基於 RESTful web 接口。Elasticsearch 是用 Java 語言開發的，並作爲 Apache 許可條款下的開放源碼發佈，是一種流行的企業級搜索引擎。ElasticSearch 用於雲計算中，能夠達到實時搜索，穩定，可靠，快速，安裝使用方便。
2、特性

    分佈式的文檔存儲引擎
    分佈式的搜索引擎和分析引擎
    分佈式，支持PB級數據

3、使用場景

    搜索領域：如百度、谷歌，全文檢索等。
    門戶網站：訪問統計、文章點贊、留言評論等。
    廣告推廣：記錄員工行爲數據、消費趨勢、員工羣體進行定製推廣等。
    信息採集：記錄應用的埋點數據、訪問日誌數據等，方便大數據進行分析。

二、ElasticSearch 基礎概念

1、ElaticSearch 和 DB 的關係

在 Elasticsearch 中，文檔歸屬於一種類型 type，而這些類型存在於索引 index 中，我們可以列一些簡單的不同點，來類比傳統關係型數據庫：

Relational DB -> Databases -> Tables -> Rows -> Columns
Elasticsearch -> Indices -> Types -> Documents -> Fields

Elasticsearch 集羣可以包含多個索引 indices，每一個索引可以包含多個類型 types，每一個類型包含多個文檔 documents，然後每個文檔包含多個字段 Fields。而在 DB 中可以有多個數據庫 Databases，每個庫中可以有多張表 Tables，沒個表中又包含多行Rows，每行包含多列Columns。
2、索引
索引基本概念（indices）：索引是含義相同屬性的文檔集合，是 ElasticSearch 的一個邏輯存儲，可以理解爲關係型數據庫中的數據庫，ElasticSearch 可以把索引數據存放到一臺服務器上，也可以 sharding 後存到多臺服務器上，每個索引有一個或多個分片，每個分片可以有多個副本。
索引類型（index_type）：索引可以定義一個或多個類型，文檔必須屬於一個類型。在 ElasticSearch 中，一個索引對象可以存儲多個不同用途的對象，通過索引類型可以區分單個索引中的不同對象，可以理解爲關係型數據庫中的表。每個索引類型可以有不同的結構，但是不同的索引類型不能爲相同的屬性設置不同的類型。
3、文檔
文檔（document）：文檔是可以被索引的基本數據單位。存儲在 ElasticSearch 中的主要實體叫文檔 document，可以理解爲關係型數據庫中表的一行記錄。每個文檔由多個字段構成，ElasticSearch 是一個非結構化的數據庫，每個文檔可以有不同的字段，並且有一個唯一的標識符。
4、映射
映射（mapping）:ElasticSearch 的 Mapping 非常類似於靜態語言中的數據類型：聲明一個變量爲 int 類型的變量，以後這個變量都只能存儲 int 類型的數據。同樣的，一個 number 類型的 mapping 字段只能存儲 number 類型的數據。同語言的數據類型相比，Mapping 還有一些其他的含義，Mapping 不僅告訴 ElasticSearch 一個 Field 中是什麼類型的值，它還告訴 ElasticSearch 如何索引數據以及數據是否能被搜索到。ElaticSearch 默認是動態創建索引和索引類型的 Mapping 的。這就相當於無需定義 Solr 中的 Schema，無需指定各個字段的索引規則就可以索引文件，很方便。但有時方便就代表着不靈活。比如，ElasticSearch 默認一個字段是要做分詞的，但我們有時要搜索匹配整個字段卻不行。如有統計工作要記錄每個城市出現的次數。對於 name 字段，若記錄 new york 文本，ElasticSearch 可能會把它拆分成 new 和 york 這兩個詞，分別計算這個兩個單詞的次數，而不是我們期望的 new york。

三、SpringBoot 項目引入 ElasticSearch 依賴

下面介紹下 SpringBoot 如何通過 elasticsearch-rest-high-level-client 工具操作 ElasticSearch，這裏需要說一下，爲什麼沒有使用 Spring 家族封裝的 spring-data-elasticsearch。
主要原因是靈活性和更新速度，Spring 將 ElasticSearch 過度封裝，讓開發者很難跟 ES 的 DSL 查詢語句進行關聯。再者就是更新速度，ES 的更新速度是非常快，但是 spring-data-elasticsearch 更新速度比較緩慢。
由於上面兩點，所以選擇了官方推出的 Java 客戶端 elasticsearch-rest-high-level-client，它的代碼寫法跟 DSL 語句很相似，懂 ES 查詢的使用其上手很快。

1、Maven 引入相關依賴

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.2.5.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>
   <groupId>com.ultrapower</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <!-- 打包跳過測試模塊 -->
      <skipTests>true</skipTests>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <!--es客戶端，不使用springboot封裝的客戶端-->
      <dependency>
         <groupId>org.elasticsearch.client</groupId>
         <artifactId>elasticsearch-rest-high-level-client</artifactId>
         <version>7.5.2</version>
      </dependency>
      <dependency>
         <groupId>org.elasticsearch</groupId>
         <artifactId>elasticsearch</artifactId>
         <version>7.5.2</version>
      </dependency>

        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-client</artifactId>
            <version>7.6.2</version>
        </dependency>

      <!--json解析工具-->
      <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>fastjson</artifactId>
         <version>1.2.68</version>
      </dependency>
      <!-- commons-lang3 -->
      <dependency>
         <groupId>org.apache.commons</groupId>
         <artifactId>commons-lang3</artifactId>
         <version>3.10</version>
      </dependency>
      <!--lombok-->
      <dependency>
         <groupId>org.projectlombok</groupId>
         <artifactId>lombok</artifactId>
         <version>1.18.12</version>
         <scope>provided</scope>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
         <exclusions>
            <exclusion>
               <groupId>org.junit.vintage</groupId>
               <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
         </exclusions>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>

</project>

2、ElasticSearch 連接配置

(1)、application.yml 配置文件

#spring
spring:
  application:
    name: springboot-test
#elasticsearch
elasticsearch:
  schema: http
  address: 127.0.0.1:9200
  connectTimeout: 5000
  socketTimeout: 5000
  connectionRequestTimeout: 5000
  maxConnectNum: 100
  maxConnectPerRoute: 100

(2)、java 連接配置類
這裏需要寫一個 Java 配置類：

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.ArrayList;
import java.util.List;


/**
 * @Deacription ElasticSearch 配置
 * @Author wenyt
 * @Date 2020/3/18 9:12
 * @Version 1.0
 **/
@Configuration
public class ElasticSearchConfiguration {
    /** 協議 */
    @Value("${elasticsearch.schema:http}")
    private String schema;

    /** 集羣地址，如果有多個用“,”隔開 */
    @Value("${elasticsearch.address}")
    private String address;

    /** 連接超時時間 */
    @Value("${elasticsearch.connectTimeout}")
    private int connectTimeout;

    /** Socket 連接超時時間 */
    @Value("${elasticsearch.socketTimeout}")
    private int socketTimeout;

    /** 獲取連接的超時時間 */
    @Value("${elasticsearch.connectionRequestTimeout}")
    private int connectionRequestTimeout;

    /** 最大連接數 */
    @Value("${elasticsearch.maxConnectNum}")
    private int maxConnectNum;

    /** 最大路由連接數 */
    @Value("${elasticsearch.maxConnectPerRoute}")
    private int maxConnectPerRoute;

    @Bean(name = "restHighLevelClient")
    public RestHighLevelClient restHighLevelClient() {
        // 拆分地址
        List<HttpHost> hostLists = new ArrayList<>();
        String[] hostList = address.split(",");
        for (String addr : hostList) {
            String host = addr.split(":")[0];
            String port = addr.split(":")[1];
            hostLists.add(new HttpHost(host, Integer.parseInt(port), schema));
        }
        // 轉換成 HttpHost 數組
        HttpHost[] httpHost = hostLists.toArray(new HttpHost[]{});
        // 構建連接對象
        RestClientBuilder builder = RestClient.builder(httpHost);
        // 異步連接延時配置
        builder.setRequestConfigCallback(requestConfigBuilder -> {
            requestConfigBuilder.setConnectTimeout(connectTimeout);
            requestConfigBuilder.setSocketTimeout(socketTimeout);
            requestConfigBuilder.setConnectionRequestTimeout(connectionRequestTimeout);
            return requestConfigBuilder;
        });
        // 異步連接數配置
        builder.setHttpClientConfigCallback(httpClientBuilder -> {
            httpClientBuilder.setMaxConnTotal(maxConnectNum);
            httpClientBuilder.setMaxConnPerRoute(maxConnectPerRoute);
            return httpClientBuilder;
        });
        return new RestHighLevelClient(builder);
    }
}

四、索引操作示例

通過 Kibana 的 Restful 工具操作與對應的 Java 代碼操作的兩個示例。

1、Restful 操作示例

創建索引
創建名爲 mydlq-user 的索引與對應 Mapping。

PUT /mydlq-user
{
"mappings": {
    "doc": {
      "dynamic": true,
      "properties": {
        "name": {
          "type": "text",
          "fields": {
            "keyword": {
              "type": "keyword"
            }
          }
        },
        "address": {
          "type": "text",
          "fields": {
            "keyword": {
              "type": "keyword"
            }
          }
        },
        "remark": {
          "type": "text",
          "fields": {
            "keyword": {
              "type": "keyword"
            }
          }
        },
        "age": {
          "type": "integer"
        },
        "salary": {
          "type": "float"
        },
        "birthDate": {
          "type": "date",
          "format": "yyyy-MM-dd"
        },
        "createTime": {
          "type": "date"
        }
      }
    }
}
}

2、Java 代碼示例

import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;

@Slf4j
@Service
public class IndexService2 {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 創建索引
     */
    public void createIndex() {
        try {
            // 創建 Mapping
            XContentBuilder mapping = XContentFactory.jsonBuilder()
                .startObject()
                    .field("dynamic", true)
                    .startObject("properties")
                        .startObject("name")
                            .field("type","text")
                            .startObject("fields")
                                .startObject("keyword")
                                    .field("type","keyword")
                                .endObject()
                            .endObject()
                        .endObject()
                        .startObject("address")
                            .field("type","text")
                            .startObject("fields")
                                .startObject("keyword")
                                    .field("type","keyword")
                                .endObject()
                            .endObject()
                        .endObject()
                        .startObject("remark")
                            .field("type","text")
                            .startObject("fields")
                                .startObject("keyword")
                                    .field("type","keyword")
                                .endObject()
                            .endObject()
                        .endObject()
                        .startObject("age")
                            .field("type","integer")
                        .endObject()
                        .startObject("salary")
                            .field("type","float")
                        .endObject()
                        .startObject("birthDate")
                            .field("type","date")
                            .field("format", "yyyy-MM-dd")
                        .endObject()
                        .startObject("createTime")
                            .field("type","date")
                        .endObject()
                    .endObject()
                .endObject();
            // 創建索引配置信息，配置
            Settings settings = Settings.builder()
                    .put("index.number_of_shards", 1)
                    .put("index.number_of_replicas", 0)
                    .build();
            // 新建創建索引請求對象，然後設置索引類型（ES 7.0 將不存在索引類型）和 mapping 與 index 配置
            CreateIndexRequest request = new CreateIndexRequest("mydlq-user", settings);
            request.mapping("doc", mapping);
            // RestHighLevelClient 執行創建索引
            CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
            // 判斷是否創建成功
            boolean isCreated = createIndexResponse.isAcknowledged();
            log.info("是否創建成功：{}", isCreated);
        } catch (IOException e) {
            log.error("", e);
        }
    }

    /**
     * 刪除索引
     */
    public void deleteIndex() {
        try {
            // 新建刪除索引請求對象
            DeleteIndexRequest request = new DeleteIndexRequest("mydlq-user");
            // 執行刪除索引
            AcknowledgedResponse acknowledgedResponse = restHighLevelClient.indices().delete(request, RequestOptions.DEFAULT);
            // 判斷是否刪除成功
            boolean siDeleted = acknowledgedResponse.isAcknowledged();
            log.info("是否刪除成功：{}", siDeleted);
        } catch (IOException e) {
            log.error("", e);
        }
    }

}

五、文檔操作示例

1、Restful 操作示例

在索引 mydlq-user 中增加一條文檔信息。

POST /mydlq-user/
{
    "address": "北京市",
    "age": 29,
    "birthDate": "1990-01-10",
    "createTime": 1579530727699,
    "name": "張三",
    "remark": "來自北京市的張先生",
    "salary": 100
}

獲取文檔信息
獲取 mydlq-user 的索引 id=1 的文檔信息。

GET /mydlq-user/doc/1

更新文檔信息
更新之前創建的 id=1 的文檔信息。

PUT /mydlq-user/1
{
    "address": "北京市海淀區",
    "age": 29,
    "birthDate": "1990-01-10",
    "createTime": 1579530727699,
    "name": "張三",
    "remark": "來自北京市的張先生",
    "salary": 100
}

刪除文檔信息
刪除之前創建的 id=1 的文檔信息。

DELETE /mydlq-user/1

2、Java 代碼示例

import club.mydlq.elasticsearch.model.entity.UserInfo;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.util.Date;

@Slf4j
@Service
public class IndexService {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 增加文檔信息
     */
    public void addDocument() {
        try {
            // 創建索引請求對象
            IndexRequest indexRequest = new IndexRequest("mydlq-user", "doc", "1");
            // 創建員工信息
            UserInfo userInfo = new UserInfo();
            userInfo.setName("張三");
            userInfo.setAge(29);
            userInfo.setSalary(100.00f);
            userInfo.setAddress("北京市");
            userInfo.setRemark("來自北京市的張先生");
            userInfo.setCreateTime(new Date());
            userInfo.setBirthDate("1990-01-10");
            // 將對象轉換爲 byte 數組
            byte[] json = JSON.toJSONBytes(userInfo);
            // 設置文檔內容
            indexRequest.source(json, XContentType.JSON);
            // 執行增加文檔
            IndexResponse response = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
            log.info("創建狀態：{}", response.status());
        } catch (Exception e) {
            log.error("", e);
        }
    }

    /**
     * 獲取文檔信息
     */
    public void getDocument() {
        try {
            // 獲取請求對象
            GetRequest getRequest = new GetRequest("mydlq-user", "doc", "1");
            // 獲取文檔信息
            GetResponse getResponse = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
            // 將 JSON 轉換成對象
            if (getResponse.isExists()) {
                UserInfo userInfo = JSON.parseObject(getResponse.getSourceAsBytes(), UserInfo.class);
                log.info("員工信息：{}", userInfo);
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

    /**
     * 更新文檔信息
     */
    public void updateDocument() {
        try {
            // 創建索引請求對象
            UpdateRequest updateRequest = new UpdateRequest("mydlq-user", "doc", "1");
            // 設置員工更新信息
            UserInfo userInfo = new UserInfo();
            userInfo.setSalary(200.00f);
            userInfo.setAddress("北京市海淀區");
            // 將對象轉換爲 byte 數組
            byte[] json = JSON.toJSONBytes(userInfo);
            // 設置更新文檔內容
            updateRequest.doc(json, XContentType.JSON);
            // 執行更新文檔
            UpdateResponse response = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
            log.info("創建狀態：{}", response.status());
        } catch (Exception e) {
            log.error("", e);
        }
    }

    /**
     * 刪除文檔信息
     */
    public void deleteDocument() {
        try {
            // 創建刪除請求對象
            DeleteRequest deleteRequest = new DeleteRequest("mydlq-user", "doc", "1");
            // 執行刪除文檔
            DeleteResponse response = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
            log.info("刪除狀態：{}", response.status());
        } catch (IOException e) {
            log.error("", e);
        }
    }

}

六、查詢操作示例

1、精確查詢(term)

(1) Restful 操作示例
精確查詢精確查詢
查詢地址爲北京市通州區的人員信息：查詢條件不會進行分詞，但是查詢內容可能會分詞，導致查詢不到。之前在創建索引時設置 Mapping 中 address 字段存在 keyword 字段是專門用於不分詞查詢的子字段。

GET mydlq-user/_search
{
"query": {
    "term": {
      "address.keyword": {
        "value": "北京市通州區"
      }
    }
}
}

精確查詢-多內容查詢精確查詢
查詢地址爲北京市豐臺區、北京市昌平區或北京市大興區的人員信息：

GET mydlq-user/_search
{
"query": {
    "terms": {
      "address.keyword": [
        "北京市豐臺區",
        "北京市昌平區",
        "北京市大興區"
      ]
    }
}
}

(2) Java 代碼示例

import club.mydlq.elasticsearch.model.entity.UserInfo;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;

@Slf4j
@Service
public class TermQueryService {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 精確查詢（查詢條件不會進行分詞，但是查詢內容可能會分詞，導致查詢不到）
     */
    public void termQuery() {
        try {
            // 構建查詢條件（注意：termQuery 支持多種格式查詢，如 boolean、int、double、string 等，這裏使用的是 string 的查詢）
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(QueryBuilders.termQuery("address.keyword", "北京市通州區"));
            // 創建查詢請求對象，將查詢對象配置到其中
            SearchRequest searchRequest = new SearchRequest("mydlq-user");
            searchRequest.source(searchSourceBuilder);
            // 執行查詢，然後處理響應結果
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            // 根據狀態和數據條數驗證是否返回了數據
            if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().totalHits > 0) {
                SearchHits hits = searchResponse.getHits();
                for (SearchHit hit : hits) {
                    // 將 JSON 轉換成對象
                    UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
                    // 輸出查詢信息
                    log.info(userInfo.toString());
                }
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

    /**
     * 多個內容在一個字段中進行查詢
     */
    public void termsQuery() {
        try {
            // 構建查詢條件（注意：termsQuery 支持多種格式查詢，如 boolean、int、double、string 等，這裏使用的是 string 的查詢）
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(QueryBuilders.termsQuery("address.keyword", "北京市豐臺區", "北京市昌平區", "北京市大興區"));
            // 創建查詢請求對象，將查詢對象配置到其中
            SearchRequest searchRequest = new SearchRequest("mydlq-user");
            searchRequest.source(searchSourceBuilder);
            // 執行查詢，然後處理響應結果
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            // 根據狀態和數據條數驗證是否返回了數據
            if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().totalHits > 0) {
                SearchHits hits = searchResponse.getHits();
                for (SearchHit hit : hits) {
                    // 將 JSON 轉換成對象
                    UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
                    // 輸出查詢信息
                    log.info(userInfo.toString());
                }
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

}

2、匹配查詢(match)

(1) Restful 操作示例
匹配查詢全部數據與分頁
匹配查詢符合條件的所有數據，並且設置以 salary 字段升序排序，並設置分頁：

GET mydlq-user/_search
{
"query": {
    "match_all": {}
},
"from": 0,
"size": 10,
"sort": [
    {
      "salary": {
        "order": "asc"
      }
    }
]
}

匹配查詢數據
匹配查詢地址爲通州區的數據：

GET mydlq-user/_search
{
"query": {
    "match": {
      "address": "通州區"
    }
}
}

詞語匹配查詢
詞語匹配進行查詢，匹配 address 中爲北京市通州區的員工信息：

GET mydlq-user/_search
{
"query": {
    "match_phrase": {
      "address": "北京市通州區"
    }
}
}

內容多字段查詢
查詢在字段 address、remark 中存在北京內容的員工信息：

GET mydlq-user/_search
{
"query": {
    "multi_match": {
      "query": "北京",
      "fields": ["address","remark"]
    }
}
}

(2) Java 代碼示例

import club.mydlq.elasticsearch.model.entity.UserInfo;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.MatchAllQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;

@Slf4j
@Service
public class MatchQueryService {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 匹配查詢符合條件的所有數據，並設置分頁
     */
    public Object matchAllQuery() {
        try {
            // 構建查詢條件
            MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
            // 創建查詢源構造器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(matchAllQueryBuilder);
            // 設置分頁
            searchSourceBuilder.from(0);
            searchSourceBuilder.size(3);
            // 設置排序
            searchSourceBuilder.sort("salary", SortOrder.ASC);
            // 創建查詢請求對象，將查詢對象配置到其中
            SearchRequest searchRequest = new SearchRequest("mydlq-user");
            searchRequest.source(searchSourceBuilder);
            // 執行查詢，然後處理響應結果
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            // 根據狀態和數據條數驗證是否返回了數據
            if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().totalHits > 0) {
                SearchHits hits = searchResponse.getHits();
                for (SearchHit hit : hits) {
                    // 將 JSON 轉換成對象
                    UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
                    // 輸出查詢信息
                    log.info(userInfo.toString());
                }
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

    /**
     * 匹配查詢數據
     */
    public Object matchQuery() {
        try {
            // 構建查詢條件
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(QueryBuilders.matchQuery("address", "*通州區"));
            // 創建查詢請求對象，將查詢對象配置到其中
            SearchRequest searchRequest = new SearchRequest("mydlq-user");
            searchRequest.source(searchSourceBuilder);
            // 執行查詢，然後處理響應結果
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            // 根據狀態和數據條數驗證是否返回了數據
            if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().totalHits > 0) {
                SearchHits hits = searchResponse.getHits();
                for (SearchHit hit : hits) {
                    // 將 JSON 轉換成對象
                    UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
                    // 輸出查詢信息
                    log.info(userInfo.toString());
                }
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

    /**
     * 詞語匹配查詢
     */
    public Object matchPhraseQuery() {
        try {
            // 構建查詢條件
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(QueryBuilders.matchPhraseQuery("address", "北京市通州區"));
            // 創建查詢請求對象，將查詢對象配置到其中
            SearchRequest searchRequest = new SearchRequest("mydlq-user");
            searchRequest.source(searchSourceBuilder);
            // 執行查詢，然後處理響應結果
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            // 根據狀態和數據條數驗證是否返回了數據
            if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().totalHits > 0) {
                SearchHits hits = searchResponse.getHits();
                for (SearchHit hit : hits) {
                    // 將 JSON 轉換成對象
                    UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
                    // 輸出查詢信息
                    log.info(userInfo.toString());
                }
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

    /**
     * 內容在多字段中進行查詢
     */
    public Object matchMultiQuery() {
        try {
            // 構建查詢條件
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(QueryBuilders.multiMatchQuery("北京市", "address", "remark"));
            // 創建查詢請求對象，將查詢對象配置到其中
            SearchRequest searchRequest = new SearchRequest("mydlq-user");
            searchRequest.source(searchSourceBuilder);
            // 執行查詢，然後處理響應結果
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            // 根據狀態和數據條數驗證是否返回了數據
            if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().totalHits > 0) {
                SearchHits hits = searchResponse.getHits();
                for (SearchHit hit : hits) {
                    // 將 JSON 轉換成對象
                    UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
                    // 輸出查詢信息
                    log.info(userInfo.toString());
                }
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

}

3、模糊查詢(fuzzy)

(1) Restful 操作示例
模糊查詢所有以三結尾的姓名

GET mydlq-user/_search
{
"query": {
    "fuzzy": {
      "name": "三"
    }
}
}

(2) Java 代碼示例

import club.mydlq.elasticsearch.model.entity.UserInfo;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.Fuzziness;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;

@Slf4j
@Service
public class FuzzyQueryService {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 模糊查詢所有以 “三” 結尾的姓名
     */
    public Object fuzzyQuery() {
        try {
            // 構建查詢條件
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(QueryBuilders.fuzzyQuery("name", "三").fuzziness(Fuzziness.AUTO));
            // 創建查詢請求對象，將查詢對象配置到其中
            SearchRequest searchRequest = new SearchRequest("mydlq-user");
            searchRequest.source(searchSourceBuilder);
            // 執行查詢，然後處理響應結果
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            // 根據狀態和數據條數驗證是否返回了數據
            if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().totalHits > 0) {
                SearchHits hits = searchResponse.getHits();
                for (SearchHit hit : hits) {
                    // 將 JSON 轉換成對象
                    UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
                    // 輸出查詢信息
                    log.info(userInfo.toString());
                }
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

}

4、範圍查詢(range)

(1) Restful 操作示例
查詢歲數 ≥ 30 歲的員工數據：

GET /mydlq-user/_search
{
"query": {
    "range": {
      "age": {
        "gte": 30
      }
    }
}
}

查詢生日距離現在 30 年間的員工數據：

GET mydlq-user/_search
{
"query": {
    "range": {
      "birthDate": {
        "gte": "now-30y"
      }
    }
}
}

(2) Java 代碼示例

import club.mydlq.elasticsearch.model.entity.UserInfo;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;

@Slf4j
@Service
public class RangeQueryService {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 查詢歲數 ≥ 30 歲的員工數據
     */
    public void rangeQuery() {
        try {
            // 構建查詢條件
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(QueryBuilders.rangeQuery("age").gte(30));
            // 創建查詢請求對象，將查詢對象配置到其中
            SearchRequest searchRequest = new SearchRequest("mydlq-user");
            searchRequest.source(searchSourceBuilder);
            // 執行查詢，然後處理響應結果
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            // 根據狀態和數據條數驗證是否返回了數據
            if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().totalHits > 0) {
                SearchHits hits = searchResponse.getHits();
                for (SearchHit hit : hits) {
                    // 將 JSON 轉換成對象
                    UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
                    // 輸出查詢信息
                    log.info(userInfo.toString());
                }
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

    /**
     * 查詢距離現在 30 年間的員工數據
     * [年(y)、月(M)、星期(w)、天(d)、小時(h)、分鐘(m)、秒(s)]
     * 例如：
     * now-1h 查詢一小時內範圍
     * now-1d 查詢一天內時間範圍
     * now-1y 查詢最近一年內的時間範圍
     */
    public void dateRangeQuery() {
        try {
            // 構建查詢條件
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            // includeLower（是否包含下邊界）、includeUpper（是否包含上邊界）
            searchSourceBuilder.query(QueryBuilders.rangeQuery("birthDate")
                    .gte("now-30y").includeLower(true).includeUpper(true));
            // 創建查詢請求對象，將查詢對象配置到其中
            SearchRequest searchRequest = new SearchRequest("mydlq-user");
            searchRequest.source(searchSourceBuilder);
            // 執行查詢，然後處理響應結果
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            // 根據狀態和數據條數驗證是否返回了數據
            if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().totalHits > 0) {
                SearchHits hits = searchResponse.getHits();
                for (SearchHit hit : hits) {
                    // 將 JSON 轉換成對象
                    UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
                    // 輸出查詢信息
                    log.info(userInfo.toString());
                }
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

}

5、通配符查詢(wildcard)

(1) Restful 操作示例
查詢所有以 “三” 結尾的姓名：

GET mydlq-user/_search
{
"query": {
    "wildcard": {
      "name.keyword": {
        "value": "*三"
      }
    }
}
}

(2) Java 代碼示例

import club.mydlq.elasticsearch.model.entity.UserInfo;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;

@Slf4j
@Service
public class WildcardQueryService {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 查詢所有以 “三” 結尾的姓名
     *
     * *：表示多個字符（0個或多個字符）
     * ?：表示單個字符
     */
    public Object wildcardQuery() {
        try {
            // 構建查詢條件
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(QueryBuilders.wildcardQuery("name.keyword", "*三"));
            // 創建查詢請求對象，將查詢對象配置到其中
            SearchRequest searchRequest = new SearchRequest("mydlq-user");
            searchRequest.source(searchSourceBuilder);
            // 執行查詢，然後處理響應結果
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            // 根據狀態和數據條數驗證是否返回了數據
            if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().totalHits > 0) {
                SearchHits hits = searchResponse.getHits();
                for (SearchHit hit : hits) {
                    // 將 JSON 轉換成對象
                    UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
                    // 輸出查詢信息
                    log.info(userInfo.toString());
                }
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

}

6、布爾查詢(bool)

(1) Restful 操作示例
查詢出生在 1990-1995 年期間，且地址在北京市昌平區、北京市大興區、北京市房山區的員工信息：

GET /mydlq-user/_search
{
"query": {
    "bool": {
      "filter": {
        "range": {
          "birthDate": {
            "format": "yyyy",
            "gte": 1990,
            "lte": 1995
          }
        }
      },
      "must": [
        {
          "terms": {
            "address.keyword": [
              "北京市昌平區",
              "北京市大興區",
              "北京市房山區"
            ]
          }
        }
      ]
    }
}
}

(2) Java 代碼示例

import club.mydlq.elasticsearch.model.entity.UserInfo;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;

@Slf4j
@Service
public class BoolQueryService {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    public Object boolQuery() {
        try {
            // 創建 Bool 查詢構建器
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            // 構建查詢條件
            boolQueryBuilder.must(QueryBuilders.termsQuery("address.keyword", "北京市昌平區", "北京市大興區", "北京市房山區"))
                    .filter().add(QueryBuilders.rangeQuery("birthDate").format("yyyy").gte("1990").lte("1995"));
            // 構建查詢源構建器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(boolQueryBuilder);
            // 創建查詢請求對象，將查詢對象配置到其中
            SearchRequest searchRequest = new SearchRequest("mydlq-user");
            searchRequest.source(searchSourceBuilder);
            // 執行查詢，然後處理響應結果
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            // 根據狀態和數據條數驗證是否返回了數據
            if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().totalHits > 0) {
                SearchHits hits = searchResponse.getHits();
                for (SearchHit hit : hits) {
                    // 將 JSON 轉換成對象
                    UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
                    // 輸出查詢信息
                    log.info(userInfo.toString());
                }
            }
        }catch (IOException e){
            log.error("",e);
        }
    }

}

七、聚合查詢操作示例

1、Metric 聚合分析

(1) Restful 操作示例
統計員工總數、工資最高值、工資最低值、工資平均工資、工資總和：

GET /mydlq-user/_search
{
"size": 0,
"aggs": {
    "salary_stats": {
      "stats": {
        "field": "salary"
      }
    }
}
}

統計員工工資最低值：

GET /mydlq-user/_search
{
"size": 0,
"aggs": {
    "salary_min": {
      "min": {
        "field": "salary"
      }
    }
}
}

統計員工工資最高值：

GET /mydlq-user/_search
{
"size": 0,
"aggs": {
    "salary_max": {
      "max": {
        "field": "salary"
      }
    }
}
}

統計員工工資平均值：

GET /mydlq-user/_search
{
"size": 0,
"aggs": {
    "salary_avg": {
      "avg": {
        "field": "salary"
      }
    }
}
}

統計員工工資總值：

GET /mydlq-user/_search
{
"size": 0,
"aggs": {
    "salary_sum": {
      "sum": {
        "field": "salary"
      }
    }
}
}

統計員工總數：

GET /mydlq-user/_search
{
"size": 0,
"aggs": {
    "employee_count": {
      "value_count": {
        "field": "salary"
      }
    }
}
}

統計員工工資百分位：

GET /mydlq-user/_search
{
"size": 0,
"aggs": {
    "salary_percentiles": {
      "percentiles": {
        "field": "salary"
      }
    }
}
}

(2) Java 代碼示例

import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.metrics.avg.ParsedAvg;
import org.elasticsearch.search.aggregations.metrics.max.ParsedMax;
import org.elasticsearch.search.aggregations.metrics.min.ParsedMin;
import org.elasticsearch.search.aggregations.metrics.percentiles.ParsedPercentiles;
import org.elasticsearch.search.aggregations.metrics.percentiles.Percentile;
import org.elasticsearch.search.aggregations.metrics.stats.ParsedStats;
import org.elasticsearch.search.aggregations.metrics.sum.ParsedSum;
import org.elasticsearch.search.aggregations.metrics.sum.SumAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.valuecount.ParsedValueCount;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;

@Slf4j
@Service
public class AggrMetricService {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * stats 統計員工總數、員工工資最高值、員工工資最低值、員工平均工資、員工工資總和
     */
    public Object aggregationStats() {
        String responseResult = "";
        try {
            // 設置聚合條件
            AggregationBuilder aggr = AggregationBuilders.stats("salary_stats").field("salary");
            // 查詢源構建器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.aggregation(aggr);
            // 設置查詢結果不返回，只返回聚合結果
            searchSourceBuilder.size(0);
            // 創建查詢請求對象，將查詢條件配置到其中
            SearchRequest request = new SearchRequest("mydlq-user");
            request.source(searchSourceBuilder);
            // 執行請求
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            // 獲取響應中的聚合信息
            Aggregations aggregations = response.getAggregations();
            // 輸出內容
            if (RestStatus.OK.equals(response.status()) || aggregations != null) {
                // 轉換爲 Stats 對象
                ParsedStats aggregation = aggregations.get("salary_stats");
                log.info("-------------------------------------------");
                log.info("聚合信息:");
                log.info("count：{}", aggregation.getCount());
                log.info("avg：{}", aggregation.getAvg());
                log.info("max：{}", aggregation.getMax());
                log.info("min：{}", aggregation.getMin());
                log.info("sum：{}", aggregation.getSum());
                log.info("-------------------------------------------");
            }
            // 根據具體業務邏輯返回不同結果，這裏爲了方便直接將返回響應對象Json串
            responseResult = response.toString();
        } catch (IOException e) {
            log.error("", e);
        }
        return responseResult;
    }

    /**
     * min 統計員工工資最低值
     */
    public Object aggregationMin() {
        String responseResult = "";
        try {
            // 設置聚合條件
            AggregationBuilder aggr = AggregationBuilders.min("salary_min").field("salary");
            // 查詢源構建器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.aggregation(aggr);
            searchSourceBuilder.size(0);
            // 創建查詢請求對象，將查詢條件配置到其中
            SearchRequest request = new SearchRequest("mydlq-user");
            request.source(searchSourceBuilder);
            // 執行請求
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            // 獲取響應中的聚合信息
            Aggregations aggregations = response.getAggregations();
            // 輸出內容
            if (RestStatus.OK.equals(response.status()) || aggregations != null) {
                // 轉換爲 Min 對象
                ParsedMin aggregation = aggregations.get("salary_min");
                log.info("-------------------------------------------");
                log.info("聚合信息:");
                log.info("min：{}", aggregation.getValue());
                log.info("-------------------------------------------");
            }
            // 根據具體業務邏輯返回不同結果，這裏爲了方便直接將返回響應對象Json串
            responseResult = response.toString();
        } catch (IOException e) {
            log.error("", e);
        }
        return responseResult;
    }

    /**
     * max 統計員工工資最高值
     */
    public Object aggregationMax() {
        String responseResult = "";
        try {
            // 設置聚合條件
            AggregationBuilder aggr = AggregationBuilders.max("salary_max").field("salary");
            // 查詢源構建器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.aggregation(aggr);
            searchSourceBuilder.size(0);
            // 創建查詢請求對象，將查詢條件配置到其中
            SearchRequest request = new SearchRequest("mydlq-user");
            request.source(searchSourceBuilder);
            // 執行請求
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            // 獲取響應中的聚合信息
            Aggregations aggregations = response.getAggregations();
            // 輸出內容
            if (RestStatus.OK.equals(response.status()) || aggregations != null) {
                // 轉換爲 Max 對象
                ParsedMax aggregation = aggregations.get("salary_max");
                log.info("-------------------------------------------");
                log.info("聚合信息:");
                log.info("max：{}", aggregation.getValue());
                log.info("-------------------------------------------");
            }
            // 根據具體業務邏輯返回不同結果，這裏爲了方便直接將返回響應對象Json串
            responseResult = response.toString();
        } catch (IOException e) {
            log.error("", e);
        }
        return responseResult;
    }

    /**
     * avg 統計員工工資平均值
     */
    public Object aggregationAvg() {
        String responseResult = "";
        try {
            // 設置聚合條件
            AggregationBuilder aggr = AggregationBuilders.avg("salary_avg").field("salary");
            // 查詢源構建器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.aggregation(aggr);
            searchSourceBuilder.size(0);
            // 創建查詢請求對象，將查詢條件配置到其中
            SearchRequest request = new SearchRequest("mydlq-user");
            request.source(searchSourceBuilder);
            // 執行請求
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            // 獲取響應中的聚合信息
            Aggregations aggregations = response.getAggregations();
            // 輸出內容
            if (RestStatus.OK.equals(response.status()) || aggregations != null) {
                // 轉換爲 Avg 對象
                ParsedAvg aggregation = aggregations.get("salary_avg");
                log.info("-------------------------------------------");
                log.info("聚合信息:");
                log.info("avg：{}", aggregation.getValue());
                log.info("-------------------------------------------");
            }
            // 根據具體業務邏輯返回不同結果，這裏爲了方便直接將返回響應對象Json串
            responseResult = response.toString();
        } catch (IOException e) {
            log.error("", e);
        }
        return responseResult;
    }

    /**
     * sum 統計員工工資總值
     */
    public Object aggregationSum() {
        String responseResult = "";
        try {
            // 設置聚合條件
            SumAggregationBuilder aggr = AggregationBuilders.sum("salary_sum").field("salary");
            // 查詢源構建器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.aggregation(aggr);
            searchSourceBuilder.size(0);
            // 創建查詢請求對象，將查詢條件配置到其中
            SearchRequest request = new SearchRequest("mydlq-user");
            request.source(searchSourceBuilder);
            // 執行請求
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            // 獲取響應中的聚合信息
            Aggregations aggregations = response.getAggregations();
            // 輸出內容
            if (RestStatus.OK.equals(response.status()) || aggregations != null) {
                // 轉換爲 Sum 對象
                ParsedSum aggregation = aggregations.get("salary_sum");
                log.info("-------------------------------------------");
                log.info("聚合信息:");
                log.info("sum：{}", String.valueOf((aggregation.getValue())));
                log.info("-------------------------------------------");
            }
            // 根據具體業務邏輯返回不同結果，這裏爲了方便直接將返回響應對象Json串
            responseResult = response.toString();
        } catch (IOException e) {
            log.error("", e);
        }
        return responseResult;
    }

    /**
     * count 統計員工總數
     */
    public Object aggregationCount() {
        String responseResult = "";
        try {
            // 設置聚合條件
            AggregationBuilder aggr = AggregationBuilders.count("employee_count").field("salary");
            // 查詢源構建器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.aggregation(aggr);
            searchSourceBuilder.size(0);
            // 創建查詢請求對象，將查詢條件配置到其中
            SearchRequest request = new SearchRequest("mydlq-user");
            request.source(searchSourceBuilder);
            // 執行請求
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            // 獲取響應中的聚合信息
            Aggregations aggregations = response.getAggregations();
            // 輸出內容
            if (RestStatus.OK.equals(response.status()) || aggregations != null) {
                // 轉換爲 ValueCount 對象
                ParsedValueCount aggregation = aggregations.get("employee_count");
                log.info("-------------------------------------------");
                log.info("聚合信息:");
                log.info("count：{}", aggregation.getValue());
                log.info("-------------------------------------------");
            }
            // 根據具體業務邏輯返回不同結果，這裏爲了方便直接將返回響應對象Json串
            responseResult = response.toString();
        } catch (IOException e) {
            log.error("", e);
        }
        return responseResult;
    }

    /**
     * percentiles 統計員工工資百分位
     */
    public Object aggregationPercentiles() {
        String responseResult = "";
        try {
            // 設置聚合條件
            AggregationBuilder aggr = AggregationBuilders.percentiles("salary_percentiles").field("salary");
            // 查詢源構建器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.aggregation(aggr);
            searchSourceBuilder.size(0);
            // 創建查詢請求對象，將查詢條件配置到其中
            SearchRequest request = new SearchRequest("mydlq-user");
            request.source(searchSourceBuilder);
            // 執行請求
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            // 獲取響應中的聚合信息
            Aggregations aggregations = response.getAggregations();
            // 輸出內容
            if (RestStatus.OK.equals(response.status()) || aggregations != null) {
                // 轉換爲 Percentiles 對象
                ParsedPercentiles aggregation = aggregations.get("salary_percentiles");
                log.info("-------------------------------------------");
                log.info("聚合信息:");
                for (Percentile percentile : aggregation) {
                    log.info("百分位：{}：{}", percentile.getPercent(), percentile.getValue());
                }
                log.info("-------------------------------------------");
            }
            // 根據具體業務邏輯返回不同結果，這裏爲了方便直接將返回響應對象Json串
            responseResult = response.toString();
        } catch (IOException e) {
            log.error("", e);
        }
        return responseResult;
    }

}

2、Bucket 聚合分析

(1) Restful 操作示例
按歲數進行聚合分桶，統計各個歲數員工的人數：

GET mydlq-user/_search
{
  "size": 0,
  "aggs": {
    "age_bucket": {
      "terms": {
        "field": "age",
        "size": "10"
      }
    }
  }
}

按工資範圍進行聚合分桶，統計工資在 3000-5000、5000-9000 和 9000 以上的員工信息：

GET mydlq-user/_search
{
  "aggs": {
    "salary_range_bucket": {
      "range": {
        "field": "salary",
        "ranges": [
          {
            "key": "低級員工",
            "to": 3000
          },{
            "key": "中級員工",
            "from": 5000,
            "to": 9000
          },{
            "key": "高級員工",
            "from": 9000
          }
        ]
      }
    }
  }
}

按照時間範圍進行分桶，統計 1985-1990 年和 1990-1995 年出生的員工信息：

GET mydlq-user/_search
{
  "size": 10,
  "aggs": {
    "date_range_bucket": {
      "date_range": {
        "field": "birthDate",
        "format": "yyyy",
        "ranges": [
          {
            "key": "出生日期1985-1990的員工",
            "from": "1985",
            "to": "1990"
          },{
            "key": "出生日期1990-1995的員工",
            "from": "1990",
            "to": "1995"
          }
        ]
      }
    }
  }
}

按工資多少進行聚合分桶，設置統計的最小值爲 0，最大值爲 12000，區段間隔爲 3000：

GET mydlq-user/_search
{
  "size": 0,
  "aggs": {
    "salary_histogram": {
      "histogram": {
        "field": "salary",
        "extended_bounds": {
          "min": 0,
          "max": 12000
        },
        "interval": 3000
      }
    }
  }
}

按出生日期進行分桶：

GET mydlq-user/_search
{
  "size": 0,
  "aggs": {
    "birthday_histogram": {
      "date_histogram": {
        "format": "yyyy",
        "field": "birthDate",
        "interval": "year"
      }
    }
  }
}

(2) Java 代碼示例

import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogramInterval;
import org.elasticsearch.search.aggregations.bucket.histogram.Histogram;
import org.elasticsearch.search.aggregations.bucket.range.Range;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.util.List;

@Slf4j
@Service
public class AggrBucketService {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 按歲數進行聚合分桶
     */
    public Object aggrBucketTerms() {
        try {
            AggregationBuilder aggr = AggregationBuilders.terms("age_bucket").field("age");
            // 查詢源構建器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.size(10);
            searchSourceBuilder.aggregation(aggr);
            // 創建查詢請求對象，將查詢條件配置到其中
            SearchRequest request = new SearchRequest("mydlq-user");
            request.source(searchSourceBuilder);
            // 執行請求
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            // 獲取響應中的聚合信息
            Aggregations aggregations = response.getAggregations();
            // 輸出內容
            if (RestStatus.OK.equals(response.status())) {
                // 分桶
                Terms byCompanyAggregation = aggregations.get("age_bucket");
                List<? extends Terms.Bucket> buckets = byCompanyAggregation.getBuckets();
                // 輸出各個桶的內容
                log.info("-------------------------------------------");
                log.info("聚合信息:");
                for (Terms.Bucket bucket : buckets) {
                    log.info("桶名：{} | 總數：{}", bucket.getKeyAsString(), bucket.getDocCount());
                }
                log.info("-------------------------------------------");
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

    /**
     * 按工資範圍進行聚合分桶
     */
    public Object aggrBucketRange() {
        try {
            AggregationBuilder aggr = AggregationBuilders.range("salary_range_bucket")
                    .field("salary")
                    .addUnboundedTo("低級員工", 3000)
                    .addRange("中級員工", 5000, 9000)
                    .addUnboundedFrom("高級員工", 9000);
            // 查詢源構建器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.size(0);
            searchSourceBuilder.aggregation(aggr);
            // 創建查詢請求對象，將查詢條件配置到其中
            SearchRequest request = new SearchRequest("mydlq-user");
            request.source(searchSourceBuilder);
            // 執行請求
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            // 獲取響應中的聚合信息
            Aggregations aggregations = response.getAggregations();
            // 輸出內容
            if (RestStatus.OK.equals(response.status())) {
                // 分桶
                Range byCompanyAggregation = aggregations.get("salary_range_bucket");
                List<? extends Range.Bucket> buckets = byCompanyAggregation.getBuckets();
                // 輸出各個桶的內容
                log.info("-------------------------------------------");
                log.info("聚合信息:");
                for (Range.Bucket bucket : buckets) {
                    log.info("桶名：{} | 總數：{}", bucket.getKeyAsString(), bucket.getDocCount());
                }
                log.info("-------------------------------------------");
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

    /**
     * 按照時間範圍進行分桶
     */
    public Object aggrBucketDateRange() {
        try {
            AggregationBuilder aggr = AggregationBuilders.dateRange("date_range_bucket")
                    .field("birthDate")
                    .format("yyyy")
                    .addRange("1985-1990", "1985", "1990")
                    .addRange("1990-1995", "1990", "1995");
            // 查詢源構建器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.size(0);
            searchSourceBuilder.aggregation(aggr);
            // 創建查詢請求對象，將查詢條件配置到其中
            SearchRequest request = new SearchRequest("mydlq-user");
            request.source(searchSourceBuilder);
            // 執行請求
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            // 獲取響應中的聚合信息
            Aggregations aggregations = response.getAggregations();
            // 輸出內容
            if (RestStatus.OK.equals(response.status())) {
                // 分桶
                Range byCompanyAggregation = aggregations.get("date_range_bucket");
                List<? extends Range.Bucket> buckets = byCompanyAggregation.getBuckets();
                // 輸出各個桶的內容
                log.info("-------------------------------------------");
                log.info("聚合信息:");
                for (Range.Bucket bucket : buckets) {
                    log.info("桶名：{} | 總數：{}", bucket.getKeyAsString(), bucket.getDocCount());
                }
                log.info("-------------------------------------------");
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

    /**
     * 按工資多少進行聚合分桶
     */
    public Object aggrBucketHistogram() {
        try {
            AggregationBuilder aggr = AggregationBuilders.histogram("salary_histogram")
                    .field("salary")
                    .extendedBounds(0, 12000)
                    .interval(3000);
            // 查詢源構建器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.size(0);
            searchSourceBuilder.aggregation(aggr);
            // 創建查詢請求對象，將查詢條件配置到其中
            SearchRequest request = new SearchRequest("mydlq-user");
            request.source(searchSourceBuilder);
            // 執行請求
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            // 獲取響應中的聚合信息
            Aggregations aggregations = response.getAggregations();
            // 輸出內容
            if (RestStatus.OK.equals(response.status())) {
                // 分桶
                Histogram byCompanyAggregation = aggregations.get("salary_histogram");
                List<? extends Histogram.Bucket> buckets = byCompanyAggregation.getBuckets();
                // 輸出各個桶的內容
                log.info("-------------------------------------------");
                log.info("聚合信息:");
                for (Histogram.Bucket bucket : buckets) {
                    log.info("桶名：{} | 總數：{}", bucket.getKeyAsString(), bucket.getDocCount());
                }
                log.info("-------------------------------------------");
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

    /**
     * 按出生日期進行分桶
     */
    public Object aggrBucketDateHistogram() {
        try {
            AggregationBuilder aggr = AggregationBuilders.dateHistogram("birthday_histogram")
                    .field("birthDate")
                    .interval(1)
                    .dateHistogramInterval(DateHistogramInterval.YEAR)
                    .format("yyyy");
            // 查詢源構建器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.size(0);
            searchSourceBuilder.aggregation(aggr);
            // 創建查詢請求對象，將查詢條件配置到其中
            SearchRequest request = new SearchRequest("mydlq-user");
            request.source(searchSourceBuilder);
            // 執行請求
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            // 獲取響應中的聚合信息
            Aggregations aggregations = response.getAggregations();
            // 輸出內容
            if (RestStatus.OK.equals(response.status())) {
                // 分桶
                Histogram byCompanyAggregation = aggregations.get("birthday_histogram");

                List<? extends Histogram.Bucket> buckets = byCompanyAggregation.getBuckets();
                // 輸出各個桶的內容
                log.info("-------------------------------------------");
                log.info("聚合信息:");
                for (Histogram.Bucket bucket : buckets) {
                    log.info("桶名：{} | 總數：{}", bucket.getKeyAsString(), bucket.getDocCount());
                }
                log.info("-------------------------------------------");
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

}

3、Metric 與 Bucket 聚合分析

(1) Restful 操作示例
按照員工歲數分桶、然後統計每個歲數員工工資最高值:

GET mydlq-user/_search
{
  "size": 0,
  "aggs": {
    "salary_bucket": {
      "terms": {
        "field": "age",
        "size": "10"
      },
      "aggs": {
        "salary_max_user": {
          "top_hits": {
            "size": 1,
            "sort": [
              {
                "salary": {
                  "order": "desc"
                }
              }
            ]
          }
        }
      }
    }
  }
}

(2) Java 代碼示例

import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.metrics.tophits.ParsedTopHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.util.List;

@Slf4j
@Service
public class AggrBucketMetricService {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * topHits 按歲數分桶、然後統計每個員工工資最高值
     */
    public Object aggregationTopHits() {
        try {
            AggregationBuilder testTop = AggregationBuilders.topHits("salary_max_user")
                    .size(1)
                    .sort("salary", SortOrder.DESC);
            AggregationBuilder salaryBucket = AggregationBuilders.terms("salary_bucket")
                    .field("age")
                    .size(10);
            salaryBucket.subAggregation(testTop);
            // 查詢源構建器
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.size(0);
            searchSourceBuilder.aggregation(salaryBucket);
            // 創建查詢請求對象，將查詢條件配置到其中
            SearchRequest request = new SearchRequest("mydlq-user");
            request.source(searchSourceBuilder);
            // 執行請求
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            // 獲取響應中的聚合信息
            Aggregations aggregations = response.getAggregations();
            // 輸出內容
            if (RestStatus.OK.equals(response.status())) {
                // 分桶
                Terms byCompanyAggregation = aggregations.get("salary_bucket");
                List<? extends Terms.Bucket> buckets = byCompanyAggregation.getBuckets();
                // 輸出各個桶的內容
                log.info("-------------------------------------------");
                log.info("聚合信息:");
                for (Terms.Bucket bucket : buckets) {
                    log.info("桶名：{}", bucket.getKeyAsString());
                    ParsedTopHits topHits = bucket.getAggregations().get("salary_max_user");
                    for (SearchHit hit:topHits.getHits()){
                        log.info(hit.getSourceAsString());
                    }
                }
                log.info("-------------------------------------------");
            }
        } catch (IOException e) {
            log.error("", e);
        }
    }

}

elasticsearch 基礎介紹及使用（high-level-client）

一、ElasticSearch 簡介

中文官方文檔鏈接

https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.6/java-rest-high-getting-started.html

二、ElasticSearch 基礎概念

三、SpringBoot 項目引入 ElasticSearch 依賴

1、Maven 引入相關依賴

2、ElasticSearch 連接配置

四、索引操作示例

五、文檔操作示例

六、查詢操作示例

1、精確查詢(term)

2、匹配查詢(match)

3、模糊查詢(fuzzy)

4、範圍查詢(range)

5、通配符查詢(wildcard)

6、布爾查詢(bool)

七、聚合查詢操作示例

1、Metric 聚合分析

2、Bucket 聚合分析

3、Metric 與 Bucket 聚合分析

公司剛入職了一名 Java 中級開發，短短 4 行代碼居然湊齊了 3 個 bug！我哭了~~

公衆號5月C#/.NET熱文一覽

git 下載大陸鏡像地址

idea 徹底刪除項目中子模塊

Mysql 事務原理簡單分析

elasticsearch 基礎介紹及使用（high-level-client）

Reason: Failed to determine suitable jdbc url 問題解決

Android 創建和解析 Json

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

elasticsearch 基礎介紹及使用 （high-level-client）

一、ElasticSearch 簡介

中文官方文檔鏈接

二、ElasticSearch 基礎概念

三、SpringBoot 項目引入 ElasticSearch 依賴

1、Maven 引入相關依賴

2、ElasticSearch 連接配置

四、索引操作示例

五、文檔操作示例

六、查詢操作示例

1、精確查詢(term)

2、匹配查詢(match)

3、模糊查詢(fuzzy)

4、範圍查詢(range)

5、通配符查詢(wildcard)

6、布爾查詢(bool)

七、聚合查詢操作示例

1、Metric 聚合分析

2、Bucket 聚合分析

3、Metric 與 Bucket 聚合分析

elasticsearch 基礎介紹及使用（high-level-client）