首页 > 其他分享 >ES-DSL搜索

ES-DSL搜索

时间：2023-09-23 15:23:21浏览次数：28  
标签：String searchSourceBuilder description DSL 搜索 new studymodel ES name

先准备测试数据

 

创建映射：
post：http://localhost:9200/xc_course/doc/_mapping
{
                "properties": {
                    "description": {
                        "type": "text",
                        "analyzer": "ik_max_word",
                        "search_analyzer": "ik_smart"
                    },
                    "name": {
                        "type": "text",
                        "analyzer": "ik_max_word",
                        "search_analyzer": "ik_smart"
                    },
                    "pic":{
                        "type":"text",
                        "index":false
                    },
                    "price": {
                        "type": "float"
                    },
                    "studymodel": {
                        "type": "keyword"
                    },
                    "timestamp": {
                        "type": "date",
                        "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
                    }
                }
            }


初始化文档：

http://localhost:9200/xc_course/doc/1
{
"name": "Bootstrap开发",
"description": "Bootstrap是由Twitter推出的一个前台页面开发框架，是一个非常流行的开发框架，此框架集成了多种页面效果。此开发框架包含了大量的CSS、JS程序代码，可以帮助开发者（尤其是不擅长页面开发的程序人员）轻松的实现一个不受浏览器限制的精美界面效果。",
"studymodel": "201002",
"price":38.6,
"timestamp":"2018-04-25 19:11:35",
"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
}
http://localhost:9200/xc_course/doc/2
{
"name": "java编程基础",
"description": "java语言是世界第一编程语言，在软件开发领域使用人数最多。",
"studymodel": "201001",
"price":68.6,
"timestamp":"2018-03-25 19:11:35",
"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
}
http://localhost:9200/xc_course/doc/3
{
"name": "spring开发基础",
"description": "spring 在java领域非常流行，java程序员都在用。",
"studymodel": "201001",
"price":88.6,
"timestamp":"2018-02-24 19:11:35",
"pic":"group1/M00/00/00/wKhlQFs6RCeAY0pHAAJx5ZjNDEM428.jpg"
}
测试数据

DSL是ES提出的基于JSON的搜索方法

1.查询所有文档

　　POST　http://localhost:9200/xc_course/doc/_search

　　Body中的JSON数据

query--------搜索的方式

_source------设置要显示的字段
{
    "query":{
        "match_all":{}
    },
    "_source":["name","studymodel"]
}

返回的结果集说明：　

{
    "took": 11,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": 3,
        "max_score": 1,
        "hits": [
            {
                "_index": "xc_course",
                "_type": "doc",
                "_id": "1",
                "_score": 1,
                "_source": {
                    "studymodel": "201002",
                    "name": "Bootstrap开发"
                }
            },
            {
                "_index": "xc_course",
                "_type": "doc",
                "_id": "2",
                "_score": 1,
                "_source": {
                    "studymodel": "201001",
                    "name": "java编程基础"
                }
            },
            {
                "_index": "xc_course",
                "_type": "doc",
                "_id": "3",
                "_score": 1,
                "_source": {
                    "studymodel": "201001",
                    "name": "spring开发基础"
                }
            }
        ]
    }
}
返回的搜索结果 　　took：本次操作花费的时间，单位为毫秒。 　　timed_out：请求是否超时 　　_shards：说明本次操作共搜索了哪些分片 　　hits：搜索命中的记录 　　hits.total ： 符合条件的文档总数 　　hits.hits ：匹配度较高的前N个文档 　　hits.max_score：文档匹配得分，这里为最高分 　　_score：每个文档都有一个匹配度得分，按照降序排列。 　　_source：显示了文档的原始内容。 　　对应的JavaApi实现 　　示例： 
@SpringBootTest
@RunWith(SpringRunner.class)
public class TestSearch {
    @Autowired
    RestHighLevelClient restHighLevelClient;

    @Autowired
    RestClient restClient;

