RestHighLevelClient Java操作ES实现CRUD （

原创已于 2023-05-05 15:35:30 修改 · 642 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#elasticsearch #搜索引擎 #lucene

于 2023-04-13 18:25:46 首次发布

该代码示例展示了如何使用Java的RestHighLevelClient进行Elasticsearch的操作，包括创建、查看、删除索引，创建、更新、获取和删除文档，批量操作，全量和条件查询，排序，过滤字段，以及高亮显示和聚合查询。

package com.example.javahighlevelrestclienttest;

import com.alibaba.fastjson.JSON;
import com.example.javahighlevelrestclienttest.Entity.User;
import org.apache.lucene.search.TotalHits;
import org.assertj.core.util.Lists;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.client.indices.GetIndexResponse;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.MultiMatchQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.BucketOrder;
import org.elasticsearch.search.aggregations.bucket.terms.ParsedStringTerms;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.search.sort.SortOrder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Stream;

@SpringBootTest
class JavaHighLevelRestClientTestApplicationTests {

    @Autowired
    private RestHighLevelClient esRestClient;

    //创建索引
    @Test
    void createIndex() throws IOException {
        //创建索引 --- 请求对象
        CreateIndexRequest request = new CreateIndexRequest("user");
        //发送请求 --- 获取响应
        CreateIndexResponse createIndexResponse = esRestClient.indices().create(request, RequestOptions.DEFAULT);
        //响应状态
        boolean acknowledged = createIndexResponse.isAcknowledged();
        System.out.println("索引操作：" + acknowledged);
        //关闭ES客户端
        esRestClient.close();
    }

    //查看索引
    @Test
    void getIndex() throws IOException {
        GetIndexRequest getIndexRequest = new GetIndexRequest("user");
        GetIndexResponse getIndexResponse = esRestClient.indices().get(getIndexRequest, RequestOptions.DEFAULT);
        //打印 别名
        System.out.println(getIndexResponse.getAliases());
        //打印 数据流
        System.out.println(getIndexResponse.getDataStreams());
        //打印 设置信息
        System.out.println(getIndexResponse.getSettings());
        //打印 映射关系
        System.out.println(getIndexResponse.getMappings());
    }

    //删除索引
    @Test
    void delIndex() throws IOException {
        DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("user");
        AcknowledgedResponse delete = esRestClient.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
        //获取删除状态
        boolean acknowledged = delete.isAcknowledged();
        //true or false
        System.out.println(acknowledged);
    }

    //创建文档
    @Test
    void createDoc() throws IOException, ParseException {
        IndexRequest indexRequest = new IndexRequest("user");
        //设置索引及索引中文档的唯一性标识id（如果不指定，则ES会默认随机生成一个id）
        //indexRequest.index("user").id("1001");

        Date day=new Date();
        SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = sdf.format(day);

        User user = new User();
        user.setUserName("泽泽");
        user.setAge(23);
        user.setGender("男");
        user.setTimestamp(format);

        //向ES中插入数据，必须将数据格式转换为JSON
        String s = JSON.toJSONString(user);
        //保存内容
        indexRequest.source(s,XContentType.JSON);

        //发送信息 获取响应
        IndexResponse index = esRestClient.index(indexRequest, RequestOptions.DEFAULT);
        System.out.println(index.getResult());

        //关闭ES客户端
        esRestClient.close();
    }

    //修改文档
    @Test
    void updateDoc() throws IOException {
        //配置修改参数 --- 表示要修改user索引中id为1001的文档内容
        UpdateRequest request = new UpdateRequest("user","1001");
        //把age修改为18
        request.doc(XContentType.JSON, "age", 18);
        //发送请求 --- 获取响应
        UpdateResponse update = esRestClient.update(request, RequestOptions.DEFAULT);
        System.out.println(update.getResult());

        esRestClient.close();
    }

    //查看文档
    @Test
    void getDoc() throws IOException {
        GetRequest getRequest = new GetRequest("user","Q-hwWYcBlZOjc5PgvviU");

        GetResponse documentFields = esRestClient.get(getRequest, RequestOptions.DEFAULT);

        System.out.println(documentFields.getSourceAsString());

        esRestClient.close();
    }

    //删除文档
    @Test
    void delDoc() throws IOException {
        //删除文档 --- 请求对象
        DeleteRequest request = new DeleteRequest();
        //设置请求参数 --- 表示要删除user索引中id为1001的文档
        request.index("user").id("1001");

        //发送请求 --- 获取响应
        DeleteResponse response = esRestClient.delete(request,RequestOptions.DEFAULT);
        System.out.println(response.getResult());

        //关闭ES客户端
        esRestClient.close();
    }

