Elasticsearch

1.什么是Elasticsearch

• 一款开源的强大的搜索引擎，可以帮助我们从海量数据中快速找到需要的内容。
• 同时Elasticsearch结合Kibana、Logstash、Beats，也就是ELK。被广泛应用在日志数据分析，实时监控等领域。

2.正向索引和倒排索引

Elasticsearch采用倒排索引：

• 文档（document）：每条数据就是一个文档（JSON）
• 词条（term）：文档按照语意分成的词语（对文档中的内容分词，得到的词语就是词条）
• 正向索引：基于文档Id创建索引。查询词条必须先找到文档，而后判断是否包含词条。
• 倒排索引：对文档内容分词，对词条创建索引，并记录词条所在文档的信息。查询时先根据词条查询到文档id，而后获取到文档。

3.中文分词IK分词器

安装：下载对应ES版本的IK分词器

解压zip到ES的plugin目录中

查看ES启动日志“loaded plugin”，安装完成

测试分词器（ik_max_word，ik_smart）

最少切分：ik_smart

最细切分：ik_max_word

字典：扩展&停用

4.索引库操作

mapping属性

mapping是对索引库中文档的约束，常见的mapping属性包括：

• type：字段数据类型

  • 字符串：text（可分词的文本）、keyword（精确值）
  • 数值：long、integer、short、byte、double、float
  • 布尔：boolean
  • 日期：date
  • 对象：object

• index：是否创建索引，默认为true

• analyzer：使用暗中分词器

• properties：改字段的子字段

5.RestClient操作索引库

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

maven依赖 :

<project>
  <dependencies>

    <dependency>
      <groupId>co.elastic.clients</groupId>
      <artifactId>elasticsearch-java</artifactId>
      <version>8.17.0</version>
    </dependency>

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.17.0</version>
    </dependency>

  </dependencies>
</project>

ES 8.X：CRUD

链接 RestClient & ElasticsearchClient

 // URL and API key
String serverUrl = "https://localhost:9200";
String apiKey = "VnVhQ2ZHY0JDZGJrU...";

// Create the low-level client
RestClient restClient = RestClient
    .builder(HttpHost.create(serverUrl))
    .setDefaultHeaders(new Header[]{
        new BasicHeader("Authorization", "ApiKey " + apiKey)
    })
    .build();

// Create the transport with a Jackson mapper
ElasticsearchTransport transport = new RestClientTransport(
    restClient, new JacksonJsonpMapper());

// And create the API client
ElasticsearchClient esClient = new ElasticsearchClient(transport);

// Use the client...

// Close the client, also closing the underlying transport object and network connections.
esClient.close();

创建倒排索引：

esClient.indices().create(c -> c
    .index("products")
);

索引文档：

Product product = new Product("bk-1", "City bike", 123.0);

IndexResponse response = esClient.index(i -> i
    .index("products")
    .id(product.getSku())
    .document(product)
);

logger.info("Indexed with version " + response.version());

获取文档：

GetResponse<Product> response = esClient.get(g -> g
    .index("products") 
    .id("bk-1"),
    Product.class      
);

if (response.found()) {
    Product product = response.source();
    logger.info("Product name " + product.getName());
} else {
    logger.info ("Product not found");
}

查询文档：

String searchText = "bike";

SearchResponse<Product> response = esClient.search(s -> s
        .index("products")
        .query(q -> q
            .match(t -> t
                .field("name")
                .query(searchText)
            )
        ),
    Product.class
);

更新文档：

Product product = new Product("bk-1", "City bike", 123.0);

esClient.update(u -> u
        .index("products")
        .id("bk-1")
        .upsert(product),
    Product.class
);

删除文档：

esClient.delete(d -> d.index("products").id("bk-1"));

删除索引：

esClient.indices().delete(d -> d
    .index("products")
);

ES7.X CRUD

操作：

Restclient client = new RestHighLevelClient(RestClient.builder(
    HttpHost.create("http://127.0.0.1:9200")
)));