    /**
     * 搜索全部记录
     */
    @Test
    public void testSearchALl() throws IOException, ParseException {
        //创建搜索请求对象
        SearchRequest searchRequest = new SearchRequest("xc_course");
            //搜索对象指定类型
            searchRequest.types("doc");
        //创建搜索源构建对象
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            //搜索源设置搜索方式
            searchSourceBuilder.query(QueryBuilders.matchAllQuery());          //QueryBuilders.matchAllQuery()-----搜索全部
            //设置源文档字段过滤------------第一个结果集包括哪些字段，第二个结果集不包括哪些字段
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","timestamp"},new String[]{});
        //搜索请求对象设置搜索源
        searchRequest.source(searchSourceBuilder);
        //执行搜索
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest);
            //获取匹配的搜索结果
            SearchHits hits = searchResponse.getHits();
            //匹配到的总记录数
            long totalHits = hits.getTotalHits();
            //匹配度高的文档
            SearchHit[] searchHits = hits.getHits();

        //日期格式化对象
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //遍历输出
        for (SearchHit hit:searchHits) {
            //文档主键
            String id = hit.getId();
            //源文档内容
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            //之前设置了源文档字段过滤集，所以搜索不到
            String description = (String) sourceAsMap.get("description");
            String studymodel = (String) sourceAsMap.get("studymodel");
            Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
            //打印
            System.out.println(name);
            System.out.println(description);
            System.out.println(studymodel);
            System.out.println(timestamp);
        }
    }

}
jave实现DSL搜索全部记录

2.分页查询

　　ES支持分页查询，传入两个参数：from和size

　　from-----表示起始文档的下标

　　size------查询的文档数量

    POST 　　http://localhost:9200/xc_course/doc/_search

　　Body的JSON数据

 {
     "from":0,"size":1,
    "query":{
        "match_all":{}
    },
    "_source":["name","studymodel"]
}

　　JaveClient示例：

 /**
     * 分页搜索记录
     */
    @Test
    public void testSearchPage() throws IOException, ParseException {
        //创建搜索请求对象
        SearchRequest searchRequest = new SearchRequest("xc_course");
        //搜索对象指定类型
        searchRequest.types("doc");
        //创建搜索源构建对象
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            //页码
            int page = 1;
            //每页记录数
            int size = 1;
            //计算记录起始下标
            int from = (page - 1) * size;
            //设置分页参数
            searchSourceBuilder.from(from);
            searchSourceBuilder.size(size);
        //搜索源设置搜索方式
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());          //QueryBuilders.matchAllQuery()-----搜索全部
        //设置源文档字段过滤------------第一个结果集包括哪些字段，第二个结果集不包括哪些字段
        searchSourceBuilder.fetchSource(new String[]{"name","studymodel","timestamp"},new String[]{});
        //搜索请求对象设置搜索源
        searchRequest.source(searchSourceBuilder);
        //执行搜索
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest);
        //获取匹配的搜索结果
        SearchHits hits = searchResponse.getHits();
        //匹配到的总记录数
        long totalHits = hits.getTotalHits();
        //匹配度高的文档
        SearchHit[] searchHits = hits.getHits();

        //日期格式化对象
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //遍历输出
        for (SearchHit hit:searchHits) {
            //文档主键
            String id = hit.getId();
            //源文档内容
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            //之前设置了源文档字段过滤集，所以搜索不到
            String description = (String) sourceAsMap.get("description");
            String studymodel = (String) sourceAsMap.get("studymodel");
            Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
            //打印
            System.out.println(name);
            System.out.println(description);
            System.out.println(studymodel);
            System.out.println(timestamp);
        }
    }
分页搜索记录

3.TermQuery精确查询和根据ID查询

　　在搜索时会整体匹配关键字，不再将关键字分词

　POST      http://localhost:9200/xc_course/doc/_search

　　整体匹配：会将下面name里的值去整体与分词器里的词去匹配

　精确查询Body的JSON数据

 {
    "query":{
        "term":{
            "name":"spring"
        }
    },
    "_source":["name","studymodel"]
}

　根据ID查询Body的JSON数据

 {
    "query":{
        "ids":{
            "type":"doc",
            "values":["3","2","100"]
        }
    },
    "_source":["name","studymodel"]
}

　　JaveClient示例：

