Spring Boot集成Elasticsearch全过程

示例文档：
Doc1: "Spring Boot integrates Elasticsearch"
Doc2: "Elasticsearch is powerful"

倒排索引：
"spring" → [Doc1]
"boot" → [Doc1]
"elasticsearch" → [Doc1, Doc2]
"powerful" → [Doc2]

| 操作类型  | 原生Client(ms) | Spring Data(ms) | 差异 |
|----------|---------------|----------------|------|
| 索引文档  | 45            | 52             | +15% |
| 精确查询 | 12            | 18             | +50% |
| 聚合查询  | 210           | 225            | +7%  |

<dependencies>
    <!-- Spring Data Elasticsearch -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
    </dependency>
    
    <!-- 用于测试 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    
    <!-- 可选：用于JSON处理 -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>
</dependencies>

spring:
  elasticsearch:
    uris: "http://localhost:9200"  # ES服务器地址
    username: "elastic"           # 7.x之后默认用户
    password: "yourpassword"      # 密码
    
    # 连接池配置（重要生产环境参数）
    connection-timeout: 1000ms    # 连接超时
    socket-timeout: 3000ms        # 套接字超时
    max-connection-per-route: 10  # 每路由最大连接数
    max-connections-total: 30     # 总最大连接数

import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.*;

@Document(indexName = "blog_articles")  // 指定索引名称
@Setting(shards = 3, replicas = 1)     // 定义分片和副本数
public class Article {
    
    @Id                                // 标记为文档ID
    private String id;
    
    @Field(type = FieldType.Text, analyzer = "ik_max_word")  // 使用IK中文分词
    private String title;
    
    @Field(type = FieldType.Keyword)   // 关键字类型不分词
    private String author;
    
    @Field(type = FieldType.Text, analyzer = "ik_smart")     // 搜索时使用智能分词
    private String content;
    
    @Field(type = FieldType.Date, format = DateFormat.date_hour_minute_second)
    private Date publishTime;
    
    @Field(type = FieldType.Integer)
    private Integer viewCount;
    
    // 嵌套类型示例
    @Field(type = FieldType.Nested)
    private List<Comment> comments;
    
    // 省略getter/setter和构造方法
}

// 嵌套对象定义
public class Comment {
    @Field(type = FieldType.Keyword)
    private String username;
    
    @Field(type = FieldType.Text)
    private String content;
    
    @Field(type = FieldType.Date)
    private Date createTime;
}

public interface ArticleRepository extends ElasticsearchRepository<Article, String> {
    
    // 方法名自动解析查询
    List<Article> findByAuthor(String author);
    
    // 分页查询
    Page<Article> findByTitleContaining(String title, Pageable pageable);
    
    // 使用@Query注解自定义DSL
    @Query("{\"match\": {\"title\": {\"query\": \"?0\"}}}")
    List<Article> customTitleSearch(String keyword);
    
    // 多条件组合查询
    List<Article> findByTitleAndAuthor(String title, String author);
    
    // 范围查询
    List<Article> findByPublishTimeBetween(Date start, Date end);
}

@SpringBootTest
public class ArticleRepositoryTest {
    
    @Autowired
    private ArticleRepository repository;
    
    @Test
    public void testCRUD() {
        // 创建索引（如果不存在）
        IndexOperations indexOps = repository.indexOps();
        if (!indexOps.exists()) {
            indexOps.create();
            indexOps.putMapping(Article.class);
        }
        
        // 1. 新增文档
        Article article = new Article();
        article.setTitle("Spring Boot集成Elasticsearch指南");
        article.setAuthor("技术达人");
        article.setContent("这是一篇详细介绍如何集成ES的教程...");
        article.setPublishTime(new Date());
        article.setViewCount(0);
        
        Article saved = repository.save(article);  // 自动生成ID
        System.out.println("保存成功，ID: " + saved.getId());
        
        // 2. 查询文档
        Optional<Article> byId = repository.findById(saved.getId());
        byId.ifPresent(a -> System.out.println("查询结果: " + a.getTitle()));
        
        // 3. 更新文档
        byId.ifPresent(a -> {
            a.setViewCount(100);
            repository.save(a);  // 使用相同ID即为更新
        });
        
        // 4. 删除文档
        repository.deleteById(saved.getId());
    }
}

