Elasticsearch查询Java实现映射文档

最新推荐文章于 2025-12-02 21:46:06 发布
原创 最新推荐文章于 2025-12-02 21:46:06 发布 · 678 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#elasticsearch #java

Elasticsearch查询Java实现映射文档

项目概述

本项目基于Elasticsearch 7.17.15版本实现了一套完整的日志查询和分析系统，采用了Spring Boot 2.7.18框架，提供了丰富的查询功能包括复合查询、高亮显示、异常分析等。

技术栈版本

  • Elasticsearch: 7.17.15
  • Spring Boot: 2.7.18
  • Spring Cloud: 3.1.8
  • Java: JDK 1.8

核心功能详细实现

1. 复合查询构建（BoolQueryBuilder）

项目实现了复杂的复合查询逻辑，支持must、should、must_not子句组合：

Java实现
/**
 * 构建复合查询条件
 * @param request 搜索请求参数
 * @return BoolQueryBuilder 复合查询构建器
 */
private BoolQueryBuilder buildQuery(LogSearchRequest request) {
    BoolQueryBuilder query = QueryBuilders.boolQuery();
  
    // 添加时间范围查询
    if (request.getStartTime() != null && request.getEndTime() != null) {
        RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("@timestamp")
            .gte(request.getStartTime().atZone(ZoneOffset.ofHours(0))
                .withZoneSameInstant(ZoneOffset.UTC).format(DATE_FORMAT))
            .lte(request.getEndTime().atZone(ZoneOffset.ofHours(0))
                .withZoneSameInstant(ZoneOffset.UTC).format(DATE_FORMAT));
        query.must(rangeQuery);
    }
  
    // 添加关键词搜索（MultiMatchQuery）
    if (request.getKeyword() != null && !request.getKeyword().trim().isEmpty()) {
        MultiMatchQueryBuilder multiMatchQuery = QueryBuilders.multiMatchQuery(request.getKeyword().trim())
            .field("message", 5.0f)      // message字段权重最高
            .field("stack_trace", 4.0f)  // 堆栈跟踪权重较高
            .field("class_name", 3.0f)   // 类名权重中等
            .field("method_name", 3.0f)  // 方法名权重中等
            .field("service_name", 2.0f) // 服务名权重较低
            .type(MultiMatchQueryBuilder.Type.BEST_FIELDS)
            .fuzziness("AUTO")           // 自动模糊匹配
            .prefixLength(2)             // 前缀长度
            .maxExpansions(50);          // 最大扩展数
        query.must(multiMatchQuery);
    }
  
    // 添加精确匹配条件
    if (request.getLevel() != null) {
        query.must(QueryBuilders.termQuery("level", request.getLevel()));
    }
  
    if (request.getService() != null) {
        query.must(QueryBuilders.termQuery("service_name", request.getService()));
    }
  
    // 添加服务列表过滤
    if (request.getServices() != null && !request.getServices().isEmpty()) {
        query.must(QueryBuilders.termsQuery("service_name", request.getServices()));
    }
  
    return query;
}
对应DSL语法
{
  "query": {
    "bool": {
      "must": [
        {
          "range": {
            "@timestamp": {
              "gte": "2023-01-01T00:00:00Z",
              "lte": "2023-01-31T23:59:59Z"
            }
          }
        },
        {
          "multi_match": {
            "query": "error keyword",
            "fields": ["message^5", "stack_trace^4", "class_name^3", "method_name^3", "service_name^2"],
            "type": "best_fields",
            "fuzziness": "AUTO",
            "prefix_length": 2,
            "max_expansions": 50
          }
        },
        {
          "term": {
            "level": "ERROR"
          }
        },
        {
          "term": {
            "service_name": "user-service"
          }
        }
      ],
      "should": [],
      "must_not": []
    }
  }
}
DSL语法说明

基本结构:

  • bool 查询容器包含 must、should、must_not、filter 子句
  • must 子句表示必须满足的条件（AND逻辑）
  • should 子句表示可选满足的条件（OR逻辑）
  • must_not 子句表示必须排除的条件（NOT逻辑）
  • filter 子句类似 must，但不参与评分计算

查询类型映射:

  • QueryBuilders.boolQuery() → "bool": { }
  • QueryBuilders.rangeQuery("@timestamp") → "range": { "@timestamp": { } }
  • QueryBuilders.multiMatchQuery() → "multi_match": { }
  • QueryBuilders.termQuery() → "term": { }
  • QueryBuilders.termsQuery() → "terms": { }

2. 高亮显示功能实现

项目实现了完整的Elasticsearch高亮功能，支持多字段高亮显示：

Java实现
/**
 * 配置高亮显示功能
 * @param searchSourceBuilder 搜索源构建器
 */