/**
     * 精确查询和根据ID查询
     */
    @Test
    public void testSearchTermQuery() throws IOException, ParseException {
        //创建搜索请求对象
        SearchRequest searchRequest = new SearchRequest("xc_course");
        //搜索对象指定类型
        searchRequest.types("doc");
        //创建搜索源构建对象
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //搜索源设置搜索方式
                    //termQuery精确查询
                  //searchSourceBuilder.query(QueryBuilders.termQuery("name","spring"));          //termQuery-----精确查询
                    // searchSourceBuilder.query(QueryBuilders.termQuery("name","spring开发"));     //因为是整体精确查询，没有相匹配的值，搜不出来
                    //设置源文档字段过滤------------第一个结果集包括哪些字段，第二个结果集不包括哪些字段
                            //根据ID查询
                                //设置主键
                                String[] ids = new String[]{"1","2"};
                                searchSourceBuilder.query(QueryBuilders.termsQuery("_id",ids));          //注意：这里的QueryBuilders.termsQuery 是termsQuery
        searchSourceBuilder.fetchSource(new String[]{"name","studymodel","timestamp"},new String[]{});
        //搜索请求对象设置搜索源
        searchRequest.source(searchSourceBuilder);
        //执行搜索
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest);
        //获取匹配的搜索结果
        SearchHits hits = searchResponse.getHits();
        //匹配到的总记录数
        long totalHits = hits.getTotalHits();
        //匹配度高的文档
        SearchHit[] searchHits = hits.getHits();

        //日期格式化对象
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //遍历输出
        for (SearchHit hit:searchHits) {
            //文档主键
            String id = hit.getId();
            //源文档内容
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            //之前设置了源文档字段过滤集，所以搜索不到
            String description = (String) sourceAsMap.get("description");
            String studymodel = (String) sourceAsMap.get("studymodel");
            Date timestamp = dateFormat.parse((String) sourceAsMap.get("timestamp"));
            //打印
            System.out.println(name);
            System.out.println(description);
            System.out.println(studymodel);
            System.out.println(timestamp);
        }
    }
精确查询和根据ID查询 
注意：根据ID查询这里的QueryBuilders.termsQuery 是termsQuery

 4.match Query---全文检索                                            match-----  n.比赛; 火柴; 敌手; 相配的人/物; 相似的东西

　POST　　http://localhost:9200/xc_course/doc/_search

　　全文检索提交的JSON数据1

 {
    "query":{
        "match":{
        "description":{
            "query":"spring开发",
            "operator":"or"
        }
    }
    }
}
query：搜索的关键字，对于英文关键字如果有多个单词则中间要用半角逗号分隔，而对于中文关键字中间可以用逗号分隔也可以不用。 operator：or 表示 只要有一个词在文档中出现则就符合条件，and表示每个词都在文档中出现则才符合条件。

　　全文检索提交的JSON数据2

 {
    "query":{
        "match":{
        "description":{
            "query":"spring开发框架",
            "minimum_should_match":"80%"
        }
    }
    }
}
spring开发框架”会被分为三个词：spring、开发、框架 设置"minimum_should_match": "80%"表示，三个词在文档的匹配占比为80%，即3*0.8=2.4，向上取整得2，表示至少有两个词在文档中要匹配成功。

 　　JavaClient示例： 

/**
     * MatchQuery
     */
    @Test
    public void MatchQuery() throws IOException {
        //搜索请求对象
        SearchRequest searchRequest = new SearchRequest("xc_course");
        //搜索对象指定类型
        searchRequest.types("doc");
        //搜索源创建对象
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            //设置搜索源搜索方式
            searchSourceBuilder.query(QueryBuilders.matchQuery("description","spring开发框架")
                                                                .minimumShouldMatch("80%"));
        //请求对象设置搜索源
        searchRequest.source(searchSourceBuilder);
        //执行搜索
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest);
        //获取匹配的搜索结果
        SearchHits hits = searchResponse.getHits();
        //匹配的总数
        long totalHits = hits.getTotalHits();
        //匹配的搜索结果
        SearchHit[] searchHits = hits.getHits();
        //遍历输出
        for (SearchHit hit:searchHits) {
            //文档主键
            String id = hit.getId();
            //源文档内容
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            //之前设置了源文档字段过滤集，所以搜索不到
            String description = (String) sourceAsMap.get("description");
            String studymodel = (String) sourceAsMap.get("studymodel");
            //打印
            System.out.println(name);
            System.out.println(description);
            System.out.println(studymodel);
        }
    }
MatchQuery---全文检索

5.MultiQuery---多字段匹配　　　　　　Multi---复选

　　POST      http://localhost:9200/xc_course/doc/_search