@Autowired
private ElasticsearchOperations operations;  // 更底层的操作模板

public List<Article> complexSearch(String keyword, String author, Date startDate, Integer minViews) {
    // 构建布尔查询
    BoolQueryBuilder boolQuery = QueryBuilders.boolQuery()
        .must(QueryBuilders.matchQuery("title", keyword).boost(2.0f))  // 标题匹配，权重加倍
        .filter(QueryBuilders.termQuery("author", author))             // 精确匹配作者
        .should(QueryBuilders.matchQuery("content", keyword))          // 内容匹配
        .minimumShouldMatch(1);                                        // 至少满足一个should
    
    // 范围过滤
    if (startDate != null) {
        boolQuery.filter(QueryBuilders.rangeQuery("publishTime").gte(startDate));
    }
    if (minViews != null) {
        boolQuery.filter(QueryBuilders.rangeQuery("viewCount").gte(minViews));
    }
    
    // 构建完整查询
    NativeSearchQuery query = new NativeSearchQueryBuilder()
        .withQuery(boolQuery)
        .withSort(SortBuilders.fieldSort("publishTime").order(SortOrder.DESC))
        .withPageable(PageRequest.of(0, 10))  // 分页
        .withHighlightFields(                 // 高亮设置
            new HighlightBuilder.Field("title").preTags("<em>").postTags("</em>"),
            new HighlightBuilder.Field("content").fragmentSize(200))
        .build();
    
    SearchHits<Article> hits = operations.search(query, Article.class);
    
    // 处理高亮结果
    List<Article> results = new ArrayList<>();
    for (SearchHit<Article> hit : hits) {
        Article article = hit.getContent();
        // 处理标题高亮
        if (hit.getHighlightFields().containsKey("title")) {
            article.setTitle(hit.getHighlightFields().get("title").get(0));
        }
        // 处理内容高亮
        if (hit.getHighlightFields().containsKey("content")) {
            article.setContent(hit.getHighlightFields().get("content").stream()
                .collect(Collectors.joining("...")));
        }
        results.add(article);
    }
    
    return results;
}

public SearchPage<Article> searchWithPaging(String keyword, int page, int size) {
    // 构建查询条件
    QueryBuilder query = QueryBuilders.multiMatchQuery(keyword, "title", "content");
    
    // 分页和排序构建
    Pageable pageable = PageRequest.of(page, size, 
        Sort.by(Sort.Direction.DESC, "publishTime")
            .and(Sort.by(Sort.Direction.ASC, "viewCount")));
    
    NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
        .withQuery(query)
        .withPageable(pageable)
        .build();
    
    // 执行查询
    SearchHits<Article> hits = operations.search(searchQuery, Article.class);
    
    // 转换为Spring Data分页对象
    return SearchHitSupport.searchPageFor(hits, pageable);
}

// 使用示例
SearchPage<Article> result = searchWithPaging("Spring Boot", 0, 10);
System.out.println("总页数: " + result.getTotalPages());
System.out.println("总记录数: " + result.getTotalElements());
result.getContent().forEach(article -> {
    System.out.println(article.getTitle());
});

public Map<String, Long> authorArticleStats(Date startDate) {
    // 1. 构建基础查询
    BoolQueryBuilder query = QueryBuilders.boolQuery();
    if (startDate != null) {
        query.filter(QueryBuilders.rangeQuery("publishTime").gte(startDate));
    }
    
    // 2. 构建聚合
    TermsAggregationBuilder authorAgg = AggregationBuilders.terms("author_stats")
        .field("author.keyword")  // 注意使用.keyword字段
        .size(10)                // 返回前10位作者
        .order(BucketOrder.count(false))  // 按文档数降序
        .subAggregation(AggregationBuilders.avg("avg_views").field("viewCount"));
    
    // 3. 构建完整查询
    NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
        .withQuery(query)
        .addAggregation(authorAgg)
        .build();
    
    // 4. 执行查询
    SearchHits<Article> hits = operations.search(searchQuery, Article.class);
    ParsedStringTerms authorStats = hits.getAggregations().get("author_stats");
    
    // 5. 处理结果
    Map<String, Long> stats = new LinkedHashMap<>();
    for (Terms.Bucket bucket : authorStats.getBuckets()) {
        String author = bucket.getKeyAsString();
        long count = bucket.getDocCount();
        double avgViews = ((ParsedAvg) bucket.getAggregations().get("avg_views")).getValue();
        
        stats.put(author + " (平均阅读量: " + String.format("%.1f", avgViews) + ")", count);
    }
    
    return stats;
}