private void configureHighlighting(SearchSourceBuilder searchSourceBuilder) {
    HighlightBuilder highlightBuilder = new HighlightBuilder();
  
    // 为message字段添加高亮配置
    HighlightBuilder.Field highlightMessage = new HighlightBuilder.Field("message");
    highlightMessage.preTags("<em class=\"highlight\">");
    highlightMessage.postTags("</em>");
    highlightMessage.fragmentSize(600);    // 片段大小
    highlightMessage.numOfFragments(3);    // 片段数量
    highlightBuilder.field(highlightMessage);

    // 为stack_trace字段添加高亮配置
    HighlightBuilder.Field highlightStackTrace = new HighlightBuilder.Field("stack_trace");
    highlightStackTrace.preTags("<em class=\"highlight\">");
    highlightStackTrace.postTags("</em>");
    highlightStackTrace.fragmentSize(600); // 片段大小
    highlightStackTrace.numOfFragments(3); // 片段数量
    highlightBuilder.field(highlightStackTrace);
  
    searchSourceBuilder.highlighter(highlightBuilder);
}
对应DSL语法
{
  "query": {
    "bool": {
      "must": [
        {
          "multi_match": {
            "query": "error",
            "fields": ["message^5", "stack_trace^4", "class_name^3", "method_name^3", "service_name^2"]
          }
        }
      ]
    }
  },
  "highlight": {
    "fields": {
      "message": {
        "pre_tags": ["<em class=\"highlight\">"],
        "post_tags": ["</em>"],
        "fragment_size": 600,
        "number_of_fragments": 3
      },
      "stack_trace": {
        "pre_tags": ["<em class=\"highlight\">"],
        "post_tags": ["</em>"],
        "fragment_size": 600,
        "number_of_fragments": 3
      }
    }
  }
}
高亮DSL语法说明

高亮配置项:

  • fields - 需要高亮显示的字段列表
  • pre_tags - 高亮内容的前缀标签
  • post_tags - 高亮内容的后缀标签
  • fragment_size - 高亮片段的最大字符数
  • number_of_fragments - 返回的高亮片段数量

Java API映射:

  • HighlightBuilder → "highlight": { }
  • HighlightBuilder.Field("message") → "message": { }
  • .preTags() → "pre_tags": [ ]
  • .postTags() → "post_tags": [ ]
  • .fragmentSize() → "fragment_size": 600
  • .numOfFragments() → "number_of_fragments": 3

3. 聚合查询实现

系统实现了多种聚合查询功能，用于数据统计和分析：

Java实现
/**
 * 构建聚合查询
 * @return SearchSourceBuilder 包含聚合的搜索源
 */
private SearchSourceBuilder buildAggregations(SearchSourceBuilder searchSourceBuilder) {
    // 按服务名称聚合
    searchSourceBuilder.aggregation(AggregationBuilders
        .terms("services")
        .field("service_name")
        .size(100));
  
    // 按日志级别聚合
    searchSourceBuilder.aggregation(AggregationBuilders
        .terms("levels")
        .field("level")
        .size(10));
  
    // 按时间范围聚合（日聚合）
    searchSourceBuilder.aggregation(AggregationBuilders
        .date_histogram("time_buckets")
        .field("@timestamp")
        .calendarInterval(DateHistogramInterval.DAY)
        .format("yyyy-MM-dd"));
  
    return searchSourceBuilder;
}
对应DSL语法
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "services": {
      "terms": {
        "field": "service_name",
        "size": 100
      }
    },
    "levels": {
      "terms": {
        "field": "level",
        "size": 10
      }
    },
    "time_buckets": {
      "date_histogram": {
        "field": "@timestamp",
        "calendar_interval": "day",
        "format": "yyyy-MM-dd"
      }
    }
  }
}
聚合DSL语法说明

聚合类型:

  • terms 聚合 → 分组统计，类似于SQL的GROUP BY
  • date_histogram 聚合 → 按时间间隔分组
  • count 统计 → 自动计算每个桶的文档数量

Java API映射:

  • AggregationBuilders.terms("services") → "services": { "terms": { } }
  • AggregationBuilders.date_histogram("time_buckets") → "time_buckets": { "date_histogram": { } }
  • .field("service_name") → "field": "service_name"
  • .size(100) → "size": 100
  • .calendarInterval(DateHistogramInterval.DAY) → "calendar_interval": "day"
  • .format("yyyy-MM-dd") → "format": "yyyy-MM-dd"

4. 异常分析功能

项目实现了智能的异常分析功能，结合精确匹配和模糊搜索：

Java实现
/**
 * 异常原因分析方法 - 综合查询实现
 * @param definiteKeyword 精确查询关键字
 * @param possibleKeyword 可能的错误关键字（模糊匹配）
 * @return 分析结果
 */
