Elasticsearch学习总结（二）

xfgg

已于 2023-05-10 10:03:44 修改

阅读量796

点赞数

文章标签： elasticsearch 学习 java

于 2023-05-10 09:58:12 首次发布

本文链接：https://blog.youkuaiyun.com/qq_42337039/article/details/130573525

版权

本文讨论了在Java中使用Elasticsearch时遇到的挑战，包括集群配置、索引设计、查询性能、大数据处理、数据同步和安全问题。提出了配置集群的要点，如节点数量、分片和副本设置，以及如何通过Java代码创建索引并设置分片副本。同时，强调了查询优化和索引设计的重要性，以及集群监控和版本兼容的注意事项。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

JAVA使用ES常见的问题

使用Java与Elasticsearch（ES）结合时，可能会遇到以下问题：

集群配置问题：ES是一个分布式系统，需要正确配置集群，包括节点数量、分片数量、副本数量等。
索引设计问题：索引的设计需要考虑数据结构、字段类型、分词器等因素，不合理的设计可能会导致查询性能下降。
查询性能问题：ES的查询语法非常灵活，但是不同的查询方式对性能有很大影响，需要根据具体情况选择合适的查询方式。
数据量过大问题：ES可以处理大规模数据，但是当数据量过大时，需要考虑分片、副本、索引优化等问题，以保证查询性能。
数据同步问题：如果使用ES作为数据存储，需要考虑数据同步的问题，包括数据的增量同步、全量同步、数据一致性等。
安全问题：ES的安全性需要考虑，包括访问控制、数据加密、防火墙等。
版本兼容问题：ES的版本更新较快，需要注意版本兼容性，以避免出现不兼容的情况。

如何正确配置集群

配置正确的集群需要考虑以下几个方面：

节点数量：ES是一个分布式系统，需要至少有两个节点才能组成一个集群。通常情况下，建议至少有三个节点，以保证集群的高可用性。
分片数量：ES将索引分成多个分片，每个分片可以分布在不同的节点上。分片数量需要根据数据量和查询负载来确定，通常建议每个索引至少有两个分片。
副本数量：ES可以为每个分片创建多个副本，以提高集群的可用性和性能。副本数量需要根据节点数量和数据量来确定，通常建议每个分片至少有一个副本。
节点配置：每个节点的配置需要考虑硬件资源、网络带宽等因素。通常建议节点之间的网络带宽足够大，以保证数据的快速传输。
节点分布：节点的分布需要考虑数据的访问模式和负载均衡。通常建议将节点分布在不同的物理机器上，以避免单点故障。
集群监控：集群的监控需要实时监控节点的状态、负载、性能等指标，以及及时发现和解决问题。

以上是配置正确的集群需要考虑的几个方面，具体的配置需要根据实际情况来确定。

这里主要讲一些分片，副本和集群监控

分片和副本

ES中的分片是将索引分成多个部分，每个部分称为一个分片。每个分片都是一个独立的Lucene索引，它可以在集群中的任何节点上存储和处理。

ES中的分片有以下几个概念：

分片数：每个索引可以分成多个分片，分片数是在创建索引时指定的。分片数越多，可以存储的数据量就越大，但是每个分片的大小也会减小，可能会影响搜索性能。
副本数：每个分片可以有多个副本，副本数是在创建索引时指定的。副本可以提高搜索性能和可用性，因为它们可以在节点故障时提供备份。
分片路由：ES使用分片路由来确定哪个分片存储哪些文档。分片路由是根据文档ID计算的，因此相同ID的文档总是存储在同一个分片中。

在创建索引时可以指定分片数和副本数
例如，以下命令将创建一个名为“my_index”的索引，其中包含5个分片和1个副本：

PUT /my_index
{
  "settings": {
    "number_of_shards": 5,
    "number_of_replicas": 1
  }
}

可以使用以下命令查看索引的分片和副本信息

GET /my_index/_settings

可以使用以下命令将现有索引的分片数更改为10

PUT /my_index/_settings
{
  "number_of_shards": 10
}

注意：在创建索引后，不能更改分片数。如果需要更改分片数，必须重新创建索引并重新索引数据。

使用java设置分片数量和副本数量
创建es客户端

@Configuration
public class ElasticsearchConfig {