JSON数据：

 {
    "query":{
        "multi_match":{
            "query":"spring开发框架",
            "minimum_should_match":"50%",
            "fields":["name^10","description"]
            }
    }
}
　　上面拿关键字 “spring css”去匹配name 和description字段 　　提升boost，通常关键字匹配上name的权重要比匹配上description的权重高，这里可以对name的权重提升 　　name^10” 表示权重提升10倍，执行上边的查询，发现name中包括spring关键字的文档排在前边。 JavaClient： 
/**
     * MultiQuery  --多字段匹配
     */
   /* MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("spring框架",
            "name", "description")
            .minimumShouldMatch("50%");
    multiMatchQueryBuilder.field("name",10);//提升boost*/

6.布尔查询

布尔查询对应于Lucene的BooleanQuery查询，实现将多个查询组合起来。 　　POST  　　http://localhost:9200/xc_course/doc/_search JSON数据： 
{
    "_source" : [ "name", "studymodel", "description"],
    "from" : 0, "size" : 1,
    "query": {
    "bool" : {
        "must":[
                {
                "multi_match" : {
        "query" : "spring框架",
        "minimum_should_match": "50%",
        "fields": [ "name^10", "description" ]
            }
            },
                {
                    "term":{
                    "studymodel" : "201001"
                    }
                }
            ]
        }
    }
}
　　must：表示必须，多个查询条件必须都满足。（通常使用must） 　　should：表示或者，多个查询条件只要有一个满足即可。 　　must_not：表示非 JavaClient示例： 
//BoolQuery，将搜索关键字分词，拿分词去索引库搜索
    @Test
    public void testBoolQuery() throws IOException {
        //创建搜索请求对象
        SearchRequest searchRequest = new SearchRequest("xc_course");
        searchRequest.types("doc");
        //创建搜索源配置对象
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.fetchSource(new String[]{"name", "pic", "studymodel"}, new String[]{});
        //multiQuery
        String keyword = "spring开发框架";
        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("spring框架",
                "name", "description")
                .minimumShouldMatch("50%");
        multiMatchQueryBuilder.field("name", 10);
        //TermQuery
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("studymodel", "201001");
        //布尔查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.must(multiMatchQueryBuilder);
        boolQueryBuilder.must(termQueryBuilder);
        //设置布尔查询对象
        searchSourceBuilder.query(boolQueryBuilder);
        searchRequest.source(searchSourceBuilder);//设置搜索源配置
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest);
        SearchHits hits = searchResponse.getHits();
        SearchHit[] searchHits = hits.getHits();
        for (SearchHit hit : searchHits) {
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            System.out.println(sourceAsMap);
        }
    }
布尔查询

7.过滤器查询

过虑是针对搜索的结果进行过虑，过虑器主要判断的是文档是否匹配，不去计算和判断文档的匹配度得分，所以过虑器性能比查询要高，且方便缓存，推荐尽量使用过虑器去实现查询或者过虑器和查询共同使用。 　　POST　　http://localhost:9200/xc_course/doc/_search JSON数据： 
{
    "_source" : [  "name", "studymodel", "description","price"],
    "query": {
        "bool":{
    "must":[
            {
            "multi_match" : {
            "query" : "spring框架",
            "minimum_should_match": "50%",
            "fields": [ "name^10", "description" ]
            }
        }
        ],
            "filter": [
            { "term": { "studymodel": "201001" }},
            { "range": { "price": { "gte": 60 ,"lte" : 100}}}
        ]
        }
    }
}
　　range：范围过虑，保留大于等于60 并且小于等于100的记录。 　　term：项匹配过虑，保留studymodel等于"201001"的记录。 　　注意：range和term一次只能对一个Field设置范围过虑。 JavaClient示例： 
 //布尔查询使用过虑器
    @Test
    public void testFilter() throws IOException {
        SearchRequest searchRequest = new SearchRequest("xc_course");
        searchRequest.types("doc");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //source源字段过虑
        searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","description"},
                new String[]{});
        searchRequest.source(searchSourceBuilder);
        //匹配关键字
        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("spring框架", "name", "description");
        //设置匹配占比
                multiMatchQueryBuilder.minimumShouldMatch("50%");
        //提升另个字段的Boost值
        multiMatchQueryBuilder.field("name",10);
        searchSourceBuilder.query(multiMatchQueryBuilder);
        //布尔查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.must(searchSourceBuilder.query());
        //过虑
        boolQueryBuilder.filter(QueryBuilders.termQuery("studymodel", "201001"));
        boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(60).lte(100));
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest);
        SearchHits hits = searchResponse.getHits();
        SearchHit[] searchHits = hits.getHits();
        for (SearchHit hit : searchHits) {
            String index = hit.getIndex();
            String type = hit.getType();
            String id = hit.getId();
            float score = hit.getScore();
            String sourceAsString = hit.getSourceAsString();
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            String studymodel = (String) sourceAsMap.get("studymodel");
            String description = (String) sourceAsMap.get("description");
            System.out.println(name);
            System.out.println(studymodel);
            System.out.println(description);
        }
    }
