Elasticsearch——High Level REST Client（二）Search/Sync Search APIs

原创

于 2024-07-27 16:52:34 发布 · 1.3k 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#elasticsearch #搜索引擎

作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬

学习必须往深处挖，挖的越深，基础越扎实！

阶段1、深入多线程

 阶段2、深入多线程设计模式

 阶段3、深入juc源码解析

阶段4、深入jdk其余源码解析

阶段5、深入jvm源码解析

码哥源码部分

码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场景题】

码哥讲源码【炸雷啦！炸雷啦！黄光头他终于跑路啦！】

码哥讲源码-【jvm课程前置知识及c/c++调试环境搭建】

码哥讲源码-原理源码篇【揭秘join方法的唤醒本质上决定于jvm的底层析构函数】

码哥源码-原理源码篇【Doug Lea为什么要将成员变量赋值给局部变量后再操作？】

码哥讲源码【你水不是你的错,但是你胡说八道就是你不对了！】

码哥讲源码【谁再说Spring不支持多线程事务，你给我抽他！】

终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！

打脸系列【020-3小时讲解MESI协议和volatile之间的关系，那些将x86下的验证结果当作最终结果的水货们请闭嘴】

7、Search APIs

7.1、SearchSourceBuilder

控制搜索行为的大多数选项都可以在SearchSourceBuilder上设置，它或多或少包含与Rest API的搜索请求体中的选项相当的选项。

    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    //查询语句
    sourceBuilder.query(QueryBuilders.termQuery("user", "kimchy"));
    //from
    sourceBuilder.from(0);
    //size
    sourceBuilder.size(5);
    //超时
    sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));

7.1.1、排序（SortBuilder）

SearchSourceBuilder允许添加一个或多个SortBuilder实例。有四种特殊的实现：

FieldSortBuilder：字段排序
GeoDistanceSortBuilder：Geo距离排序
ScoreSortBuilder：评分排序
ScriptSortBuilder：脚本排序

    //评分排序
    sourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
    //字段排序
    sourceBuilder.sort(new FieldSortBuilder("id").order(SortOrder.ASC));

7.1.2、字段过滤

    //不获取_source字段
    sourceBuilder.fetchSource(false);
    //通过includes和exclude过滤
    String[] includeFields = new String[] {"title", "innerObject.*"};
    String[] excludeFields = new String[] {"user"};
    sourceBuilder.fetchSource(includeFields, excludeFields);

7.1.3、高亮

突出显示搜索结果可以通过在SearchSourceBuilder上设置HighlightBuilder来实现。通过添加一个或多个HighlightBuilder，可以为每个字段定义不同的突出显示行为。

    //创建一个HighlightBuilder
    HighlightBuilder highlightBuilder = new HighlightBuilder();
    //创建一个高亮字段
    HighlightBuilder.Field highlightTitle = new HighlightBuilder.Field("title");
    //设置字段高亮显示类型
    highlightTitle.highlighterType("unified");
    //将字段高亮添加到高亮器中
    highlightBuilder.field(highlightTitle);
    //第二个高亮字段
    HighlightBuilder.Field highlightUser = new HighlightBuilder.Field("user");
    //添加到高亮器
    highlightBuilder.field(highlightUser);
    //高亮器加入到builder
    sourceBuilder.highlighter(highlightBuilder);

7.1.4、聚合

聚合可以通过首先创建适当的AggregationBuilder，然后在SearchSourceBuilder上设置它来添加到搜索中

    //创建一个聚合Builder，指定集合类型、字段
    TermsAggregationBuilder aggregation = AggregationBuilders.terms("by_company")
            .field("company.keyword");
    //子聚合
    aggregation.subAggregation(AggregationBuilders.avg("average_age")
            .field("age"));
    //加入到Builder
    sourceBuilder.aggregation(aggregation);

7.1.5、Profile API

Profile API可用于分析特定搜索请求的查询和聚合的执行情况。为了使用它，profile标志必须在SearchSourceBuilder上设置为true:

    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    searchSourceBuilder.profile(true);

7.2、QueryBuilder

搜索查询是使用QueryBuilder对象创建的。QueryBuilder存在于Elasticsearch的查询DSL支持的每种搜索查询类型。

共有两种创建方式：

使用构造函数new一个

    MatchQueryBuilder matchQueryBuilder = new MatchQueryBuilder("user", "kimchy");
    matchQueryBuilder.fuzziness(Fuzziness.AUTO); 
    matchQueryBuilder.prefixLength(3); 
    matchQueryBuilder.maxExpansions(10);

使用QueryBuilders工具类创建

    QueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("user", "kimchy")
                                                    .fuzziness(Fuzziness.AUTO)
                                                    .prefixLength(3)
                                                    .maxExpansions(10);

