Java-Elasticsearch的增删查以及所需配置

1.引入Elasticsearch依赖

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>7.12.0</version>
</dependency>

2.创建Elasticsearch客户端

RestHighLevelClient client = new RestHighLevelClient(
            RestClient.builder(new HttpHost("ruowu.com", 9200, "http"))
    );

3.实际使用

(1).批量添加

public R<Boolean> insert(@RequestBody EsInsertListVo esInsertListVo) {
        // 获取插入数据的索引名称和数据
        String indexName = esInsertListVo.getIndexName();
        List<EsInsertVo> list = esInsertListVo.getList();
        // 检查索引是否存在，如果不存在则抛出异常或返回错误信息
        esIndexService.checkParms(indexName, true);
        // 查询索引是否存在，如果不存在则返回错误信息
        R<Boolean> booleanR = esIndexService.selectEsIndex(new SelectEsIndex(indexName));
        if (!booleanR.getData()){
            return R.ok(false,"索引不存在，请先创建索引");
        }
        // 判断list是否为空，如果为空将抛出异常
        if (CollectionUtils.isEmpty(list)){
            throw new ServiceException("添加数据不能为空");
        }
        // 创建 BulkRequest 对象，用于批量处理请求
        BulkRequest bulkRequest = new BulkRequest();
        // 遍历list，将每个EsInsertVo对象封装成对应的IndexRequest请求，并添加到BulkRequest中
        list.stream().forEach(res -> {
            IndexRequest indexRequest = new IndexRequest(indexName);
            // 获取文档ID，并设置到IndexRequest对象中
            String indexId = res.getIndexId();
            if (StringUtils.isNotEmpty(indexId)){
                indexRequest.id(indexId);
            }
            // 获取文档内容，并设置到IndexRequest对象中
            Map<String, Object> parms = res.getParms();
            indexRequest.source(parms);
            bulkRequest.add(indexRequest);
        });
        try {
            // 使用BulkRequest对象发送请求，获取Elasticsearch服务返回的响应
            BulkResponse bulk = client.bulk(bulkRequest, RequestOptions.DEFAULT);
            // 判断响应中是否包含失败信息，如果有则返回错误信息
            if (bulk.hasFailures()){
                return R.ok(false,"添加失败");
            }
        } catch (Exception e) {
            // 发生异常时，抛出ServiceException并返回错误信息
            throw new ServiceException("批添错误");
        }
        // 如果所有文档都成功插入，则返回成功信息
        return R.ok(true,"添加成功");
    }

(2).批量删除

public R<Boolean> delete(EsDeleteListVo esDeleteListVo) {
        // 获取删除数据的索引名称和数据
        String indexName = esDeleteListVo.getIndexName();
        List<EsDeleteVo> list = esDeleteListVo.getList();
        // 检查索引是否存在，如果不存在则抛出异常或返回错误信息
        esIndexService.checkParms(indexName, true);
        // 查询索引是否存在，如果不存在则返回错误信息
        R<Boolean> booleanR = esIndexService.selectEsIndex(new SelectEsIndex(indexName));
        if (!booleanR.getData()){
            return R.ok(false,"索引不存在，请先创建索引");
        }
        // 判断list是否为空，如果为空将抛出异常
        if (CollectionUtils.isEmpty(list)){
            throw new ServiceException("删除数据不能为空");
        }
        // 创建 BulkRequest 对象，用于批量处理请求
        BulkRequest bulkRequest = new BulkRequest();
        // 遍历list，将每个EsDeleteVo对象封装成对应的DeleteRequest请求，并添加到BulkRequest中
        list.stream().forEach(res -> {
            DeleteRequest deleteRequest = new DeleteRequest(indexName);
            // 获取删除文档的ID，并设置到DeleteRequest对象中
            String indexId = res.getIndexId();
            if (StringUtils.isNotEmpty(indexId)){
                deleteRequest.id(indexId);
            }
            bulkRequest.add(deleteRequest);
        });
        try {
            // 使用BulkRequest对象发送请求，获取Elasticsearch服务返回的响应
            BulkResponse bulk = client.bulk(bulkRequest, RequestOptions.DEFAULT);
            // 判断响应中是否包含失败信息，如果有则返回错误信息
            if (bulk.hasFailures()){
                return R.ok(false,"删除失败");
            }
        } catch (Exception e) {
            // 发生异常时，抛出ServiceException并返回错误信息
            throw new ServiceException("批删错误");
        }
        // 如果所有文档都成功删除，则返回成功信息
        return R.ok(true,"删除成功");
    }

(3).条件查询（因为要支持不同的数据类型进行查询）