    //批量创建文档
    @Test
    void bulkCreateDoc() throws IOException {
        //批量新增文档 --- 请求对象
        BulkRequest request = new BulkRequest();
        //以JSON格式批量新增文档 --- 存入请求体中
        request.add(new IndexRequest().index("user").source(XContentType.JSON, "name", "牛子","sex","boy","age",21,"",""));
        request.add(new IndexRequest().index("user").source(XContentType.JSON, "name", "天乐","sex","boy","age",18));
        request.add(new IndexRequest().index("user").id("1003").source(XContentType.JSON, "name", "乐乐","sex","girl","age",20));

        //发送请求 --- 获取响应
        BulkResponse response = esRestClient.bulk(request, RequestOptions.DEFAULT);
        System.out.println(response.getTook());

        //关闭ES客户端
        esRestClient.close();
    }

    //批量删除文档
    @Test
    void bulkDelDoc() throws IOException {
        //批量删除文档 --- 请求对象
        BulkRequest request = new BulkRequest();
        //将要删除的文档id存入请求体中
        request.add(new DeleteRequest().index("user").id("1001"));
        request.add(new DeleteRequest().index("user").id("1002"));
        request.add(new DeleteRequest().index("user").id("1003"));

        //发送请求 --- 获取响应
        BulkResponse response = esRestClient.bulk(request,RequestOptions.DEFAULT);
        System.out.println(response.getTook());
        System.out.println(response.getItems());

        //关闭ES客户端
        esRestClient.close();
    }

    //全量查询
    @Test
    void matcAllDoc() throws IOException{
        //1.查询索引中的全部文档 --- matchAllQuery 全量查询
        //创建搜索请求对象
        SearchRequest request = new SearchRequest();
        //设置参数 --- 表示查询哪个索引中的文档内容
        request.indices("user");
        //构建查询的请求体 --- 存入搜索请求对象中
        request.source(new SearchSourceBuilder().query(QueryBuilders.matchAllQuery()));
        //发送请求 --- 获取响应
        SearchResponse response = esRestClient.search(request,RequestOptions.DEFAULT);
        //获取查询到的结果集
        SearchHits hits = response.getHits();
        System.out.println(hits.getTotalHits()); //结果集的条数
        System.out.println(response.getTook());  //总耗时

        //遍历结果集
        for (SearchHit hit : hits) {
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
//            User user = new User();
            String name = (String) sourceAsMap.get("userName");
            Integer age = (Integer) sourceAsMap.get("age");
            String gender = (String) sourceAsMap.get("gender");
            String timestamp = (String) sourceAsMap.get("timestamp");

            System.out.println(name+" "+age+" "+gender+" "+timestamp);
            System.out.println(hit.getSourceAsString());
        }

        //关闭ES客户端
        esRestClient.close();
    }

    //条件查询
    @Test
    void mustDoc() throws IOException {
        //2.条件查询--- termQuery age=21
        //创建搜索请求对象
        SearchRequest request = new SearchRequest();
        //设置参数 --- 表示查询哪个索引中的文档内容
        request.indices("user");
        //构建查询的请求体 --- 存入搜索请求对象中
        request.source(new SearchSourceBuilder().query(QueryBuilders.termQuery("age",21)));

        //发送请求 --- 获取响应
        SearchResponse response = esRestClient.search(request,RequestOptions.DEFAULT);
        //获取查询到的结果集
        SearchHits hits = response.getHits();
        System.out.println(hits.getTotalHits()); //结果集的条数
        System.out.println(response.getTook());  //总耗时
        //遍历结果集
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

        //关闭ES客户端
        esRestClient.close();
    }

    //分页查询
    @Test
    void pageSizeDoc() throws IOException {
        //3.分页查询
        //创建搜索请求对象
        SearchRequest request = new SearchRequest();
        //设置参数 --- 表示查询哪个索引中的文档内容
        request.indices("user");
        //构建查询的请求体
        SearchSourceBuilder builder = new SearchSourceBuilder().query(QueryBuilders.matchAllQuery());
        builder.from(0);
        builder.size(3);
        //将构建好的查询请求体存入搜索请求对象中
        request.source(builder);

        //发送请求 --- 获取响应
        SearchResponse response = esRestClient.search(request,RequestOptions.DEFAULT);
        //获取查询到的结果集
        SearchHits hits = response.getHits();
        System.out.println(hits.getTotalHits()); //结果集的条数
        System.out.println(response.getTook());  //总耗时
        //遍历结果集
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

        //关闭ES客户端
        esRestClient.close();
    }