public String analyzeError(String definiteKeyword, String possibleKeyword) {
    try {
        logger.info("Starting error analysis with definiteKeyword: {}, possibleKeyword: {}", 
            definiteKeyword, possibleKeyword);
    
        // 设置查询时间范围为最近7天
        LocalDateTime endTime = LocalDateTime.now();
        LocalDateTime startTime = endTime.minusDays(7);
    
        StringBuilder result = new StringBuilder();
        result.append("异常分析结果:\n\n");
    
        // 构建复合查询条件
        BoolQueryBuilder combinedQuery = QueryBuilders.boolQuery();
    
        // 添加时间范围查询
        RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("@timestamp")
            .gte(startTime.atZone(ZoneOffset.ofHours(0)).withZoneSameInstant(ZoneOffset.UTC).format(DATE_FORMAT))
            .lte(endTime.atZone(ZoneOffset.ofHours(0)).withZoneSameInstant(ZoneOffset.UTC).format(DATE_FORMAT));
        combinedQuery.must(rangeQuery);
    
        // 添加精确匹配条件（使用match_phrase确保短语完全匹配）
        if (definiteKeyword != null && !definiteKeyword.trim().isEmpty()) {
            result.append("1. 精确关键字 '").append(definiteKeyword).append("' 的查询条件:\n");
            BoolQueryBuilder exactQuery = QueryBuilders.boolQuery();
            exactQuery.should(QueryBuilders.matchPhraseQuery("message", definiteKeyword.trim()));
            exactQuery.should(QueryBuilders.matchPhraseQuery("stack_trace", definiteKeyword.trim()));
            exactQuery.should(QueryBuilders.matchPhraseQuery("class_name", definiteKeyword.trim()));
            exactQuery.should(QueryBuilders.matchPhraseQuery("method_name", definiteKeyword.trim()));
            exactQuery.should(QueryBuilders.matchPhraseQuery("service_name", definiteKeyword.trim()));
            exactQuery.minimumShouldMatch(1);
            combinedQuery.should(exactQuery);
        }
    
        // 添加模糊匹配条件（使用multi_match）
        if (possibleKeyword != null && !possibleKeyword.trim().isEmpty()) {
            result.append("2. 可能关键字 '").append(possibleKeyword).append("' 的查询条件:\n");
            MultiMatchQueryBuilder fuzzyQuery = QueryBuilders.multiMatchQuery(possibleKeyword.trim())
                .field("message", 5.0f)
                .field("stack_trace", 4.0f)
                .field("class_name", 3.0f)
                .field("method_name", 3.0f)
                .field("service_name", 2.0f)
                .type(MultiMatchQueryBuilder.Type.BEST_FIELDS)
                .fuzziness("AUTO")
                .prefixLength(2)
                .maxExpansions(50);
            combinedQuery.should(fuzzyQuery);
        }
    
        // 设置至少一个should子句需要匹配
        combinedQuery.minimumShouldMatch(1);
    
        // 执行复合查询
        Map<String, Object> combinedResult = searchLogs(combinedRequest, combinedQuery);
        // ... 处理结果逻辑
    
        return result.toString();
    } catch (Exception e) {
        logger.error("Error analysis failed", e);
        throw new RuntimeException("异常分析失败: " + e.getMessage(), e);
    }
}
对应DSL语法
{
  "query": {
    "bool": {
      "must": [
        {
          "range": {
            "@timestamp": {
              "gte": "2023-01-01T00:00:00Z",
              "lte": "2023-01-07T23:59:59Z"
            }
          }
        }
      ],
      "should": [
        {
          "bool": {
            "should": [
              {
                "match_phrase": {
                  "message": "exact error keyword"
                }
              },
              {
                "match_phrase": {
                  "stack_trace": "exact error keyword"
                }
              },
              {
                "match_phrase": {
                  "class_name": "exact error keyword"
                }
              },
              {
                "match_phrase": {
                  "method_name": "exact error keyword"
                }
              },
              {
                "match_phrase": {
                  "service_name": "exact error keyword"
                }
              }
            ],
            "minimum_should_match": 1
          }
        },
        {
          "multi_match": {
            "query": "fuzzy error keyword",
            "fields": ["message^5", "stack_trace^4", "class_name^3", "method_name^3", "service_name^2"],
            "type": "best_fields",
            "fuzziness": "AUTO",
            "prefix_length": 2,
            "max_expansions": 50
          }
        }
      ],
      "minimum_should_match": 1
    }
  }
}
异常分析DSL语法说明

匹配类型:

  • match_phrase → 短语精确匹配，要求所有词按照指定顺序连续出现
  • multi_match → 多字段模糊匹配
  • fuzziness: "AUTO" → 自动调整模糊匹配容错度
  • minimum_should_match → 控制should子句的最小匹配数