public void nestedAggregationExample() {
    // 1. 构建日期直方图聚合
    DateHistogramAggregationBuilder dateHistogram = AggregationBuilders.dateHistogram("by_publish_date")
        .field("publishTime")
        .calendarInterval(DateHistogramInterval.MONTH)  // 按月分组
        .format("yyyy-MM")                             // 格式化为年月
        .minDocCount(1);                               // 至少1个文档才显示
    
    // 2. 添加子聚合（按作者分组）
    TermsAggregationBuilder authorTerms = AggregationBuilders.terms("by_author")
        .field("author.keyword")
        .size(5);
    
    // 3. 在作者分组下再添加子聚合（平均阅读量）
    authorTerms.subAggregation(AggregationBuilders.avg("avg_views").field("viewCount"));
    dateHistogram.subAggregation(authorTerms);
    
    // 4. 构建查询
    NativeSearchQuery query = new NativeSearchQueryBuilder()
        .addAggregation(dateHistogram)
        .build();
    
    // 5. 执行并解析结果
    SearchHits<Article> hits = operations.search(query, Article.class);
    ParsedDateHistogram dateHistogramAgg = hits.getAggregations().get("by_publish_date");
    
    for (Histogram.Bucket dateBucket : dateHistogramAgg.getBuckets()) {
        String date = dateBucket.getKeyAsString();
        System.out.println("\n月份: " + date);
        
        ParsedStringTerms authorAgg = dateBucket.getAggregations().get("by_author");
        for (Terms.Bucket authorBucket : authorAgg.getBuckets()) {
            String author = authorBucket.getKeyAsString();
            double avgViews = ((ParsedAvg) authorBucket.getAggregations().get("avg_views")).getValue();
            
            System.out.printf("  作者: %-15s 文章数: %-5d 平均阅读量: %.1f\n", 
                author, authorBucket.getDocCount(), avgViews);
        }
    }
}

barChart
    title 各月份文章统计
    xAxis 月份
    yAxis 文章数
    series "技术达人"
    series "架构师"
    
    "2023-01": 15, 8
    "2023-02": 12, 10
    "2023-03": 18, 15

// 创建索引时指定生命周期策略
@Configuration
public class ElasticsearchConfig {
    
    @Bean
    public IndexOperations indexOperations(ElasticsearchOperations operations) {
        IndexOperations indexOps = operations.indexOps(Article.class);
        
        // 定义生命周期策略
        Map<String, Object> lifecyclePolicy = new HashMap<>();
        lifecyclePolicy.put("policy", new HashMap<String, Object>() {{
            put("phases", new HashMap<String, Object>() {{
                put("hot", new HashMap<String, Object>() {{
                    put("actions", new HashMap<String, Object>() {{
                        put("rollover", new HashMap<String, Object>() {{
                            put("max_size", "50GB");
                            put("max_age", "30d");
                        }});
                    }});
                }});
                put("delete", new HashMap<String, Object>() {{
                    put("min_age", "365d");
                    put("actions", new HashMap<String, Object>() {{
                        put("delete", new HashMap<>());
                    }});
                }});
            }});
        }});
        
        // 创建索引设置
        Settings settings = Settings.builder()
            .put("index.lifecycle.name", "article_policy")
            .put("index.lifecycle.rollover_alias", "blog_articles")
            .build();
        
        indexOps.create(settings, indexOps.createMapping(Article.class));
        return indexOps;
    }
}

// 动态调整索引设置
indexOps.putSettings(Settings.builder()
    .put("index.number_of_shards", 5)        // 根据数据量调整
    .put("index.number_of_replicas", 1)      // 生产环境建议≥1
    .put("index.refresh_interval", "30s")    // 降低刷新频率提高写入性能
    .build());