    @Bean
    public RestHighLevelClient restHighLevelClient() {
        RestClientBuilder builder = RestClient.builder(
                new HttpHost("localhost", 9200, "http"),
                new HttpHost("localhost", 9201, "http"));
        return new RestHighLevelClient(builder);
    }
}

上述代码中，我们创建了一个Elasticsearch客户端，连接到本地的两个节点（9200和9201）
配置分片副本和分片路由

public class ElasticsearchService {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    public void createIndex(String index) throws IOException {
        CreateIndexRequest request = new CreateIndexRequest(index);
        request.settings(Settings.builder()
                .put("index.number_of_shards", 3)
                .put("index.number_of_replicas", 2));
        request.mapping("properties", "title", "type=text");
        request.mapping("properties", "author", "type=text");
        request.mapping("properties", "price", "type=double");
        request.mapping("properties", "publish_date", "type=date");
        request.mapping("properties", "description", "type=text");
        request.mapping("properties", "tags", "type=keyword");
        request.mapping("properties", "stock", "type=integer");

        // 配置分片路由
        request.routingPartitionSize(2);

        restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
    }
}

在上述代码中，我们使用CreateIndexRequest来创建索引，并使用Settings来配置分片副本。在创建索引时，我们使用routingPartitionSize方法来配置分片路由，指定每个分片有两个路由。这样，每个分片就会被分成两个部分，每个部分都有一个副本，提高了数据的可靠性和查询效率。

使用分片副本和分片路由进行查询

public class ElasticsearchServiceTest {

    @Autowired
    private ElasticsearchService elasticsearchService;

    @Test
    public void testCreateIndex() throws IOException {
        elasticsearchService.createIndex("book");
    }
}

在上述代码中，我们调用ElasticsearchService的createIndex方法来创建索引。在创建索引过程中，会自动使用我们配置的分片副本和分片路由。

集群监控

做集群监控需要考虑以下几个方面：

节点状态监控：需要实时监控节点的状态，包括CPU使用率、内存使用率、磁盘使用率等指标，以及节点是否在线、是否可用等状态。
负载监控：需要实时监控节点的负载，包括查询请求量、索引请求量、网络带宽等指标，以及节点的负载均衡情况。
性能监控：需要实时监控节点的性能，包括查询响应时间、索引响应时间、缓存命中率等指标，以及节点的性能优化情况。
日志监控：需要实时监控节点的日志，包括错误日志、警告日志、信息日志等，以及及时发现和解决问题。
集群状态监控：需要实时监控集群的状态，包括节点数量、分片数量、副本数量等指标，以及集群的健康状态、可用性等。
告警监控：需要设置告警规则，当节点或集群出现异常时，及时发送告警通知，以便及时处理问题

这里主要采用Grafana监控
使用Grafana监控集群需要进行以下几个步骤：

安装Grafana：可以从Grafana官网下载安装包，根据操作系统进行安装。
安装Elasticsearch数据源插件：在Grafana中添加Elasticsearch数据源插件，可以从Grafana官网下载插件，也可以在Grafana中直接安装。
创建仪表盘：在Grafana中创建仪表盘，可以选择不同的图表类型，如折线图、柱状图、饼图等，也可以自定义图表。
添加数据源：在仪表盘中添加Elasticsearch数据源，需要填写Elasticsearch的地址、用户名、密码等信息。
添加面板：在仪表盘中添加面板，可以选择不同的指标，如节点状态、负载、性能等指标，也可以自定义指标。
设置告警：可以设置告警规则，当指标超过阈值时，发送告警通知。

以上是使用Grafana监控集群的一般步骤，具体的操作需要根据实际情况来确定。Grafana提供了丰富的图表和面板，可以根据需求进行自定义。

索引设计问题

在使用Elasticsearch时，索引的设计是非常重要的，它直接影响到搜索性能和结果的准确性。以下是一些Java使用ES时索引设计的建议：