Java API映射:

  • QueryBuilders.matchPhraseQuery() → "match_phrase": { }
  • QueryBuilders.multiMatchQuery() → "multi_match": { }
  • .minimumShouldMatch(1) → "minimum_should_match": 1
  • .fuzziness("AUTO") → "fuzziness": "AUTO"
  • .prefixLength(2) → "prefix_length": 2
  • .maxExpansions(50) → "max_expansions": 50

5. 搜索排序和分页

Java实现
/**
 * 配置搜索排序和分页
 */
private void configureSearchSource(LogSearchRequest request, SearchSourceBuilder searchSourceBuilder) {
    // 设置分页
    searchSourceBuilder.from(request.getFrom());
    searchSourceBuilder.size(request.getSize());
  
    // 配置排序
    searchSourceBuilder.sort(SortBuilders.scoreSort().order(SortOrder.DESC));  // 按相关性得分排序
    searchSourceBuilder.sort("@timestamp", SortOrder.DESC);                    // 按时间倒序排序
  
    // 配置搜索源
    searchSourceBuilder.trackScores(true);  // 跟踪相关性得分
    searchSourceBuilder.timeout(TimeValue.timeValueSeconds(30));  // 设置超时时间
}
对应DSL语法
{
  "from": 0,
  "size": 20,
  "sort": [
    {
      "_score": {
        "order": "desc"
      }
    },
    {
      "@timestamp": {
        "order": "desc"
      }
    }
  ],
  "timeout": "30s",
  "track_scores": true
}

6. 常用查询类型对比

精确匹配 vs 模糊匹配
查询类型Java实现DSL语法适用场景
精确匹配QueryBuilders.termQuery("level", "ERROR")"term": { "level": "ERROR" }精确字段匹配
短语匹配QueryBuilders.matchPhraseQuery("message", "error occurred")"match_phrase": { "message": "error occurred" }短语精确匹配
模糊匹配QueryBuilders.matchQuery("message", "erorr")"match": { "message": "erorr" }文本相似度匹配
多字段匹配QueryBuilders.multiMatchQuery("error")"multi_match": { "query": "error" }跨字段搜索
范围查询类型
Java实现DSL语法示例
QueryBuilders.rangeQuery("@timestamp").gte("2023-01-01").lte("2023-01-31")"range": { "@timestamp": { "gte": "2023-01-01", "lte": "2023-01-31" } }时间范围
QueryBuilders.gteQuery("@timestamp").lt("now-7d")"range": { "@timestamp": { "gte": "now-7d" } }相对时间
QueryBuilders.numericRangeQuery("count").gte(100).lte(1000)"range": { "count": { "gte": 100, "lte": 1000 } }数值范围

性能优化和错误处理

1. 连接池配置优化

Java配置
/**
 * Elasticsearch客户端配置优化
 */
@Configuration
@EnableConfigurationProperties(LogProperties.class)
public class AppConfig {
  
    @Bean
    public RestHighLevelClient elasticsearchClient() {
        return new RestHighLevelClient(
            RestClient.builder(
                new HttpHost("localhost", 9200, "http"),
                new HttpHost("localhost", 9201, "http")
            )
            .setRequestConfigCallback(requestConfigBuilder -> 
                requestConfigBuilder
                    .setConnectTimeout(5000)      // 连接超时5秒
                    .setSocketTimeout(30000)      // 读取超时30秒
                    .setConnectionRequestTimeout(1000) // 连接请求超时1秒
            )
            .setHttpClientConfigCallback(httpClientBuilder -> 
                httpClientBuilder
                    .setMaxConnTotal(100)         // 最大连接数
                    .setMaxConnPerRoute(20)       // 每个路由最大连接数
            )
        );
    }
}
对应配置项说明
  • setConnectTimeout(5000) → 连接建立超时时间
  • setSocketTimeout(30000) → 数据读取超时时间
  • setMaxConnTotal(100) → 客户端最大连接池大小
  • setMaxConnPerRoute(20) → 每个主机最大连接数

2. 完整查询DSL示例

