RestHighLevelClient查询es

时间 2019-11-06

标签 resthighlevelclient 查询繁體版

原文原文链接

本篇分享的是es官网推荐的es客户端组件RestHighLevelClient的使用，其封装了操做es的crud方法，底层原理就是模拟各类es须要的请求，如put，delete，get等方式；本篇主要分享经常使用查询，但愿能给你们带来好的帮助；html

分页查询
条件查询java
1. 文本模糊匹配
2. 时间范围匹配
超时设置sql
1. es超时时间
2. RestHighLevelClient发送请求的http响应超时时间
排序
指定返回列
模拟一个post获取es数据

准备工做

本人es服务端的版本是5.6.x，所以RestHighLevelClient建议一样引入相同主版本的包，相关参考文档(link)：json

 1         <dependency>
 2             <groupId>org.elasticsearch.client</groupId>
 3             <artifactId>elasticsearch-rest-high-level-client</artifactId>
 4             <version>5.6.16</version>
 5         </dependency>
 6 
 7         <dependency>
 8             <groupId>com.alibaba</groupId>
 9             <artifactId>fastjson</artifactId>
10             <version>1.2.56</version>
11             <scope>compile</scope>
12         </dependency>

做为客户端来讲，咱们须要知道es服务的ip:端口，以此来链接到服务端，对于es来讲链接服务端其实就是往这个ip:端口上发送各类格式请求参数，以下建立个restclient：elasticsearch

1     public RestHighLevelClient client() {
2         Assert.requireNonEmpty(this.hosts, "无效的es链接");
3         return new RestHighLevelClient(
4                 RestClient.builder(this.hosts).build()
5         );
6     }

分页查询

做为客户端来讲resthighlevelclient的查询操做及其简单，只须要以下简短代码便可操做查询：分布式

 1             SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
 2             SearchRequest rq = new SearchRequest();
 3             //索引
 4             rq.indices(index);
 5             //各类组合条件
 6             rq.source(sourceBuilder);
 7 
 8             //请求
 9             System.out.println(rq.source().toString());
10             SearchResponse rp = client().search(rq);

如上模板咱们知道要完成一次查询，须要知道对应的索引和各类业务查询条件；索引是必须的，至于条件这里先来分页吧，能够经过以下方式设置页码：ide

1             from = from <= -1 ? 0 : from;
2             size = size >= 1000 ? 1000 : size;
3             size = size <= 0 ? 15 : size;
4             //其实位置
5             sourceBuilder.from(from);
6             //每页数量
7             sourceBuilder.size(size);

条件查询

对于查询来讲一般都有各类and和or的条件，能够经过SearchSourceBuilder的must和should来设置and和or关系，这里用到了must；post

1.文本模糊匹配
对于es关键字或单词的查询咱们能够借助QueryBuilders.wildcardQuery方法来操做，只须要指定es中对应的列和要查询的内容便可：fetch

1             //模糊匹配
2             boolQueryBuilder.must(QueryBuilders.wildcardQuery(k, v.toString()));

2.时间范围匹配
相对时间条件来讲，一般的需求都是按照范围来查询的，这里能够借助QueryBuilders.rangeQuery指定es中某列(k)的范围匹配：ui

1    boolQueryBuilder.must(
2                         QueryBuilders.rangeQuery(k).
3                                 gte(format.format(mapV.get("start"))).
4                                 lt(format.format(mapV.get("end"))));

超时设置

使用RestHighLevelClient做为查询端，须要注意的超时时间有两种：es自己须要的时间和Rest发送http的响应时间

1.es超时时间
对于es服务端来讲每每须要设置一下查询超时时间，尽管es是分布式查询较快并创建在多个lucence基础上聚合的查询，也须要设置超时时间，避免因为数据量过大或集群过大致使查询缓慢问题；

1     sourceBuilder.timeout(new TimeValue(timeOut, TimeUnit.SECONDS));

2.RestHighLevelClient发送请求的http响应超时时间
对应http来讲每每会有一个响应的时长，超过期长后将不能再获取到数据，RestHighLevelClient做为以http方式请求es客户端这点须要注意；好比es查询须要10s，可是http设置了5s，数据就没法正常返回；

1         return new RestHighLevelClient(
2                 RestClient.builder(this.hosts).
3                         setMaxRetryTimeoutMillis(60 * 1000).  //设置http客户请求时长
4                         build()
5         );

排序

排序在业务中也是经常使用，es提供了默认排序和自定义排序，默认排序一般都是_score来排的，以下参数：

若是自定义列来排序，能够经过以下方式：

1       sourceBuilder.sort(new FieldSortBuilder(k).order(v ? SortOrder.ASC : SortOrder.DESC));

指定返回列

对应查询一般会指定一些返回列，就sql查询来讲select *一般都比select cols要慢，一个缘由是数据量少了有可能走了索引；es其实也一样，指定返回列可减小返回数据体量；