确定索引的目的和数据类型：在创建索引之前，需要确定索引的目的和数据类型。例如，如果你的索引是用于搜索文本，那么你需要使用全文搜索的技术，如果你的索引是用于聚合数据，那么你需要使用聚合技术。
确定字段类型和映射：在创建索引时，需要确定每个字段的类型和映射。例如，如果你的字段是一个日期类型，那么你需要将它映射为日期类型，如果你的字段是一个字符串类型，那么你需要将它映射为字符串类型。
确定分词器和分析器：在创建索引时，需要确定分词器和分析器。分词器用于将文本分成单词，分析器用于对单词进行处理。例如，如果你的索引是用于搜索中文文本，那么你需要使用中文分词器和分析器。
确定索引的副本和分片：在创建索引时，需要确定索引的副本和分片。副本用于提高搜索性能和可用性，分片用于分散数据和提高搜索性能。
确定索引的更新策略：在创建索引时，需要确定索引的更新策略。例如，如果你的索引是用于实时搜索，那么你需要使用实时更新策略，如果你的索引是用于批量处理，那么你需要使用批量更新策略。

总之，索引的设计需要根据具体的业务需求和数据类型进行调整，以提高搜索性能和结果的准确性。

可以根据以下例子来选择

文本搜索索引：如果你的索引是用于搜索文本，那么你需要使用全文搜索的技术。例如，你可以使用Elasticsearch的全文搜索功能来创建一个文本搜索索引，该索引可以对文本进行分词、分析和搜索。

// 创建Elasticsearch客户端
RestHighLevelClient client = new RestHighLevelClient(
        RestClient.builder(new HttpHost("localhost", 9200, "http")));

// 创建索引请求
CreateIndexRequest request = new CreateIndexRequest("my_index");
request.settings(Settings.builder()
        .put("index.number_of_shards", 1)
        .put("index.number_of_replicas", 0)
);
request.mapping("my_type", "my_field", "type=text");

// 执行创建索引请求
CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);

// 处理创建索引结果
boolean acknowledged = createIndexResponse.isAcknowledged();

// 关闭Elasticsearch客户端
client.close();

在上面的代码中，我们首先创建了一个Elasticsearch客户端，然后创建了一个创建索引请求，并设置了索引的名称、分片和副本数，以及字段的映射。在这个例子中，我们将my_field字段映射为text类型，以支持全文搜索。然后我们执行了创建索引请求，并处理了创建索引结果。

聚合数据索引：如果你的索引是用于聚合数据，那么你需要使用聚合技术。例如，你可以使用Elasticsearch的聚合功能来创建一个聚合数据索引，该索引可以对数据进行聚合、分析和统计。

// 创建Elasticsearch客户端
RestHighLevelClient client = new RestHighLevelClient(
        RestClient.builder(new HttpHost("localhost", 9200, "http")));

// 创建索引请求
CreateIndexRequest request = new CreateIndexRequest("my_index");
request.settings(Settings.builder()
        .put("index.number_of_shards", 1)
        .put("index.number_of_replicas", 0)
);
request.mapping("my_type", "my_field", "type=keyword");

// 执行创建索引请求
CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);

// 创建文档请求
IndexRequest indexRequest = new IndexRequest("my_index", "my_type", "1");
indexRequest.source("my_field", "my_value");

// 执行创建文档请求
IndexResponse indexResponse = client.index(indexRequest, RequestOptions.DEFAULT);

// 创建聚合请求
SearchRequest searchRequest = new SearchRequest("my_index");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.aggregation(AggregationBuilders.terms("my_agg").field("my_field"));
searchRequest.source(searchSourceBuilder);

// 执行聚合请求
SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

// 处理聚合结果
Aggregations aggregations = searchResponse.getAggregations();
Terms terms = aggregations.get("my_agg");
for (Terms.Bucket bucket : terms.getBuckets()) {
    String key = bucket.getKeyAsString();
    long docCount = bucket.getDocCount();
    // 处理聚合结果
}

// 关闭Elasticsearch客户端
client.close();

在上面的代码中，我们首先创建了一个Elasticsearch客户端，然后创建了一个创建索引请求，并设置了索引的名称、分片和副本数，以及字段的映射。在这个例子中，我们将my_field字段映射为keyword类型，以支持聚合。然后我们执行了创建索引请求，并处理了创建索引结果。接着，我们创建了一个创建文档请求，并执行了创建文档请求。然后，我们创建了一个聚合请求，并设置了聚合条件。在这个例子中，我们使用了terms聚合，它会对指定字段进行分组，并统计每个分组的文档数量。然后我们执行了聚合请求，并处理了聚合结果。

