SpringBoot项目es索引管理

创建索引

/**
     * 创建es索引
     *
     * @param goodsList 商品列表
     */
    private BulkResponse createIndex(List<SearchProductDTO> goodsList) throws IOException {
        boolean indexExist = elasticsearchClient.indices().exists(ExistsRequest.of(builder -> builder.index(DomainUrlUtil.ES_INDEX_NAME))).value();
        //聚合查询最大窗口数
        elasticsearchClient.cluster().putSettings(builder -> builder.persistent("search.max_buckets", JsonData.of(1000000)));

        if (!indexExist) {
            //分词类型设置
            IndexSettingsAnalysis indexSettingsAnalysis = IndexSettingsAnalysis.of(builder -> builder
                    //保存索引的分词类型
                    .analyzer("default", new Analyzer("type", JsonData.fromJson("{\"type\":\"ik_max_word\"}")))
                    //搜索词分词类型
                    .analyzer("default_search", new Analyzer("type", JsonData.fromJson("{\"type\":\"ik_smart\"}"))));
            IndexSettings indexSettings = IndexSettings.of(builder -> builder.analysis(indexSettingsAnalysis)
                    //最大查询数据量
                    .maxResultWindow(1000000));
            CreateIndexRequest createIndexRequest = CreateIndexRequest.of(builder ->
                    builder.index(DomainUrlUtil.ES_INDEX_NAME).settings(indexSettings)
            );

            elasticsearchClient.indices().create(createIndexRequest);
        }

        //构造批量请求参数
        List<BulkOperation> bulkOperationList = new ArrayList<>();
        goodsList.forEach(goods -> {
            IndexOperation<Object> indexOperation = IndexOperation.of(builder -> builder.id(goods.getGoodsId()).document(goods));
            BulkOperation bulkOperation = BulkOperation.of(builder -> builder.index(indexOperation));
            bulkOperationList.add(bulkOperation);
        });

        //批量请求
        BulkRequest bulkRequest = BulkRequest.of(builder -> builder.index(DomainUrlUtil.ES_INDEX_NAME).operations(bulkOperationList));

        //执行
        return elasticsearchClient.bulk(bulkRequest);
    }

删除索引

    /**
     * 删除索引
     */
    private void deleteByQuery() throws IOException {
        boolean indexExist = elasticsearchClient.indices().exists(ExistsRequest.of(builder -> builder.index(DomainUrlUtil.ES_INDEX_NAME))).value();
        if (indexExist) {
            //索引存在，删除索引中的数据
            elasticsearchClient.deleteByQuery(DeleteByQueryRequest.of(builder ->
                    builder.index(DomainUrlUtil.ES_INDEX_NAME)
                            .conflicts(Conflicts.Proceed)
                            .query(Query.of(builder1 ->
                                    builder1.matchAll(MatchAllQuery.of(builder2 -> builder2))))));
        }
    }

查询满足条件的数据

 /**
     * 查询满足条件的数据
     *
     * @param categoryId 分类id
     * @param keyword    关键词
     * @return 店铺id集合
     */
    public List<Long> searchStoreIdsByEs(Integer categoryId, String keyword) {
        List<Long> result = new ArrayList<>();//返回数据

        //搜索条件构造
        BoolQuery.Builder boolQueryBuilder = QueryBuilders.bool();
        SearchConditionDTO qc = new SearchConditionDTO();
        if (!StringUtil.isNullOrZero(categoryId)) {
            qc.setCategoryIds(categoryId + "");
            boolQueryBuilder.must(this.searchIndexAssembling4cate(qc));
        }
        if (!StringUtil.isEmpty(keyword)) {
            qc.setKeyword(keyword);
            boolQueryBuilder.must(this.searchIndexAssembling4keyword(qc, 1000f));
        }

        //请求参数builder
        SearchRequest.Builder searchSourceBuilder = new SearchRequest.Builder();
        searchSourceBuilder.index(DomainUrlUtil.ES_INDEX_NAME)
                .query(boolQueryBuilder.build()._toQuery());

        searchSourceBuilder.size(0);
        searchSourceBuilder.sort(builder -> builder.score(builder1 -> builder1.order(SortOrder.Desc)));

        //聚合查询，将所有符合条件的店铺id放入list
        searchSourceBuilder.query(boolQueryBuilder.build()._toQuery())
                .aggregations("list", AggregationBuilders.terms(builder -> builder.field(SearchProductDTO.STORE_ID_ + ".keyword").size(1000000)));

        try {
            SearchResponse<ModelMap> search = elasticsearchClient.search(searchSourceBuilder.build(), ModelMap.class);
            log.info(JSON.toJSONString(search.aggregations()));
            //解析查询结果，拿到店铺id list
            Buckets<StringTermsBucket> buckets = ((StringTermsAggregate) search.aggregations().get("list")._get()).buckets();
            buckets.array().forEach(stringTermsBucket -> {
                String key = stringTermsBucket.key().stringValue();
                result.add(Long.valueOf(key));
            });
        } catch (IOException e) {
            log.error("es搜索异常", e);
        }

        return result;
    }