过滤器

8.排序

可以在字段上添加一个或多个排序，支持在keyword、date、float等类型上添加，text类型的字段上不允许添加排序。  POST　　http://localhost:9200/xc_course/doc/_search

JSON数据：

过虑0--10元价格范围的文档，并且对结果进行排序，先按studymodel降序，再按价格升序 
{
    "_source" : [ "name", "studymodel", "description","price"],
    "query": {
        "bool" : {
            "filter": [
        { "range": { "price": { "gte": 0 ,"lte" : 100}}}
                ]
                                }
                },
        "sort" : [
            {
            "studymodel" : "desc"
            },
            {
            "price" : "asc"
            }            
        ]
}

JavaClient示例：

/**
     * 排序
     * @throws IOException
     */
    @Test
    public void testSort() throws IOException {
        SearchRequest searchRequest = new SearchRequest("xc_course");
        searchRequest.types("doc");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    //source源字段过虑
        searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","description"},
                new String[]{});
        searchRequest.source(searchSourceBuilder);
    //布尔查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
    //过虑
        boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(0).lte(100));
        //排序
        searchSourceBuilder.sort(new FieldSortBuilder("studymodel").order(SortOrder.DESC));   //降序 DESC
        searchSourceBuilder.sort(new FieldSortBuilder("price").order(SortOrder.ASC));         //升序 ESC
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest);
        SearchHits hits = searchResponse.getHits();
        SearchHit[] searchHits = hits.getHits();
        for (SearchHit hit : searchHits) {
            String index = hit.getIndex();
            String type = hit.getType();
            String id = hit.getId();
            float score = hit.getScore();
            String sourceAsString = hit.getSourceAsString();
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            String studymodel = (String) sourceAsMap.get("studymodel");
            String description = (String) sourceAsMap.get("description");
            System.out.println(name);
            System.out.println(studymodel);
            System.out.println(description);
        }
    }
排序

9.高亮

高亮显示可以将搜索结果一个或多个字突出显示，以便向用户展示匹配关键字的位置。 
　　POST　　 http://127.0.0.1:9200/xc_course/doc/_search  JSON数据： 
{
    "_source" : [ "name", "studymodel", "description","price"],
    "query": {
        "bool" : {
            "must":[
            {
                "multi_match" : {
                "query" : "开发框架",
                "minimum_should_match": "50%",
                "fields": [ "name^10", "description" ],
                "type":"best_fields"
                }
                }
        ],
        "filter": [
        { "range": { "price": { "gte": 0 ,"lte" : 100}}}
            ]
            }
            },
        "highlight":{
            "pre_tags": ["<tag>"],
            "post_tags": ["</tag>"],
            "fields": {
            "name": {},
            "description":{}
            }
        }
}

JavaClient示例：

/**
     * 高亮
     * @throws IOException
     */
    @Test
    public void testHighlight() throws IOException {
        SearchRequest searchRequest = new SearchRequest("xc_course");
        searchRequest.types("doc");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//source源字段过虑
        searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","description"},
                new String[]{});
        searchRequest.source(searchSourceBuilder);
//匹配关键字
        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("开发","name", "description");
        searchSourceBuilder.query(multiMatchQueryBuilder);
//布尔查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.must(searchSourceBuilder.query());
//过虑
        boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(0).lte(100));
//排序
        searchSourceBuilder.sort(new FieldSortBuilder("studymodel").order(SortOrder.DESC));
        searchSourceBuilder.sort(new FieldSortBuilder("price").order(SortOrder.ASC));
//高亮设置
        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);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest);
        SearchHits hits = searchResponse.getHits();
        SearchHit[] searchHits = hits.getHits();
        for (SearchHit hit : searchHits) {
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
//名称
            String name = (String) sourceAsMap.get("name");
//取出高亮字段内容
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            if(highlightFields!=null){
                HighlightField nameField = highlightFields.get("name");
                if(nameField!=null){
                    Text[] fragments = nameField.getFragments();
                    StringBuffer stringBuffer = new StringBuffer();
                    for (Text str : fragments) {
                        stringBuffer.append(str.string());
                    }
                    name = stringBuffer.toString();
                }
            }
            String index = hit.getIndex();
            String type = hit.getType();
            String id = hit.getId();
            float score = hit.getScore();
            String sourceAsString = hit.getSourceAsString();
            String studymodel = (String) sourceAsMap.get("studymodel");
            String description = (String) sourceAsMap.get("description");
            System.out.println(name);
            System.out.println(studymodel);
            System.out.println(description);
        }
    }
