Elasticsearch 核心概念与 Java 客户端实战指南 | 极客日志

Javajava算法

Elasticsearch 核心概念与 Java 客户端实战指南

Elasticsearch 基于 Lucene 实现分布式全文检索，通过倒排索引提供毫秒级查询能力。深入解析 ES 集群架构、分片原理及 Java 客户端（RestHighLevelClient/Spring Data）配置实践。涵盖索引设计最佳实践、查询优化策略、批量操作处理、实时性控制及企业级电商搜索与日志分析案例。包含性能调优参数、监控告警方案及常见故障排查指南，帮助开发者构建稳定高效的搜索服务。

二进制发布于 2026/3/23更新于 2026/5/910 浏览

Elasticsearch 核心概念与 Java 客户端实战指南

Elasticsearch 核心概念与 Java 客户端实战指南

为什么选择 Elasticsearch？

从数据库的痛苦说起

在电商系统早期，我们尝试用 MySQL 做商品搜索。典型的模糊查询如下：

SELECT * FROM products 
WHERE name LIKE '%手机%' OR description LIKE '%手机%' OR tags LIKE '%手机%'
ORDER BY create_time DESC LIMIT 100 OFFSET 0;

这种写法存在明显痛点：

LIKE '%xxx%' 导致全表扫描，性能极差。
多字段 OR 查询效率低下。
无法支持复杂评分排序、分词、同义词或拼音搜索。

相比之下，Elasticsearch (ES) 基于 Lucene 构建，利用倒排索引实现毫秒级检索。其核心结构大致如下：

// 倒排索引逻辑示意
public class InvertedIndex {
    // 词项 -> 文档列表
    Map<String, List<Posting>> index = new HashMap<>();
    // "华为" -> [文档 1]
    // "手机" -> [文档 1, 文档 2]
}

性能对比测试（1000 万商品数据）：

场景	MySQL	Elasticsearch	性能差距
单字段模糊查询	3200ms	45ms	71 倍
多字段 OR 查询	8500ms	65ms	130 倍
复杂条件 + 排序	12000ms	85ms	141 倍

ES 核心架构解析

集群架构

@Configuration
public class IndexConfig {
    public void createProductIndex(RestHighLevelClient client) throws IOException {
        CreateIndexRequest request = new CreateIndexRequest("products");
        request.settings(Settings.builder()
            .put("index.number_of_shards", 3)
            .put("index.number_of_replicas", 1)
            .put("index.refresh_interval", "1s")
            .put("analysis.analyzer.default.type", "ik_max_word"));

        XContentBuilder mapping = JsonXContent.contentBuilder()
            .startObject().startObject("properties")
                .startObject("name")
                    .field("type", "text")
                    .field("analyzer", "ik_max_word")
                    .field("search_analyzer", "ik_smart")
                    .endObject()
                .startObject("price")
                    .field("type", "double")
                    .endObject()
            .endObject().endObject();
        request.mapping(mapping);
        client.indices().create(request, RequestOptions.DEFAULT);
    }
}

客户端	优点	缺点	推荐场景
RestHighLevelClient	官方维护，功能全	API 较复杂	新项目，需完整功能
Spring Data Elasticsearch	简洁，集成 Spring	版本兼容需注意	Spring Boot 项目

@Configuration
@Slf4j
public class ElasticsearchConfig {
    @Value("${elasticsearch.hosts:localhost:9200}")
    private String hosts;

    @Bean
    public RestHighLevelClient restHighLevelClient() {
        String[] hostArray = hosts.split(",");
        HttpHost[] httpHosts = new HttpHost[hostArray.length];
        for (int i = 0; i < hostArray.length; i++) {
            String[] hostPort = hostArray[i].split(":");
            httpHosts[i] = new HttpHost(hostPort[0].trim(), Integer.parseInt(hostPort[1].trim()), "http");
        }

        RestClientBuilder builder = RestClient.builder(httpHosts)
            .setRequestConfigCallback(config -> config
                .setConnectTimeout(5000)
                .setSocketTimeout(60000))
            .setHttpClientConfigCallback(client -> {
                client.setMaxConnTotal(100)
                      .setMaxConnPerRoute(50);
                return client;
            });
        return new RestHighLevelClient(builder);
    }
}

@Configuration
@EnableElasticsearchRepositories(basePackages = "com.example.repository")
public class SpringDataESConfig {
    @Document(indexName = "products")
    @Data
    public static class Product {
        @Id
        private String id;
        @Field(type = FieldType.Text, analyzer = "ik_max_word")
        private String name;
        @Field(type = FieldType.Double)
        private Double price;
    }

    public interface ProductRepository extends ElasticsearchRepository<Product, String> {
        List<Product> findByName(String name);
        Page<Product> findByPriceBetween(Double min, Double max, Pageable pageable);
    }
}

@Component
public class IndexLifecycleManager {
    public String getDailyIndex(String prefix) {
        return prefix + "-" + LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy.MM.dd"));
    }

    public void rolloverIndex() throws IOException {
        // 检查当前索引大小，超过阈值则创建新索引并切换别名
        // ... 省略具体实现细节
    }
}

{
  "mappings": {
    "dynamic": "strict",
    "properties": {
      "id": { "type": "keyword" },
      "vector": { "type": "dense_vector", "dims": 128 },
      "attributes": { "type": "nested" }
    }
  }
}

public SearchResponse searchByBool(String keyword, Double minPrice, String category) throws IOException {
    BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    if (StringUtils.isNotBlank(keyword)) {
        boolQuery.must(QueryBuilders.matchQuery("name", keyword).analyzer("ik_smart"));
    }
    if (minPrice != null) {
        boolQuery.filter(QueryBuilders.rangeQuery("price").gte(minPrice));
    }
    if (StringUtils.isNotBlank(category)) {
        boolQuery.filter(QueryBuilders.termQuery("category.keyword", category));
    }
    // 注意：过滤条件放入 filter 可被缓存，提升性能
    return executeSearch(boolQuery);
}

BulkProcessor.Listener listener = new BulkProcessor.Listener() {
    @Override
    public void afterBulk(long executionId, BulkRequest request, BulkResponse response) {
        if (response.hasFailures()) {
            log.error("Bulk 执行失败：{}", response.buildFailureMessage());
        }
    }
};
BulkProcessor processor = BulkProcessor.builder((req, bulkListener) -> client.bulkAsync(req, bulkListener), listener)
    .setBulkActions(1000)
    .setFlushInterval(TimeValue.timeValueSeconds(5))
    .build();

client.index(new IndexRequest("products").id("1").source(...).setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE));

// 构建 Bool 查询，组合关键词、过滤条件和排序
// 高亮配置：preTags="<em>", postTags="</em>"
// 聚合：价格区间、品牌分布、品类统计

// 按时间范围聚合错误数量
AggregationBuilder timeAgg = AggregationBuilders.dateHistogram("by_time")
    .field("@timestamp")
    .calendarInterval(DateHistogramInterval.HOUR);

# prometheus alerting_rules
- alert: ClusterHealthRed
  expr: elasticsearch_cluster_health_status{color="red"} == 1
  for: 5m

// 启用 profile 查看查询耗时详情
sourceBuilder.profile(true);
SearchRequest request = new SearchRequest(index).source(sourceBuilder);
SearchResponse response = client.search(request, RequestOptions.DEFAULT);