1             //返回和排除列
2             if (!CollectionUtils.isEmpty(includeFields) || !CollectionUtils.isEmpty(excludeFields)) {
3                 sourceBuilder.fetchSource(includeFields, excludeFields);
4             }

模拟一个post获取es数据

如上就是查询es经常使用一些参数说明，配置及心得；下面给出完整的示例代码：

 1   /**
 2      * @param index
 3      * @param from
 4      * @param size
 5      * @param where
 6      * @param sortFieldsToAsc
 7      * @param includeFields
 8      * @param excludeFields
 9      * @param timeOut
10      * @return
11      */
12     public List<Map<String, Object>> searchIndex(String index, int from, int size, Map<String, Object> where,
13                                                  Map<String, Boolean> sortFieldsToAsc, String[] includeFields, String[] excludeFields,
14                                                  int timeOut) {
15         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
16         try {
17             SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
18             //条件
19             if (where != null && !where.isEmpty()) {
20                 BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
21                 where.forEach((k, v) -> {
22                     if (v instanceof Map) {
23                         //范围选择map  暂定时间
24                         Map<String, Date> mapV = (Map<String, Date>) v;
25                         if (mapV != null) {
26                             boolQueryBuilder.must(
27                                     QueryBuilders.rangeQuery(k).
28                                             gte(format.format(mapV.get("start"))).
29                                             lt(format.format(mapV.get("end"))));
30                         }
31                     } else {
32                         //普通模糊匹配
33                         boolQueryBuilder.must(QueryBuilders.wildcardQuery(k, v.toString()));
34                     }
35                 });
36                 sourceBuilder.query(boolQueryBuilder);
37             }
38 
39             //分页
40             from = from <= -1 ? 0 : from;
41             size = size >= 1000 ? 1000 : size;
42             size = size <= 0 ? 15 : size;
43             sourceBuilder.from(from);
44             sourceBuilder.size(size);
45 
46             //超时
47             sourceBuilder.timeout(new TimeValue(timeOut, TimeUnit.SECONDS));
48 
49             //排序
50             if (sortFieldsToAsc != null && !sortFieldsToAsc.isEmpty()) {
51                 sortFieldsToAsc.forEach((k, v) -> {
52                     sourceBuilder.sort(new FieldSortBuilder(k).order(v ? SortOrder.ASC : SortOrder.DESC));
53                 });
54             } else {
55                 sourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
56             }
57 
58             //返回和排除列
59             if (!CollectionUtils.isEmpty(includeFields) || !CollectionUtils.isEmpty(excludeFields)) {
60                 sourceBuilder.fetchSource(includeFields, excludeFields);
61             }
62 
63             SearchRequest rq = new SearchRequest();
64             //索引
65             rq.indices(index);
66             //各类组合条件
67             rq.source(sourceBuilder);
68 
69             //请求
70             System.out.println(rq.source().toString());
71             SearchResponse rp = client().search(rq);
72 
73             //解析返回
74             if (rp.status() != RestStatus.OK || rp.getHits().getTotalHits() <= 0) {
75                 return Collections.emptyList();
76             }
77 
78             //获取source
79             return Arrays.stream(rp.getHits().getHits()).map(b -> {
80                 return b.getSourceAsMap();
81             }).collect(Collectors.toList());
82 
83         } catch (Exception ex) {
84             ex.printStackTrace();
85         }
86         return Collections.emptyList();
87     }

分享经过RestClient方式往es发送的请求参数以及模拟post方式发送参数获取es数据：

 1 {
 2   "from" : 0,
 3   "size" : 5,
 4   "timeout" : "60s",
 5   "query" : {
 6     "bool" : {
 7       "must" : [
 8         {
 9           "range" : {
10             "timeStamp" : {
11               "from" : "2019-05-23T19:17:59.000+0800",
12               "to" : "2019-05-23T19:18:00.000+0800",
13               "include_lower" : true,
14               "include_upper" : false,
15               "boost" : 1.0
16             }
17           }
18         },
19         {
20           "wildcard" : {
21             "data" : {
22               "wildcard" : "虎",
23               "boost" : 1.0
24             }
25           }
26         }
27       ],
28       "disable_coord" : false,
29       "adjust_pure_negative" : true,
30       "boost" : 1.0
31     }
32   },
33   "_source" : {
34     "includes" : [ ],
35     "excludes" : [
36       "serverIp"
37     ]
38   },
39   "sort" : [
40     {
41       "timeStamp" : {
42         "order" : "desc"
43       }
44     }
45   ]
46 }

有了上面参数，咱们彻底能够经过postman直接发post给es服务端，让其返回响应的数据而；resthighlevelclient做为http客户端就是帮咱们完成了这部分封装：