public R find(EsQueryVo esQueryVo) {
        // 定义 total 数量为零
        long total = 0;
        // 定义一个 ArrayList 集合，用来存储查询到的结果
        ArrayList<Map<String, Object>> list = new ArrayList<>();
        // 获取索引名称
        String indexName = esQueryVo.getIndexName();
        // 获取当前页码数和每页显示数量
        Integer pageNum = esQueryVo.getPageNum();
        Integer pageSize = esQueryVo.getPageSize();
        // 获取查询参数
        Map<String, Map<String, Object>> parms = esQueryVo.getParms();
        // 创建一个查询请求对象
        SearchRequest searchRequest = new SearchRequest(indexName);
        // 创建一个查询构造器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        // 创建一个布尔查询构造器
        BoolQueryBuilder builder = QueryBuilders.boolQuery();
        // 检查参数是否为空，如果为空则进行全量查询
        esIndexService.checkParms(indexName, true);
        if (MapUtil.isEmpty(parms)) {
            // 如果参数为空，则进行全量查询
            sourceBuilder.query(QueryBuilders.matchAllQuery());
        }
        if (MapUtil.isNotEmpty(parms)) {
            // 如果参数不为空
            // 获取模糊匹配的参数，并添加到查询构造器中
            Map<String, Object> match = parms.get("match");
            if (MapUtil.isNotEmpty(match)) {
                match.keySet().stream().forEach(key -> {
                    MatchQueryBuilder matchQueryBuilder = new MatchQueryBuilder(key, match.get(key));
                    builder.must(matchQueryBuilder);
                    sourceBuilder.query(builder);
                });
            }
            // 获取精准匹配的参数，并添加到查询构造器中
            Map<String, Object> term = parms.get("term");
            if (MapUtil.isNotEmpty(term)) {
                term.keySet().stream().forEach(key -> {
                    TermQueryBuilder termQueryBuilder = new TermQueryBuilder(key, term.get(key));
                    builder.must(termQueryBuilder);
                    sourceBuilder.query(builder);
                });
            }
            // 获取排序参数，并添加到查询构造器中
            Map<String, Object> order = parms.get("order");
            if (MapUtil.isNotEmpty(order)) {
                order.keySet().stream().forEach(key -> {
                    String orders = (String) order.get(key);
                    if ("desc".equals(orders)) {
                        sourceBuilder.sort(key, SortOrder.DESC);
                    }
                    if ("asc".equals(orders)) {
                        sourceBuilder.sort(key, SortOrder.ASC);
                    }
                });
            }
            // 获取数据过滤参数，并添加到查询构造器中
            Map<String, Object> filter = parms.get("filter");
            if (MapUtil.isNotEmpty(filter)) {
                String[] a = new String[1];
                String[] b = new String[1];
                filter.keySet().stream().forEach(key -> {
                    ArrayList<String> includes = null;
                    ArrayList<String> excludes = null;
                    if ("includes".equals(key)) {
                        includes = (ArrayList<String>) filter.get(key);
                    }
                    if ("excludes".equals(key)) {
                        excludes = (ArrayList<String>) filter.get(key);
                    }
                    if (includes != null) {
                        for (int i = 0; i < includes.size(); i++) {
                            a[i] = includes.get(i);
                        }
                        System.err.println("a:" + a);
                    }
                    if (excludes != null) {
                        for (int i = 0; i < excludes.size(); i++) {
                            b[i] = excludes.get(i);
                        }
                    }
                });
                sourceBuilder.fetchSource(a, b);
            }
            // 获取布尔查询and参数，并添加到查询构造器中
            Map<String, Object> boolAnd = parms.get("boolAnd");
            if (MapUtil.isNotEmpty(boolAnd)) {
                BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
                boolAnd.keySet().stream().forEach(key -> {
                    ArrayList o = (ArrayList) boolAnd.get(key);
                    boolQuery.must(QueryBuilders.matchQuery(key, o));
                    sourceBuilder.query(boolQuery);
                });
            }
            // 获取布尔查询or参数，并添加到查询构造器中
            Map<String, Object> boolOr = parms.get("boolOr");
            if (MapUtil.isNotEmpty(boolOr)) {
                BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
                boolOr.keySet().stream().forEach(key -> {
                    ArrayList o = (ArrayList) boolOr.get(key);
                    boolQuery.should(QueryBuilders.matchQuery(key, o));
                    sourceBuilder.query(boolQuery);
                });
            }
            // 获取高亮查询参数，并添加到查询构造器中
            Map<String, Object> highlight = parms.get("highlight");
            if (MapUtil.isNotEmpty(highlight)) {
                HighlightBuilder highlightBuilder = new HighlightBuilder();
                highlightBuilder.preTags("<font color='#00FFF0'>");
                highlightBuilder.postTags("</font>");
                highlight.keySet().stream().forEach(key -> {
                    sourceBuilder.query(builder);
                    highlightBuilder.field(key);
                    if (highlight.size() > 1) {
                        highlightBuilder.requireFieldMatch(false);
                    }
                });
                sourceBuilder.highlighter(highlightBuilder);
            }
            // 获取区间查询参数，并添加到查询构造器中
            Map<String, Object> range = parms.get("range");
            if (MapUtil.isNotEmpty(range)) {
                range.keySet().stream().forEach(key -> {
                    ArrayList o = (ArrayList) range.get(key);
                    RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery(key);
                    rangeQueryBuilder.gte(o.get(0));
                    rangeQueryBuilder.lt(o.get(1));
                    sourceBuilder.query(rangeQueryBuilder);
                });
            }
        }
        // 设置分页信息
        sourceBuilder.from((pageNum - 1) * pageSize);
        sourceBuilder.size(pageSize);
        searchRequest.source(sourceBuilder);
        try {
            // 发起查询请求，并获取返回结果
            SearchResponse search = client.search(searchRequest, RequestOptions.DEFAULT);
            SearchHits hits = search.getHits();
            total = hits.getTotalHits().value;
            // 遍历查询结果，并设置高亮字段
            for (SearchHit hit : hits.getHits()) {
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                Map<String, Object> highlight = parms.get("highlight");
                highlight.keySet().stream().forEach(key -> {
                    Map<String, HighlightField> highlightFields = hit.getHighlightFields();
                    if (highlightFields != null) {
                        HighlightField highlightField = highlightFields.get(key);
                        if (highlightField != null) {
                            Text[] fragments = highlightField.getFragments();
                            String str = "";
                            for (Text fragment : fragments) {
                                str += fragment;
                            }
                            sourceAsMap.put(key, str);
                        }
                    }
                });
                list.add(sourceAsMap);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        // 返回查询结果
        return R.ok(PageResult.toPageResult(total, list));
    }