7.2.1、简单查询

    //查询所有
    MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
    //词项查询
    TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("title", "hello");
    //全文检索
    QueryBuilders.matchQuery("content", "content")
            .analyzer("english");//设置分词器
    //分词查询
    QueryBuilders.matchPhraseQuery("content", "content")
            .slop(2);//指定slop
    //前缀分词匹配
    QueryBuilders.matchBoolPrefixQuery("conotnet", "con")
            .maxExpansions(1);//最大匹配数
    //多字段 搜索title、content字段中的hello
    QueryBuilders.multiMatchQuery("hello", "title", "content")
            .field("title", 1.2f);//指定字段权重
    //query_string
    QueryBuilders.queryStringQuery("(title:Reversus) OR (content:Nanette)")
            .field("content", 1.2f);//指定字段权重
    //query_string升级版：使用 +、|、- 代替 AND、OR、NOT 等。
    QueryBuilders.simpleQueryStringQuery("lake + street")
            .field("content");
    //词项查询
    QueryBuilders.termQuery("title.keyword", "hello");
    //多词项查询
    QueryBuilders.termsQuery("title.keyword", "value1", "value2");
    //范围查询
    QueryBuilders.rangeQuery("age")
            .gte("18")
            .lte("28");
    //非空查询
    QueryBuilders.existsQuery("content");
    //前缀匹配
    QueryBuilders.prefixQuery("content", "prefix_value");
    //通配符查询
    QueryBuilders.wildcardQuery("content", "h?ll*");
    //正则查询
    QueryBuilders.regexpQuery("content", "na.*");
    //模糊查询
    QueryBuilders.fuzzyQuery("title", "javo");
    //多id查询
    QueryBuilders.idsQuery()
            .addIds("1", "2", "3");

7.2.2、复合查询

7.2.2.1、constant_score query——无关词频的查询

    @Test
    public void constant_score_query() throws IOException {
        SearchRequest searchRequest = new SearchRequest("bank");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        /**
         * constant_score query 无关词频的查询
         * GET /bank/_search
         * {
         *   "query": {
         *     "constant_score": {
         *       "filter": {
         *         "match": {
         *           "employer": "Chillium"
         *         }
         *       },
         *       "boost": 1.2
         *     }
         *   }
         * }
         */ 
        ConstantScoreQueryBuilder queryBuilder = QueryBuilders.constantScoreQuery(
                QueryBuilders.matchQuery("employer", "Chillium")
        );
        sourceBuilder.query(queryBuilder);
        searchRequest.source(sourceBuilder);
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
    
        System.out.println(response.toString());
    }

7.2.2.2、bool query——逻辑组合查询

    @Test
    public void bool_query() throws IOException {
        SearchRequest searchRequest = new SearchRequest("bank");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        /**
         * bool query——逻辑组合查询
         * GET /bank/_search
         * {
         *   "query": {
         *     "bool": {
         *       "must": [
         *         {
         *           "match": {
         *             "address": "street"
         *           }
         *         }
         *       ],
         *       "should": [
         *         {
         *           "term": {
         *             "balance": {
         *               "value": 1
         *             }
         *           }
         *         }
         *       ],
         *       "must_not": [
         *         {
         *           "range": {
         *             "age": {
         *               "gte": 20,
         *               "lte": 39
         *             }
         *           }
         *         }
         *       ]
         *     }
         *   },
         *   "from": 0,
         *   "size": 2
         * }
         */
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery()
                .must(QueryBuilders.matchQuery("address", "street"))
                .should(QueryBuilders.termQuery("balance", 1))
                .mustNot(QueryBuilders.rangeQuery("age").gte(20).lte(39));
        sourceBuilder.query(queryBuilder).from(0).size(2);
        searchRequest.source(sourceBuilder);
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
    
        System.out.println(response.toString());
    }

7.2.2.3、dis_max query——分离最大化查询

    @Test
    public void dis_max_query() throws IOException {
        SearchRequest searchRequest = new SearchRequest("blog");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        /**
         * dis_max query——分离最大化查询
         * GET /blog/_search
         * {
         *   "query": {
         *     "dis_max": {
         *       "tie_breaker": 0.7,
         *       "boost": 1.2,
         *       "queries": [
         *         {
         *           "match": {
         *             "title": "java解决方案"
         *           }
         *         },
         *         {
         *           "match": {
         *             "content": "java解决方案"
         *           }
         *         }
         *       ]
         *     }
         *   }
         * }
         */
        QueryBuilder queryBuilder = QueryBuilders.disMaxQuery()
                .tieBreaker(0.7f)
                .boost(1.2f)
                .add(QueryBuilders.matchQuery("title", "java解决方案"))
                .add(QueryBuilders.matchQuery("content", "java解决方案"));
    
        sourceBuilder.query(queryBuilder);
        searchRequest.source(sourceBuilder);
        Sea