    //排序查询
    //做全量查询，对查询结果中的年龄age字段做降序排序。
    @Test
    void sortMatchAllDoc() throws IOException {
        //4.对查询结果进行排序
        //创建搜索请求对象
        SearchRequest request = new SearchRequest();
        //设置参数 --- 表示查询哪个索引中的文档内容
        request.indices("user");
        //构建查询的请求体
        SearchSourceBuilder builder = new SearchSourceBuilder().query(QueryBuilders.matchAllQuery());
        builder.sort("age", SortOrder.ASC);
        //将构建好的查询请求体存入搜索请求对象中
        request.source(builder);

        //发送请求 --- 获取响应
        SearchResponse response = esRestClient.search(request,RequestOptions.DEFAULT);
        //获取查询到的结果集
        SearchHits hits = response.getHits();
        System.out.println(hits.getTotalHits()); //结果集的条数
        System.out.println(response.getTook());  //总耗时
        //遍历结果集
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

        //关闭ES客户端
        esRestClient.close();
    }

    //过滤字段查询
    //做全量查询，同时排除性别sex字段。
    @Test
    void filterMatchAll() throws IOException {
        //5.过滤字段
        //创建搜索请求对象
        SearchRequest request = new SearchRequest();
        //设置参数 --- 表示查询哪个索引中的文档内容
        request.indices("user");
        //构建查询的请求体
        SearchSourceBuilder builder = new SearchSourceBuilder().query(QueryBuilders.matchAllQuery());
        //不包括
        String[] excludes = {"sex"};
        //包括 俩者写一个就可，不包括就过滤指定字段，包括就只显示包括的字段。
        String[] includes = {};
        builder.fetchSource(includes,excludes);
        //将构建好的查询请求体存入搜索请求对象中
        request.source(builder);

        //发送请求 --- 获取响应
        SearchResponse response = esRestClient.search(request,RequestOptions.DEFAULT);
        //获取查询到的结果集
        SearchHits hits = response.getHits();
        System.out.println(hits.getTotalHits()); //结果集的条数
        System.out.println(response.getTook());  //总耗时
        //遍历结果集
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

        //关闭ES客户端
        esRestClient.close();
    }

    //组合条件查询
    //查询年龄 age=18 或者 name=张起灵 的文档内
    @Test
    void compositeQuery() throws IOException {
        //6.组合查询
        //创建搜索请求对象
        SearchRequest request = new SearchRequest();
        //设置参数 --- 表示查询哪个索引中的文档内容
        request.indices("user");
        //构建查询的请求体
        SearchSourceBuilder builder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.should(QueryBuilders.matchQuery("age",18));
        boolQueryBuilder.should(QueryBuilders.matchQuery("name","天乐"));
        builder.query(boolQueryBuilder);
        //将构建好的查询请求体存入搜索请求对象中
        request.source(builder);

        //发送请求 --- 获取响应
        SearchResponse response = esRestClient.search(request,RequestOptions.DEFAULT);
        //获取查询到的结果集
        SearchHits hits = response.getHits();
        System.out.println(hits.getTotalHits()); //结果集的条数
        System.out.println(response.getTook());  //总耗时
        //遍历结果集
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

        //关闭ES客户端
        esRestClient.close();
    }

    //高亮显示
    @Test
    void testHighlight() throws IOException, ParseException {
        //搜索请求对象
        SearchRequest searchRequest = new SearchRequest("user");
        //搜索源构建对象
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        //boolQuery搜索方式
        //先定义一个MultiMatchQuery
        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("乐乐18", "name", "age")
                .minimumShouldMatch("50%")
                .field("name", 10);

        //定义一个boolQuery
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.must(multiMatchQueryBuilder);
        //定义过虑器
        boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(0).lte(100));

        searchSourceBuilder.query(boolQueryBuilder);
        //设置源字段过虑,第一个参数结果集包括哪些字段，第二个参数表示结果集不包括哪些字段
        searchSourceBuilder.fetchSource(new String[]{"name","age","gender","timestamp"},new String[]{});

        //设置高亮
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.preTags("<tag>");
        highlightBuilder.postTags("</tag>");
        highlightBuilder.fields().add(new HighlightBuilder.Field("name"));
//        highlightBuilder.fields().add(new HighlightBuilder.Field("description"));
        searchSourceBuilder.highlighter(highlightBuilder);