// 新增
ProductionDoc productionDoc =new ProductionDoc();
IndexRequest indexRequest = new IndexRequest("index").id(productionDoc.getId().toString());
indexRequest.source(JSON.toJSONString(productionDoc), XContenType.JSON);
client.index(indexRequest, RequestOptions.DEFAULT)

// 查询 ById
GetRequest getRequest = new GetRequest("index", "id");
GetResponse getResponse = client.get(updateRequest, RequestOptions.DEFAULT)
log.info(getResponse.getSourceAsString());
// 更新
UpdateRequest updateRequest = new UpdateRequest("index", "id");
updateRequest.doc(
    "price", "101",
    "starName", "王"
)
client.update(updateRequest, RequestOptions.DEFAULT)
// 删除
DeleteRequest deleteRequest = new DeleteRequest("index", "id");
client.delete(deleteRequest, RequestOptions.DEFAULT)

//批量导入 bulk
BulkRequest bulkRequest = new BulkRequest();
bulkRequest.add(new IndexRequest("hotel").id("101").source("json str 1", XContenType.JSON));
bulkRequest.add(new IndexRequest("hotel").id("102").source("json str 2", XContenType.JSON));
client.bulk(bulkRequest, RequestOptions.DEFAULT)

6.DSL查询语法

DSL Query分类

Elasticsearch 提供了基于JSON的DSK（Domain Specific Language）来定义查询。常见的查询类型包括：

• 查询所有：查询出所有数据，一般用于测试：
  • match_all
• 全文检索（full text）查询：利用分词器对用户输入内容分词，然后去倒排索引库中匹配
  • match_query （根据一个字段查询）
  • multi_match_query （根据多个字段查询，参与查询字段越多，查询性能越差）
• 精确查询：根据精确词条值查询数据，一般是查找keyword、数值、日期、boolean等类型字段
  • ids （id）
  • range (数值范围)
  • term （数据值）
• 地理（geo）查询：根据经纬度查询：
  • geo_distance
  • geo_bounding_box
• 复合（compound）查询：复合查询可以将上述各种查询条件苏荷起来，合并查询条件：
  • bool
  • function_score

DSL Query基本语法

# GET /索引库名/_search
{ "query": { "查询类型": { "FIELD": "TEXT" }}}

# 查询所有 GET /索引库名/_search
{ "query": { "match_all": {}}}


# 全文检索-全部字段/单个字段 GET /索引库名/_search
{ "query": { "match": { "all": "TEXT" }}}
# 全文检索-指定字段 GET /索引库名/_search
{ "query": { "multi_match": { "query": "TEXT", "fields": ["FIELD1", "FIELD2"] }}}

# 精确查询 - term
{ "query": { "term": { "FIELD": {"value": "VALUE"}}}}

# 精确查询 - range
{ "query": { "term": { "FIELD": {"gte": "10", "lte": 20}}}}

DSL 相关性算分

Elasticsearch 提供了相关性算分机制，用于计算查询结果中每个文档的得分。
相关性算分机制会根据查询条件中指定的字段，计算出每个字段的权重，然后将这些权重相加，得到最终的文档得分。

• TF-IDF算法 是一种计算文档中词条权重的算法，它考虑了词条在文档中的出现频率和文档总数，以计算出每个词条的权重。
• BM25算法（高版本默认）是一种计算文档中词条权重的算法，它考虑了词条在文档中的出现频率、文档总数和词条在文档中的位置，以计算出每个词条的权重，会随着词频增大而增大，但曲线趋于平缓。

DSL Function Score Query

Function Score Query 是一种复合查询，它允许在查询条件中添加额外的函数来计算文档得分。

DSL Boolean Query

Boolean Query 是一种复合查询，它允许在查询条件中添加多个查询条件，并使用布尔运算符（AND、OR、NOT）来组合多个查询条件。

• must：必须匹配每个子查询，类似‘与’
• should：选择性匹配子查询，类似‘或’
• must_not：必须不匹配，不参与算分，类似‘非’
• filter：必须匹配，不参与算分