复杂查询DSL
{
  "index": "logstash-2023.01.01,logstash-2023.01.02",
  "from": 0,
  "size": 100,
  "query": {
    "bool": {
      "must": [
        {
          "range": {
            "@timestamp": {
              "gte": "2023-01-01T00:00:00Z",
              "lte": "2023-01-31T23:59:59Z"
            }
          }
        },
        {
          "multi_match": {
            "query": "database connection error",
            "fields": ["message^5", "stack_trace^4", "class_name^3"],
            "type": "best_fields",
            "fuzziness": "AUTO",
            "prefix_length": 2,
            "max_expansions": 50
          }
        }
      ],
      "must_not": [
        {
          "term": {
            "level": "DEBUG"
          }
        }
      ],
      "filter": [
        {
          "terms": {
            "service_name": ["user-service", "order-service"]
          }
        }
      ]
    }
  },
  "sort": [
    {
      "@timestamp": {
        "order": "desc"
      }
    }
  ],
  "highlight": {
    "fields": {
      "message": {
        "pre_tags": ["<em class=\"highlight\">"],
        "post_tags": ["</em>"],
        "fragment_size": 600,
        "number_of_fragments": 3
      },
      "stack_trace": {
        "pre_tags": ["<em class=\"highlight\">"],
        "post_tags": ["</em>"],
        "fragment_size": 600,
        "number_of_fragments": 3
      }
    }
  },
  "aggs": {
    "services": {
      "terms": {
        "field": "service_name",
        "size": 10
      }
    },
    "time_buckets": {
      "date_histogram": {
        "field": "@timestamp",
        "calendar_interval": "day",
        "format": "yyyy-MM-dd"
      }
    }
  },
  "timeout": "30s",
  "track_scores": true
}
对应的完整Java实现
/**
 * 完整的日志搜索实现
 */
public Map<String, Object> searchLogs(LogSearchRequest request) {
    try {
        // 构建索引模式
        String indexPattern = buildIndexPattern(request.getStartTime(), request.getEndTime());
        logger.info("Searching logs in index pattern: {}", indexPattern);

        // 构建复合查询
        BoolQueryBuilder query = buildQuery(request);

        // 配置搜索源
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(query);
        searchSourceBuilder.from(request.getFrom());
        searchSourceBuilder.size(request.getSize());
        searchSourceBuilder.sort(SortBuilders.scoreSort().order(SortOrder.DESC));
        searchSourceBuilder.sort("@timestamp", SortOrder.DESC);
        searchSourceBuilder.trackScores(true);
        searchSourceBuilder.timeout(TimeValue.timeValueSeconds(30));

        // 配置高亮
        if (request.getKeyword() != null && !request.getKeyword().trim().isEmpty()) {
            configureHighlighting(searchSourceBuilder);
        }

        // 配置聚合
        searchSourceBuilder.aggregation(AggregationBuilders
            .terms("services")
            .field("service_name")
            .size(10));
        searchSourceBuilder.aggregation(AggregationBuilders
            .date_histogram("time_buckets")
            .field("@timestamp")
            .calendarInterval(DateHistogramInterval.DAY)
            .format("yyyy-MM-dd"));

        // 构建搜索请求
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices(indexPattern.split(","));
        searchRequest.source(searchSourceBuilder);

        // 执行搜索
        SearchResponse response = esClient.search(searchRequest, RequestOptions.DEFAULT);
        return processSearchResponse(response, request);

    } catch (IOException e) {
        logger.error("Failed to search logs", e);
        throw new RuntimeException("ES search failed: " + e.getMessage(), e);
    }
}

3. 错误处理机制

异常处理DSL注意事项
/**
 * 错误处理机制
 */
private Map<String, Object> handleException(Exception e, SearchRequest searchRequest) {
    logger.error("Elasticsearch search failed", e);
  
    // 检查不同类型的异常
    if (e instanceof ConnectException) {
        throw new RuntimeException("ES服务连接失败，请检查网络和ES集群状态", e);
    } else if (e instanceof SocketTimeoutException) {
        throw new RuntimeException("ES查询超时，请优化查询条件或调整超时时间", e);
    } else if (e instanceof IndexNotFoundException) {
        throw new RuntimeException("索引不存在，请检查索引名称和权限", e);
    } else if (e instanceof SearchPhaseExecutionException) {
        throw new RuntimeException("查询语法错误，请检查查询条件", e);
    } else {
        throw new RuntimeException("未知错误: " + e.getMessage(), e);
    }
}
DSL查询验证
/**
 * 验证查询条件的正确性
 */
private void validateSearchRequest(LogSearchRequest request) {
    // 验证时间范围
    if (request.getStartTime() != null && request.getEndTime() != null) {
        if (request.getStartTime().isAfter(request.getEndTime())) {
            throw new IllegalArgumentException("开始时间不能晚于结束时间");
        }
    
        // 限制时间范围不超过30天
        if (request.getStartTime().isBefore(request.getEndTime().minusDays(30))) {
            throw new IllegalArgumentException("查询时间范围不能超过30天");
        }
    }
  
    // 验证分页参数
    if (request.getSize() > 1000) {
        throw new IllegalArgumentException("单页查询数量不能超过1000条");
    }
  
    // 验证关键词长度
    if (request.getKeyword() != null && request.getKeyword().length() > 100) {
        throw new IllegalArgumentException("关键词长度不能超过100个字符");
    }
}

配置说明

1. application.yml配置