地理位置索引：如果你的索引是用于搜索地理位置数据，那么你需要使用地理位置搜索的技术。例如，你可以使用Elasticsearch的地理位置搜索功能来创建一个地理位置索引，该索引可以对地理位置数据进行搜索和聚合。

// 创建Elasticsearch客户端
RestHighLevelClient client = new RestHighLevelClient(
        RestClient.builder(new HttpHost("localhost", 9200, "http")));

// 创建索引请求
CreateIndexRequest request = new CreateIndexRequest("my_index");
request.settings(Settings.builder()
        .put("index.number_of_shards", 1)
        .put("index.number_of_replicas", 0)
);
request.mapping("my_type", "location", "type=geo_point");

// 执行创建索引请求
CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);

// 创建文档请求
IndexRequest indexRequest = new IndexRequest("my_index", "my_type", "1");
indexRequest.source("location", "40.715, -74.011");

// 执行创建文档请求
IndexResponse indexResponse = client.index(indexRequest, RequestOptions.DEFAULT);

// 创建地理位置搜索请求
SearchRequest searchRequest = new SearchRequest("my_index");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.geoDistanceQuery("location").point(40.715, -74.011).distance(10, DistanceUnit.KILOMETERS));
searchRequest.source(searchSourceBuilder);

// 执行地理位置搜索请求
SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

// 处理地理位置搜索结果
SearchHits hits = searchResponse.getHits();
for (SearchHit hit : hits) {
    String sourceAsString = hit.getSourceAsString();
    // 处理搜索结果
}

// 关闭Elasticsearch客户端
client.close();

在上面的代码中，我们首先创建了一个Elasticsearch客户端，然后创建了一个创建索引请求，并设置了索引的名称、分片和副本数，以及字段的映射。在这个例子中，我们将location字段映射为geo_point类型，以支持地理位置搜索。然后我们执行了创建索引请求，并处理了创建索引结果。接着，我们创建了一个创建文档请求，并执行了创建文档请求。然后，我们创建了一个地理位置搜索请求，并设置了搜索条件。在这个例子中，我们使用了geoDistanceQuery查询，它会对指定字段进行地理位置搜索。然后我们执行了地理位置搜索请求，并处理了搜索结果。

时间序列索引：如果你的索引是用于搜索时间序列数据，那么你需要使用时间序列搜索的技术。例如，你可以使用Elasticsearch的时间序列搜索功能来创建一个时间序列索引，该索引可以对时间序列数据进行搜索和聚合。

// 创建Elasticsearch客户端
RestHighLevelClient client = new RestHighLevelClient(
        RestClient.builder(new HttpHost("localhost", 9200, "http")));

// 创建索引请求
CreateIndexRequest request = new CreateIndexRequest("my_index");
request.settings(Settings.builder()
        .put("index.number_of_shards", 1)
        .put("index.number_of_replicas", 0)
);
request.mapping("my_type", "timestamp", "type=date");

// 执行创建索引请求
CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);

// 创建文档请求
IndexRequest indexRequest = new IndexRequest("my_index", "my_type", "1");
indexRequest.source("timestamp", new Date(), "my_field", "my_value");

// 执行创建文档请求
IndexResponse indexResponse = client.index(indexRequest, RequestOptions.DEFAULT);

// 创建时间序列搜索请求
SearchRequest searchRequest = new SearchRequest("my_index");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.rangeQuery("timestamp").gte("now-1h").lte("now"));
searchRequest.source(searchSourceBuilder);

// 执行时间序列搜索请求
SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

// 处理时间序列搜索结果
SearchHits hits = searchResponse.getHits();
for (SearchHit hit : hits) {
    String sourceAsString = hit.getSourceAsString();
    // 处理搜索结果
}

// 关闭Elasticsearch客户端
client.close();```
在上面的代码中，我们首先创建了一个Elasticsearch客户端，然后创建了一个创建索引请求，并设置了索引的名称、分片和副本数，以及字段的映射。在这个例子中，我们将location字段映射为geo_point类型，以支持地理位置搜索。然后我们执行了创建索引请求，并处理了创建索引结果。接着，我们创建了一个创建文档请求，并执行了创建文档请求。然后，我们创建了一个地理位置搜索请求，并设置了搜索条件。在这个例子中，我们使用了geoDistanceQuery查询，它会对指定字段进行地理位置搜索。然后我们执行了地理位置搜索请求，并处理了搜索结果。

- 图像搜索索引：如果你的索引是用于搜索图像数据，那么你需要使用图像搜索的技术。例如，你可以使用Elasticsearch的图像搜索功能来创建一个图像搜索索引，该索引可以对图像进行搜索和聚合。

```java
// 创建Elasticsearch客户端
RestHighLevelClient client = new RestHighLevelClient(
        RestClient.builder(new HttpHost("localhost", 9200, "http")));