分片数 = max(数据节点数 × 1.5, 日志类数据总大小/30GB, 搜索类数据总大小/50GB)

@Field(type = FieldType.Text, 
       analyzer = "ik_max_word",
       searchAnalyzer = "ik_smart",
       fielddata = false,          // 避免对text字段启用fielddata
       norms = false,             // 如果不关心评分可以禁用
       indexOptions = IndexOptions.DOCS)  // 只索引文档不存储频率和位置
private String title;

// 优化前的查询
NativeSearchQuery slowQuery = new NativeSearchQueryBuilder()
    .withQuery(QueryBuilders.matchQuery("content", "Spring Boot"))
    .build();

// 优化后的查询
NativeSearchQuery fastQuery = new NativeSearchQueryBuilder()
    .withQuery(QueryBuilders.boolQuery()
        .must(QueryBuilders.matchQuery("title", "Spring Boot").boost(2.0f))
        .should(QueryBuilders.matchQuery("content", "Spring Boot"))
        .minimumShouldMatch(1))
    .withSourceFilter(new FetchSourceFilter(
        new String[]{"id", "title", "author", "publishTime"},  // 只返回必要字段
        null))
    .withPageable(PageRequest.of(0, 20, Sort.by("publishTime").descending()))
    .build();

// 批量插入优化
@Autowired
private ElasticsearchOperations operations;

public void bulkInsert(List<Article> articles) {
    List<IndexQuery> queries = articles.stream()
        .map(article -> new IndexQueryBuilder()
            .withId(article.getId())
            .withObject(article)
            .build())
        .collect(Collectors.toList());
    
    // 执行批量操作
    operations.bulkIndex(queries, Article.class);
    
    // 手动刷新（通常不需要，根据业务需求）
    operations.indexOps(Article.class).refresh();
}

// 使用缓存优化热点查询
@Cacheable(value = "articleCache", key = "#id")
public Article findByIdWithCache(String id) {
    return repository.findById(id).orElse(null);
}

@Service
public class BlogSearchService {
    
    @Autowired
    private ElasticsearchOperations operations;
    
    @Autowired
    private ArticleRepository repository;
    
    public SearchResult<Article> searchArticles(SearchRequest request) {
        // 1. 构建基础查询
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        
        // 关键词查询（多字段匹配）
        if (StringUtils.isNotBlank(request.getKeyword())) {
            boolQuery.must(QueryBuilders.multiMatchQuery(request.getKeyword(), 
                    "title^2", "content", "author")  // 标题权重加倍
                .type(MultiMatchQueryBuilder.Type.BEST_FIELDS)  // 最佳字段匹配
                .tieBreaker(0.3f));  // 字段间相关性平衡
        }
        
        // 作者过滤
        if (StringUtils.isNotBlank(request.getAuthor())) {
            boolQuery.filter(QueryBuilders.termQuery("author.keyword", request.getAuthor()));
        }
        
        // 标签过滤
        if (request.getTags() != null && !request.getTags().isEmpty()) {
            boolQuery.filter(QueryBuilders.termsQuery("tags.keyword", request.getTags()));
        }
        
        // 日期范围
        if (request.getStartDate() != null || request.getEndDate() != null) {
            RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("publishTime");
            if (request.getStartDate() != null) {
                rangeQuery.gte(request.getStartDate());
            }
            if (request.getEndDate() != null) {
                rangeQuery.lte(request.getEndDate());
            }
            boolQuery.filter(rangeQuery);
        }
        
        // 2. 构建高亮
        HighlightBuilder highlightBuilder = new HighlightBuilder()
            .field("title").preTags("<em class='highlight'>").postTags("</em>")
            .field("content").fragmentSize(200).numOfFragments(3);
        
        // 3. 构建完整查询
        NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
            .withQuery(boolQuery)
            .withPageable(PageRequest.of(request.getPage(), request.getSize()))
            .withSort(buildSort(request.getSortType()))
            .withHighlightBuilder(highlightBuilder)
            .build();
        
        // 4. 执行查询
        SearchHits<Article> hits = operations.search(searchQuery, Article.class);
        
        // 5. 处理结果
        List<Article> articles = new ArrayList<>();
        for (SearchHit<Article> hit : hits) {
            Article article = hit.getContent();
            // 处理高亮
            if (hit.getHighlightFields().containsKey("title")) {
                article.setTitle(hit.getHighlightFields().get("title").get(0));
            }
            if (hit.getHighlightFields().containsKey("content")) {
                article.setContent(String.join("...", hit.getHighlightFields().get("content")));
            }
            articles.add(article);
        }
        
        // 6. 返回分页结果
        return new SearchResult<>(
            articles,
            hits.getTotalHits(),
            request.getPage(),
            request.getSize(),
            hits.getMaxScore()
        );
    }
    