# Elasticsearch配置
elasticsearch:
  hosts: localhost:9200,localhost:9201
  username: elastic
  password: password
  index-pattern: "logstash-*"
  connection-timeout: 5000
  socket-timeout: 30000
  max-conn-total: 100
  max-conn-per-route: 20

# 日志配置
logging:
  level:
    com.inspur.app.log.service.LogQueryService: DEBUG
    org.elasticsearch: WARN

2. 索引模式配置

Java实现
/**
 * 动态构建索引模式（基于时间范围）
 * @param start 开始时间
 * @param end 结束时间
 * @return 索引模式字符串
 */
private String buildIndexPattern(LocalDateTime start, LocalDateTime end) {
    Set<String> indices = new HashSet<>();
    LocalDateTime startDay = start.withHour(0).withMinute(0).withSecond(0).withNano(0);
    LocalDateTime endDay = end.withHour(0).withMinute(0).withSecond(0).withNano(0);
  
    // 如果结束时间大于当前时间，将结束时间设置为当前时间
    if (endDay.isAfter(LocalDateTime.now())) {
        endDay = LocalDateTime.now();
    }
  
    // 生成索引名称模式
    LocalDateTime current = startDay;
    while (!current.isAfter(endDay)) {
        String indexName = "logstash-" + current.format(INDEX_FORMAT);
        indices.add(indexName);
        current = current.plusDays(1);
    }
  
    return String.join(",", indices);
}

API接口文档

1. 日志搜索接口

/**
 * 日志搜索接口
 */
@RestController
@RequestMapping("/api/logs")
public class LogQueryController {
  