// 创建索引请求
CreateIndexRequest request = new CreateIndexRequest("my_index");
request.settings(Settings.builder()
        .put("index.number_of_shards", 1)
        .put("index.number_of_replicas", 0)
);
request.mapping("my_type", "my_image", "type=image");

// 执行创建索引请求
CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);

// 创建文档请求
IndexRequest indexRequest = new IndexRequest("my_index", "my_type", "1");
indexRequest.source("my_image", new File("/path/to/my/image"));

// 执行创建文档请求
IndexResponse indexResponse = client.index(indexRequest, RequestOptions.DEFAULT);

优化查询语句

优化查询语句可以从以下几个方面入手：

减少查询结果的数量：尽量减少查询结果的数量，可以通过设置合适的查询条件、过滤条件、分页等方式来实现。

SearchRequest searchRequest = new SearchRequest("index");
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.query(QueryBuilders.matchQuery("field", "value"));
sourceBuilder.size(10); // 设置查询结果数量为10
searchRequest.source(sourceBuilder);

使用合适的查询方式：ES提供了多种查询方式，如全文搜索、精确匹配、模糊匹配、范围查询等，根据实际需求选择合适的查询方式可以提高查询效率。

SearchRequest searchRequest = new SearchRequest("index");
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.query(QueryBuilders.termQuery("field", "value")); // 使用精确匹配查询
searchRequest.source(sourceBuilder);

使用合适的索引：索引是ES查询的基础，使用合适的索引可以提高查询效率。可以通过分析查询语句，选择合适的字段作为索引，或者使用多字段索引等方式来优化索引。

SearchRequest searchRequest = new SearchRequest("index");
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.query(QueryBuilders.matchQuery("field", "value"));
sourceBuilder.postFilter(QueryBuilders.rangeQuery("date").gte("2021-01-01")); // 使用范围查询过滤器
searchRequest.source(sourceBuilder);

避免使用过多的聚合操作：聚合操作是ES查询中比较耗时的操作，尽量避免使用过多的聚合操作，或者将聚合操作放在查询结果较少的情况下进行。

SearchRequest searchRequest = new SearchRequest("index");
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.query(QueryBuilders.matchQuery("field", "value"));
sourceBuilder.aggregation(AggregationBuilders.terms("agg").field("field")); // 使用聚合操作
sourceBuilder.size(0); // 设置查询结果数量为0，只返回聚合结果
searchRequest.source(sourceBuilder);

避免使用过多的排序操作：排序操作也是ES查询中比较耗时的操作，尽量避免使用过多的排序操作，或者将排序操作放在查询结果较少的情况下进行。

SearchRequest searchRequest = new SearchRequest("index");
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.query(QueryBuilders.matchQuery("field", "value"));
sourceBuilder.sort(new FieldSortBuilder("date").order(SortOrder.DESC)); // 使用排序操作
sourceBuilder.size(10); // 设置查询结果数量为10
searchRequest.source(sourceBuilder);

使用缓存：ES提供了缓存机制，可以将查询结果缓存起来，下次查询时直接从缓存中获取结果，可以提高查询效率。

SearchRequest searchRequest = new SearchRequest("index");
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.query(QueryBuilders.matchQuery("field", "value"));
sourceBuilder.size(10);
sourceBuilder.profile(true); // 开启查询分析
searchRequest.source(sourceBuilder);

SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
QueryProfileShardResults queryProfileShardResults = searchResponse.getProfileResults();
QueryProfile queryProfile = queryProfileShardResults.getQueryProfile("query"); // 获取查询分析结果
if (queryProfile != null) {
    QueryProfileTree queryProfileTree = queryProfile.getQueryProfileTree();
    queryProfileTree.setCache(true); // 开启缓存
}