    private SortBuilder<?> buildSort(String sortType) {
        switch (sortType) {
            case "newest":
                return SortBuilders.fieldSort("publishTime").order(SortOrder.DESC);
            case "hottest":
                return SortBuilders.fieldSort("viewCount").order(SortOrder.DESC);
            case "most_commented":
                return SortBuilders.scriptSort(
                    ScriptBuilders.script("doc['comments'].size()"), 
                    ScriptSortBuilder.ScriptSortType.NUMBER).order(SortOrder.DESC);
            default:  // 默认按相关度
                return SortBuilders.scoreSort();
        }
    }
    
    // 搜索建议实现
    public List<String> suggestTitles(String prefix) {
        CompletionSuggestionBuilder suggestionBuilder = SuggestBuilders
            .completionSuggestion("title_suggest")
            .prefix(prefix)
            .size(5);
        
        SearchRequest request = new SearchRequest("blog_articles")
            .source(new SearchSourceBuilder()
                .suggest(new SuggestBuilder().addSuggestion("title_suggest", suggestionBuilder)));
        
        try {
            SearchResponse response = operations.getClient().search(request, RequestOptions.DEFAULT);
            return Arrays.stream(response.getSuggest()
                    .getSuggestion("title_suggest")
                    .getEntries().get(0)
                    .getOptions())
                .map(Suggest.Suggestion.Entry.Option::getText)
                .collect(Collectors.toList());
        } catch (IOException e) {
            throw new RuntimeException("搜索建议失败", e);
        }
    }
}

@RestController
@RequestMapping("/api/articles")
public class ArticleController {
    
    @Autowired
    private BlogSearchService searchService;
    
    @GetMapping("/search")
    public ResponseEntity<SearchResult<Article>> search(
            @RequestParam(required = false) String keyword,
            @RequestParam(required = false) String author,
            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date startDate,
            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd") Date endDate,
            @RequestParam(required = false) List<String> tags,
            @RequestParam(defaultValue = "relevance") String sort,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int size) {
        
        SearchRequest request = new SearchRequest(
            keyword, author, tags, startDate, endDate, sort, page, size);
        
        return ResponseEntity.ok(searchService.searchArticles(request));
    }
    
    @GetMapping("/suggest")
    public ResponseEntity<List<String>> suggestTitles(@RequestParam String prefix) {
        return ResponseEntity.ok(searchService.suggestTitles(prefix));
    }
    
    @GetMapping("/stats/authors")
    public ResponseEntity<Map<String, Long>> authorStats() {
        return ResponseEntity.ok(searchService.authorArticleStats(null));
    }
}

// 同义词分析器配置
@Configuration
public class SynonymConfig {
    
    @Bean
    public AnalysisPlugin analysisPlugin() {
        return new AnalysisPlugin() {
            @Override
            public List<PreConfiguredTokenFilter> getPreConfiguredTokenFilters() {
                return List.of(
                    PreConfiguredTokenFilter.singleton("synonym_filter", 
                        () -> new SynonymGraphTokenFilterFactory(
                            new IndexSettings(IndexModule.newIndexSettings(
                                IndexMetadata.builder("_na_").settings(Settings.builder()
                                    .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
                                    .build()).build(), Settings.EMPTY),
                                new AnalysisRegistry(null, null, null, null, null, null, null, null, null, null)),
                            null, "synonym_filter", Settings.builder()
                                .put("synonyms_path", "analysis/synonyms.txt")
                                .put("expand", "true")
                                .build())));
            }
        };
    }
}