    /**
     * 搜索日志
     * @param request 搜索请求参数
     * @return 搜索结果
     */
    @PostMapping("/search")
    public ResponseEntity<Map<String, Object>> searchLogs(@RequestBody LogSearchRequest request) {
        try {
            validateSearchRequest(request);  // 验证请求参数
            Map<String, Object> result = logQueryService.searchLogs(request);
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            logger.error("Log search failed", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(Collections.singletonMap("error", "搜索失败: " + e.getMessage()));
        }
    }
  
    /**
     * 异常分析接口
     * @param request 分析请求参数
     * @return 分析结果
     */
    @PostMapping("/analyze-error")
    public ResponseEntity<Map<String, Object>> analyzeError(@RequestBody ErrorAnalysisRequest request) {
        try {
            Map<String, Object> result = logQueryService.analyzeError(request);
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            logger.error("Error analysis failed", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(Collections.singletonMap("error", "分析失败: " + e.getMessage()));
        }
    }
  
    /**
     * 获取过滤选项
     * @return 可用的过滤选项
     */
    @GetMapping("/filters")
    public ResponseEntity<Map<String, Object>> getFilters() {
        try {
            Map<String, Object> filters = new HashMap<>();
            filters.put("services", logQueryService.getDistinctServices());
            filters.put("levels", logQueryService.getDistinctLevels());
            return ResponseEntity.ok(filters);
        } catch (Exception e) {
            logger.error("Failed to get filters", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(Collections.singletonMap("error", "获取过滤选项失败: " + e.getMessage()));
        }
    }
}

最佳实践和注意事项

1. 查询性能优化

DSL优化建议:

  • 使用 filter 而不是 must 来执行精确匹配，避免计算相关性得分
  • 合理设置 size 参数，避免一次返回过多数据
  • 使用索引模式而不是通配符，提高查询效率
  • 为常用字段建立合适的mapping，包括analyzer设置

Java API优化:

// 好的做法：使用filter执行精确匹配
BoolQueryBuilder query = QueryBuilders.boolQuery();
query.filter(QueryBuilders.termQuery("level", "ERROR"));  // 不参与评分

// 避免的做法：在must中使用精确匹配
query.must(QueryBuilders.termQuery("level", "ERROR"));   // 参与评分，影响性能

2. 高亮功能使用

DSL高亮优化:

{
  "highlight": {
    "fields": {
      "message": {
        "pre_tags": ["<em>"],
        "post_tags": ["</em>"],
        "fragment_size": 200,      // 适当的片段大小
        "number_of_fragments": 1,  // 减少片段数量
        "require_field_match": false
      }
    }
  }
}

Java API对应:

// 优化高亮配置
HighlightBuilder.Field highlightField = new HighlightBuilder.Field("message");
highlightField.preTags("<em>");
highlightField.postTags("</em>");
highlightField.fragmentSize(200);          // 设置合适的片段大小
highlightField.numOfFragments(1);          // 只返回第一个片段
highlightField.requireFieldMatch(false);   // 不要求字段匹配

3. 安全考虑

DSL注入防护:

/**
 * 验证用户输入，防止DSL注入
 */
private String sanitizeKeyword(String keyword) {
    if (keyword == null) return null;
  
    // 移除潜在的DSL注入字符
    keyword = keyword.replaceAll("[{}\\[\\]<>:\"']", "");
  
    // 限制关键词长度
    if (keyword.length() > 100) {
        keyword = keyword.substring(0, 100);
    }
  
    return keyword;
}

DSL安全检查:

{
  "query": {
    "bool": {
      "must": [
        {
          "multi_match": {
            "query": "user input",  // 经过安全处理的输入
            "fields": ["message", "stack_trace"]
          }
        }
      ]
    }
  }
}

4. 监控和调试

查询调试信息:

/**
 * 输出调试信息
 */
private void logQueryDebug(SearchSourceBuilder searchSourceBuilder) {
    if (logger.isDebugEnabled()) {
        try {
            // 将SearchSourceBuilder转换为DSL格式
            XContentBuilder builder = XContentFactory.jsonBuilder();
            searchSourceBuilder.toXContent(builder, ToXContent.EMPTY_PARAMS);
            logger.debug("Generated DSL: {}", builder.string());
        } catch (IOException e) {
            logger.warn("Failed to generate DSL debug info", e);
        }
    }
}

总结

本项目实现了完整的Elasticsearch日志查询和分析系统，通过Java API和原始DSL语法的对比映射，为开发者提供了清晰的技术实现参考。文档中的代码示例和DSL语法说明可以直接用于类似的日志查询系统开发。

关键优势:

  1. 双重实现方式 - Java API和DSL语法对照，便于理解和调试
  2. 完整的错误处理 - 全面的异常捕获和用户友好的错误提示
  3. 性能优化实践 - 连接池配置、查询优化、索引管理
  4. 安全防护机制 - 输入验证、DSL注入防护、权限控制
  5. 可维护性设计 - 模块化实现、清晰注释、错误日志记录

通过这种方式，开发者可以深入理解Elasticsearch的底层机制，同时享受Java API的便利性和DSL的灵活性。

elasticsearch java api 离线文档
11-06
在Java API中，Elasticsearch提供了多种操作方法，包括索引创建、文档的增删改查、搜索查询、聚合分析等。以下是几个核心概念和功能的详细解释： 1. **客户端（Client）** 客户端是与Elasticsearch集群进行通信的...
elasticsearch Java代码实现
11-16
总的来说，Elasticsearch的Java实现涵盖了索引生命周期管理、查询构建和执行等多个方面，通过Java代码可以灵活地进行数据操作，实现高效的数据检索和分析。开发者需要对Elasticsearch的原理有深入理解，并掌握Java ...
es查询索引java_elasticsearch查询篇索引映射文档数据准备
weixin_42160424的博客
03-04 544
elasticsearch查询篇索引映射文档数据准备我们后面要讲elasticsearch查询，先来准备下索引，映射以及文档；我们先用Head插件建立索引film，然后建立映射{"properties": {"title": {"type": "text"},"publishDate": {"type": "date"},"content": {"type": "text"},"director"...
Elasticsearch——使用Java API实现ES中的索引、映射、文档操作
贝尔摩德苦艾酒
08-26 2万+
Elasticsearch——使用Java API实现ES中的索引、映射、文档操作
Elasticsearch 的索引管理与映射配置实战
热门推荐
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
10-06 5万+
本文介绍了 Elasticsearch 中索引与映射的基本概念及其重要性。通过详细的操作示例，阐述了如何创建、更新和删除索引，以及如何定义和调整映射以优化数据存储与查询性能。文章强调了选择适当数据类型和字段属性、动态映射调整的重要性，以及索引生命周期管理（ILM）对提升性能的作用。希望读者能够掌握这些基础知识，提升数据管理和搜索效率。
Elasticsearch 入门笔记：Java 实体映射与基础配置
pkhlll的博客
10-17 309
摘要：Elasticsearch中通过Java实体类映射索引结构，使用@Document指定索引名，@Id标记主键字段，@Field配置字段类型和分词规则（如Text类型配ik_max_word分词器）。项目需配置ES连接地址，并通过继承CrudRepository接口快速实现基本CRUD操作。实体类需实现Serializable接口，并添加@JsonIgnoreProperties注解避免反序列化异常。这种映射方式类似MySQL表与Java对象的ORM关系。（149字）
【ElasticSearch】ES Java API 实现地理位置搜索
weixin_48500080的博客
08-03 1229
ElasticSearch 实现 geo_point 和 geo_shape 两种类型的地理位置搜索，附带 Java API 代码
ElasticSearch（三）【索引、映射、文档】
Vinjcent
09-18 1103
索引 一个索引就是一个拥有几分相似特征的文档的集合。比如说，你可以有一个商品数据的索引，一个订单数据的索引，还有一个用户数据的索引。 一个索引由一个名字来标识（必须全部是小写字母的），并且当我们要对这个索引中的文档进行索引、搜索、更新和删除的时候，都要使用到这个名字 映射 映射是定义一个文档和它所包含的字段如何被存储和索引的过程。在默认配置下，ES可以根据插入的数据自动地创建mapping，也可以手动创建mapping。mapping中主要包括字段名字段类型等 文档 文档是索引中存储的一条条数据。
Elasticsearch Java客户端动态字段映射
Leon_Jinhai_Sun的博客
10-12 603
Elasticsearch Java客户端动态字段映射
elasticSearch创建索引库、映射、文档
醉殇姒若梦遗年 ツ的博客
04-13 3560
创建索引库 使用postman或curl这样的工具创建 put http://localhost:9200/索引库名称 参数: { "settings": { "index": { "number_of_shards": 1, "number_of_replicas": 0 } } } number_of_shards：设置分片的数量，在集群中通常设置多个分片，表示一个索引库将拆分成多片分别存储不同的结点，提
Elasticsearch索引映射定义
程序员小潘
07-16 1543
索引是文档的集合，文档是字段的集合，每个字段都有自己的数据类型。在映射数据时，需要创建一个映射定义，其中包含与文档相关的字段列表。映射定义还包括元数据字段，如_source字段，它自定义如何处理文档的关联元数据。
spring boot 2.7整合Elasticsearch Java client + ingest attachment实现文档解析
localhost
10-10 1593
spring boot 2.7整合Elasticsearch Java client并实现文档解析
基于Elasticsearch Java API的参考手册
04-29
**Elasticsearch Java API详解** Elasticsearch是一个分布式、RESTful风格的搜索和数据分析引擎，广泛应用于大数据领域的实时分析和信息检索。Java API是Elasticsearch官方提供的与Elasticsearch服务器进行交互的...
使用java开发ElasticSearch Demo，整合了easy-es，并在mybatisplus的拦截器中，完成数据同步
11-05
首先，easy-es是一个轻量级的Java框架，它封装了ElasticSearch的底层操作，简化了ElasticSearch的接口调用，使得开发者可以更加聚焦于业务逻辑的实现，而不需要深入底层的复杂操作。其次，MyBatisPlus是基于MyBatis...
Docker下安装ES和kibana详细教程
yohann1991的博客
12-02 278
最近工作需要，原来把项目日志数据存入mysql，导致mysql宕机，现在想着试试把日志数据存入es中，减轻mysql压力，以下是本人在测试环境的操作过程。下面是详细的步骤，包含创建网络、创建卷、运行 ES 和运行 Kibana。以上就是ES和kibana的安装过程，希望对读者有帮助。
SpringBoot的@Scheduled和@Schedules有什么区别
2509_94189991的博客
11-30 995
对于更复杂的需求，比如调整线程池大小或者设置线程名称前缀等，你可以通过自定义来进行配置。Spring提供了几种内置的调度器实现，如和。@Override@Override@Override// 自定义异常处理逻辑。
Elastic Stack梳理：深度解析Elasticsearch分布式查询机制与相关性算分优化实践
Wang的专栏
12-02 982
分布式搜索中的Elasticsearch面临查询流程复杂性和相关性算分失真两大挑战。Query-Then-Fetch机制通过两阶段处理：Query阶段各分片独立计算并返回Top N文档，Fetch阶段聚合完整数据。分片本地统计导致BM25算法算分偏差，解决方案包括单分片模式、DFS查询模式（预收集全局统计量）和混合方案。NestJS集成示例展示了基础检索和DFS算分修正的实现。关键点在于分片选择必须覆盖所有ID，深分页需调整参数，DFS模式虽提升算分准确性但增加性能开销。
Canvas架构手记 08 副作用与同步 | 不可变更新 | 调试与错误边界 | ESLint
最新发布
im_AMBER的博客
12-02 836
在分布式系统中，“多客户端同步” 指多个客户端（比如不同用户的浏览器、不同设备）需要共享同一个 “全局状态”（比如聊天房间的消息、协作文档的内容），且任何一个客户端对状态的修改，都要同步到其他所有客户端。你提供的ChatRoom多个用户的ChatRoom组件连接到同一个聊天服务端，需要同步聊天消息、在线状态等。“状态同步契约” 是客户端与服务端（或客户端之间）约定的 “状态同步规则”你的ChatRoom组件通过useEffect。
Elasticsearch 完全指南：原理、优势与应用场景
u011265143的专栏
11-29 1491
Elasticsearch 是一个基于 Apache Lucene 构建的开源、分布式、RESTful 搜索和分析引擎。它是 Elastic Stack（ELK Stack）的核心组件，由 Elastic 公司开发和维护。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值