高亮

 

标签：String,searchSourceBuilder,description,DSL,搜索,new,studymodel,ES,name
From： https://www.cnblogs.com/lksses/p/17716635.html

相关文章

  • 802.1D STP Port States（STP端口状态）
    STP3802.1DSTPPortStates(端口状态)生成树端口分为角色和状态：三种角色：RB根桥RP根端口DP指定端口2.五种状态：Disabled（禁用）端口Down掉或没插线、管理员关闭或默认关闭，这个状态既不能发送也不能接收帧。Blocking（阻塞）只能接受BPDU，不能发送或发送其他任何的......
  • 启动MySQL数据库时报错"Another process with pid 3306 is using unix socket file…
    问题描述：启动MySQL数据库时报错"Anotherprocesswithpid3306isusingunixsocketfile……"，如下所示：数据库：MySQL5.7.211、异常重现2023-09-23T06:09:48.644151Z0[Note]ServersocketcreatedonIP:'::'.2023-09-23T06:09:48.645247Z0[ERROR]Anotherprocessw......
  • AES-256-ECB PKCS7Padding 解密 微信退款接口
    微信退款通知https://pay.weixin.qq.com/wiki/doc/api/wxpay/ch/pay/OfficialPayMent/chapter8_8.shtml需要的pom<!--https://mvnrepository.com/artifact/commons-codec/commons-codec--> <dependency> <groupId>commons-codec</groupId> <......
  • 万界星空科技/免费开源MES系统/免费自动排产管理
    万界星空科技免费MES系统助力企业实现生产排程自动化，降低人力成本。生产计划排产管理是指制定一个可行的生产计划并按照该计划安排生产资源和制造活动的过程。它是制造企业管理中的一个关键过程，涉及到计划制定、资源管理、物料采购、工厂布局、生产调度等多个环节，是企业整体生产管......
  • 解决：idea services窗口不显示端口号
    1.关闭所有java进程2.到此目录下“C:\Users\用户名\AppData\Local\Temp\hsperfdata_用户名”，将“hsperfdata_用户名”文件夹删除。3.IDEA重启一下，在Dashboard中启动项目，则可以在DashBoard中看到相应进程后面的端口号。 ......
  • 10-ES客户端索引相关操作
    新建业务包├─config #配置文件├─controller #控制器├─entity #实体映射│└─response #响应实体└─service #相关业务在response包下，新建两个类，分别是ResultCode(interface),ResponseResult.java：ResultCode.java:/***@authorBNTang......
  • 3-ES核心概念
    es与关系型数据库索引index索引是ES中最大的数据单元，相当于关系型数据库中,库的概念。ES中没有表的概念，这是ES和数据库的一个区别，在我们建立索引之后，可以直接往索引中写入文档。在6.0版本之前，ES中有Type的概念，可以理解成关系型数据库中的表，但是官方说这是......
  • 4-ES环境搭建
    下载镜像废话不多说直接上代码，使用docker下载es与kibana镜像。下载es镜像：dockerpulldocker.elastic.co/elasticsearch/elasticsearch:7.16.2下载kibana镜像：dockerpullkibana:7.16.2启动es容器我这里对数据文件进行了与容器当中进行挂载关于什么是数......
  • 6-ES数据管理
    索引操作创建索引库PUT/索引名称{"settings":{"属性名":"属性值"}}settings：就是索引库设置，其中可以定义索引库的各种属性，比如分片数，副本数等。PUT/bntang_index{"settings":{}}判断索引是否存在HEAD/索引名称查看索引GET/索引名称批量......
  • 7-DSL语言高级查询
    概述关于DSLDSL(DomainSpecificLanguage)领域专用语言Elasticsearch提供了基于JSON的DSL来定义查询组成叶子查询子句：在特定域中寻找特定的值。复合查询子句：复合查询子句包装其他叶子查询或复合查询，并用于以逻辑方式组合多个查询。基本语法POST/索引名称/_se......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99