        //向搜索请求对象中设置搜索源
        searchRequest.source(searchSourceBuilder);
        //执行搜索,向ES发起http请求
        SearchResponse searchResponse = esRestClient.search(searchRequest,RequestOptions.DEFAULT);
        //搜索结果
        SearchHits hits = searchResponse.getHits();
        //匹配到的总记录数
        TotalHits totalHits = hits.getTotalHits();
        //得到匹配度高的文档
        SearchHit[] searchHits = hits.getHits();
        //日期格式化对象
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        for(SearchHit hit:searchHits){
            //文档的主键
            String id = hit.getId();
            //源文档内容
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            //源文档的name字段内容
            String name = (String) sourceAsMap.get("name");
            //取出高亮字段
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            if(highlightFields!=null){
                //取出name高亮字段
                HighlightField nameHighlightField = highlightFields.get("name");
                if(nameHighlightField!=null){
                    Text[] fragments = nameHighlightField.getFragments();
                    StringBuffer stringBuffer = new StringBuffer();
                    for(Text text:fragments){
                        stringBuffer.append(text);
                    }
                    name = stringBuffer.toString();
                }
            }

            //由于前边设置了源文档字段过虑，这时description是取不到的
            String description = (String) sourceAsMap.get("description");
            //学习模式
            String studymodel = (String) sourceAsMap.get("studymodel");
            //价格
            Double price = (Double) sourceAsMap.get("price");
            //日期
            Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
            System.out.println(name);
            System.out.println(studymodel);
            System.out.println(description);
        }
    }

    @Test
    void testTime(){
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = df.format(new Date());
        System.out.println("当前时间"+df.format(new Date()));
        //1代表为一个月    正的往前  负的为后
        Date date = stepMonth(new Date(), -1);
        System.out.println("前一个月时间为"+df.format(date));
    }

    Date stepMonth(Date sourceDate, int month){
        Calendar c = Calendar.getInstance();
        c.setTime(sourceDate);
        c.add(Calendar.MONTH, -1);
        return c.getTime();
    }

    @Test
    void ssss() {
        String sss1 = "(Spring|Mysql|ElasticSearch)   ";
        System.out.println(sss1);
        String trim = sss1.trim();
        System.out.println(trim);

        //替换
        String substring = trim.replace("(", "");
//        System.out.println("替换为 " + substring);
//
//        //正则分割
//        String[] split = substring.split("\\||\\)");
//        Spliterator<String> spliterator = Arrays.stream(split).spliterator();
//        System.out.println(spliterator);
//
//        for (int i = split.length - 1; i >= 0; i--) {
//            System.out.println(split[i]);
//        }
        Stream.of(substring.split("\\||\\)|,")).forEach(keyword -> {
            System.out.println("打印"+keyword);
        });
    }

    @Test
    void ssss1111() {
        String s = "a,b,c,d,e,,,,,";
        String[] string1 = new String[20];
        String[] string2 = new String[20];
        string1 = s.split(",");
        string2 = s.split(",",1);
        for (String a: string2) {
            System.out.println("2222 "+a);
        }
        for (String a: string1) {
            System.out.println("1111 "+a);
        }

//                正数 按组分割 只分割一次
//                负数      正常分割，首位有符号时候分割，但会有空字符
//                没有数字 正常分割
    }

    //热词Top10排序
    @Test
    void getTermsandOrderBy(){
        SearchRequest searchRequest = new SearchRequest("user");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //聚合查询 top10热词
        TermsAggregationBuilder field = AggregationBuilders.terms("order_by_word").field("word")
                .size(10)
                .order(BucketOrder.aggregation("_count",false));
        sourceBuilder.aggregation(field);
        searchRequest.source(sourceBuilder);
        List<User> hotWordList = Lists.newArrayList();
        try {
            SearchResponse response = esRestClient.search(searchRequest, RequestOptions.DEFAULT);
            Terms terms = response.getAggregations().get("order_by_word");
            for (Terms.Bucket bucket : terms.getBuckets()) {
                User hotWordVO = new User();
                String fieldValue = bucket.getKeyAsString();
                long count = bucket.getDocCount();
                hotWordVO.setWord(fieldValue);
                hotWordVO.setCount(count);
                hotWordList.add(hotWordVO);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        System.out.println(hotWordList.toArray());
    }

}

查看数据结构的

        //查看表别名与本名结构
        Request request;
        request = new Request("GET", "_cat/aliases?v&h=alias,index");
        Response response = elasticTemplate.request(request, restHighLevelClient);

        //查看表数量
        request = new Request("GET", "_cat/indices?v&h=idx,docs.count");
        response = elasticTemplate.request(request, restHighLevelClient);