// 实体类中使用同义词分析器
@Field(type = FieldType.Text, 
       analyzer = "synonym_analyzer",
       searchAnalyzer = "synonym_analyzer")
private String content;

Spring Boot, SB
微服务 => 分布式系统
ES, Elasticsearch

public List<Article> recommendArticles(String userId, String currentArticleId) {
    // 1. 获取用户历史行为
    List<UserBehavior> behaviors = behaviorService.getUserBehaviors(userId);
    
    // 2. 构建个性化查询
    BoolQueryBuilder query = QueryBuilders.boolQuery()
        .mustNot(QueryBuilders.idsQuery().addIds(currentArticleId))  // 排除当前文章
        
    // 基于标签的推荐
    if (!behaviors.isEmpty()) {
        List<String> preferredTags = extractPreferredTags(behaviors);
        query.should(QueryBuilders.termsQuery("tags.keyword", preferredTags).boost(2.0f));
    }
    
    // 基于作者的推荐
    List<String> preferredAuthors = extractPreferredAuthors(behaviors);
    if (!preferredAuthors.isEmpty()) {
        query.should(QueryBuilders.termsQuery("author.keyword", preferredAuthors).boost(1.5f));
    }
    
    // 3. 添加热门度因素
    query.should(QueryBuilders.rangeQuery("viewCount")
        .gte(1000)
        .boost(0.5f));
    
    // 4. 执行查询
    NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
        .withQuery(query)
        .withPageable(PageRequest.of(0, 5))
        .build();
    
    return operations.search(searchQuery, Article.class)
        .stream()
        .map(SearchHit::getContent)
        .collect(Collectors.toList());
}

<properties>
    <elasticsearch.version>7.17.3</elasticsearch.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>elasticsearch-rest-high-level-client</artifactId>
        <version>${elasticsearch.version}</version>
    </dependency>
</dependencies>

@Configuration
public class RestClientConfig extends AbstractElasticsearchConfiguration {
    
    @Override
    @Bean
    public RestHighLevelClient elasticsearchClient() {
        return new RestHighLevelClient(
            RestClient.builder(HttpHost.create("http://localhost:9200"))
                .setRequestConfigCallback(builder -> 
                    builder.setConnectTimeout(5000).setSocketTimeout(60000))
                .setHttpClientConfigCallback(httpClientBuilder -> 
                    httpClientBuilder.setDefaultCredentialsProvider(
                        new BasicCredentialsProvider() {{
                            setCredentials(AuthScope.ANY, 
                                new UsernamePasswordCredentials("elastic", "password"));
                        }})));
    }
}

@Component
public class ElasticsearchHealthChecker {
    
    @Autowired
    private RestHighLevelClient client;
    
    public Health checkClusterHealth() {
        try {
            ClusterHealthResponse response = client.cluster()
                .health(new ClusterHealthRequest(), RequestOptions.DEFAULT);
            
            return Health.status(response.getStatus().name())
                .withDetail("cluster_name", response.getClusterName())
                .withDetail("node_count", response.getNumberOfNodes())
                .withDetail("active_shards", response.getActiveShards())
                .build();
        } catch (IOException e) {
            return Health.down(e).build();
        }
    }
    
    public boolean testConnection() {
        try {
            return client.ping(RequestOptions.DEFAULT);
        } catch (IOException e) {
            return false;
        }
    }
}

// 批量插入优化示例
public void bulkInsertArticles(List<Article> articles) {
    List<IndexQuery> queries = articles.stream()
        .map(article -> new IndexQueryBuilder()
            .withId(article.getId())
            .withObject(article)
            .build())
        .collect(Collectors.toList());
    
    // 配置批量参数
    BulkOptions options = BulkOptions.builder()
        .withTimeout(Duration.ofMinutes(2))
        .withRefreshPolicy(RefreshPolicy.NONE)  // 不立即刷新
        .build();
    
    operations.bulkIndex(queries, options, Article.class);
}

// 创建索引时优化设置
Settings settings = Settings.builder()
    .put("index.refresh_interval", "30s")       // 降低刷新频率
    .put("index.translog.sync_interval", "5s")  // 事务日志同步间隔
    .put("index.number_of_replicas", 0)        // 初始加载时禁用副本
    .build();

indexOps.create(settings, indexOps.createMapping(Article.class));

// 启用慢查询日志
indexOps.putSettings(Settings.builder()
    .put("index.search.slowlog.threshold.query.warn", "10s")
    .put("index.search.slowlog.threshold.query.info", "5s")
    .put("index.search.slowlog.threshold.fetch.warn", "1s")
    .put("index.search.slowlog.threshold.fetch.info", "500ms")
    .build());

{
  "query": {
    "match": {
      "content": "Spring Boot"
    }
  },
  "size": 100
}

{
  "query": {
    "bool": {
      "must": [
        {"match": {"title": {"query": "Spring Boot", "boost": 2}}},
        {"match": {"content": "Spring Boot"}}
      ],
      "filter": [
        {"range": {"publishTime": {"gte": "now-1y/d"}}}
      ]
    }
  },
  "_source": ["id", "title", "author", "publishTime"],
  "size": 20,
  "sort": [{"viewCount": "desc"}]
}

// 向量字段映射
@Field(type = FieldType.Dense_Vector, dims = 512)
private float[] titleVector;

// 向量搜索实现
public List<Article> vectorSearch(float[] queryVector, int k) {
    KnnSearchBuilder knnSearch = new KnnSearchBuilder("titleVector", queryVector, k)
        .boost(0.9f);
    
    NativeSearchQuery query = new NativeSearchQueryBuilder()
        .withKnnSearch(knnSearch)
        .build();
    
    return operations.search(query, Article.class)
        .stream()
        .map(SearchHit::getContent)
        .collect(Collectors.toList());
}

spring:
  elasticsearch:
    uris: "https://localhost:9200"
    ssl:
      verification-mode: certificate  # 严格证书验证
    username: "elastic"
    password: "yourpassword"
    socket-keep-alive: true          # 保持长连接

resources:
  requests:
    memory: "4Gi"
    cpu: "2"
  limits:
    memory: "8Gi"
    cpu: "4"

volumeClaimTemplates:
  - metadata:
      name: elasticsearch-data
    spec:
      accessModes: [ "ReadWriteOnce" ]
      storageClassName: "ssd"
      resources:
        requests:
          storage: "100Gi"

// AWS Lambda示例
public class IndexUpdater implements RequestHandler<S3Event, Void> {
    
    private final ElasticsearchOperations operations = createElasticsearchTemplate();
    
    public Void handleRequest(S3Event event, Context context) {
        event.getRecords().forEach(record -> {
            String key = record.getS3().getObject().getKey();
            String content = downloadContentFromS3(key);
            Article article = parseContent(content);
            operations.save(article);
        });
        return null;
    }
}

// 使用ML模型生成搜索排名
public SearchResult<Article> smartSearch(String query, User user) {
    // 1. 基础相关性搜索
    SearchResult<Article> baseResults = basicSearch(query);
    
    // 2. 应用机器学习排序
    List<Article> rankedResults = mlRankingService.rerank(
        baseResults.getContent(),
        query,
        user.getPreferences());
    
    // 3. 返回重新排序的结果
    return new SearchResult<>(
        rankedResults,
        baseResults.getTotalElements(),
        baseResults.getPage(),
        baseResults.getSize(),
        baseResults.getMaxScore()
    );
}

// 图像+文本混合搜索
public List<Article> multimodalSearch(String textQuery, byte[] image) {
    // 1. 提取图像特征向量
    float[] imageVector = imageService.extractFeatures(image);
    
    // 2. 构建混合查询
    QueryBuilder textQueryBuilder = QueryBuilders.matchQuery("content", textQuery);
    KnnSearchBuilder imageKnn = new KnnSearchBuilder("image_vector", imageVector, 10);
    
    // 3. 执行混合搜索
    NativeSearchQuery query = new NativeSearchQueryBuilder()
        .withQuery(textQueryBuilder)
        .withKnnSearch(imageKnn)
        .build();
    
    return operations.search(query, Article.class)
        .stream()
        .map(SearchHit::getContent)
        .collect(Collectors.toList());
}