RestHighLevelClient封装使用，Java调用ES客户端 [支持ES6.x]_resthighlevelclient 6.x 认证

前言：之前做项目的时候，需要用到Es的操作，本来想使用EsJpa的（即SpringDataElasticsearch），结果项目采用的是SpringBoot1.x版本，不得已，只要自己封装RestHighLevelClient来使用；不过网上查找到的基本都是copy的东西，只好自己写几个

以下为百科：
Java高级别REST客户端（The Java High Level REST Client）以后简称高级客户端，内部仍然是基于低级客户端。它提供了更多的API，接受请求对象作为参数并返回响应对象，由客户端自己处理编码和解码。

每个API都可以同步或异步调用。 同步方法返回一个响应对象，而异步方法的名称以async后缀结尾，需要一个监听器参数，一旦收到响应或错误，就会被通知（由低级客户端管理的线程池）。

高级客户端依赖于Elasticsearch core项目。 它接受与TransportClient相同的请求参数并返回相同的响应对象。

下面是代码：

Pom依赖：使用的是6.4.3版本

<dependency>
      <groupId>org.elasticsearch.client</groupId>
      <artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>6.4.3</version>
</dependency>
1
2
3
4
5

Java 工具类(最简单的获取客户端方式，其他花哨的东西就不写了)

/**
获取客户端
**/
 public static RestHighLevelClient getClient() {
    return new RestHighLevelClient(
        RestClient.builder(new HttpHost("localhost", 9200, "http")));
  }
1
2
3
4
5
6
7

下面的client都为上面的getClient()

    /**
     * 根据QueryBuilder来查询全部的条数
     *
     * @param indexName 索引
     * @param typeName  类型
     * @param id   id
     * @return 条数
     * @throws IOException 异常
     */
    public SearchResponse idQuery(String[] indexName, String typeName, String id) throws IOException {
        SearchRequest searchRequest = new SearchRequest(filterIndexName(indexName));
        searchRequest.types(typeName);
        searchRequest.source().query(QueryBuilders.idsQuery().addIds(id));
        return client.search(searchRequest);
    }

    /**
     * 根据QueryBuilder来查询全部的条数
     *
     * @param indexNameArray 索引
     * @param typeName  类型
     * @param builder   查询构建器
     * @return 条数
     * @throws IOException 异常
     */
    public Long getTotalRecords(String[] indexNameArray, String typeName, QueryBuilder builder) throws IOException {
        String[] indexArr = filterIndexName(indexNameArray);
        if(indexArr.length == 0)
            return 0L;
        SearchRequest searchRequest = new SearchRequest(indexArr);
        searchRequest.types(typeName);
        searchRequest.source().query(builder);
        SearchResponse response = client.search(searchRequest);
        return response.getHits().getTotalHits();
    }

    /**
     * 查询全部
     *
     * @param indexName 索引
     * @param typeName  类型
     * @param builder   查询构建器
     * @return SearchResponse
     * @throws IOException 异常
     */
    public SearchResponse findAll(String indexName, String typeName, QueryBuilder builder) throws IOException {
        SearchRequest request = new SearchRequest(indexName);
        request.types(typeName);
        request.source().query(builder);
        return client.search(request);
    }


    /**
     * 分页
     *
     * @param indexNameArray    索引
     * @param typeName     类型
     * @param queryBuilder 参数
     * @param from         从第几条
     * @param size         页面条数
     * @param sortBuilder  排序
     * @return response
     * @throws IOException 异常
     */
    public SearchResponse page(String[] indexNameArray, String typeName, QueryBuilder queryBuilder, int from, int size, SortBuilder sortBuilder)
            throws IOException {
        String[] indexArr = filterIndexName(indexNameArray);
        if(indexArr.length == 0){
            logger.error("选择的时间区间中没有数据");
            return null;
        }
        SearchRequest request = new SearchRequest(indexArr).types(typeName);
        //构建搜寻器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //参数
        sourceBuilder.query(queryBuilder);
        //排序
        sourceBuilder.sort(sortBuilder);
        //分页
        sourceBuilder.from(from);
        sourceBuilder.size(size);

        request.source(sourceBuilder);
        return client.search(request);
    }


    /**
     * 批量插入数据
     *
     * @param indexName 索引
     * @param typeName  类型
     * @param valueMap  map
     * @return BulkResponse
     * @throws IOException 异常
     */
    public BulkResponse insert(String indexName, String typeName, Map<String, String> valueMap) throws IOException {
        BulkRequest bulkRequest = new BulkRequest();
        Set<String> keySet = valueMap.keySet();
        for (String id : keySet) {
            IndexRequest request = new IndexRequest(indexName);
            request.type(typeName);
            request.index(indexName).id(id).source(valueMap.get(id), XContentType.JSON);
            bulkRequest.add(request);
        }
        return client.bulk(bulkRequest);
    }

    /**
     * 更新- 根据id进行更新(插入时根据id进行覆盖)
     */
    public void update(String indexName, String typeName,String id,String jsonStr)throws IOException{
        insert(indexName,typeName,id,jsonStr);
    }

    /**
     * 批量更新
     */
    public void update(String indexName, String typeName, Map<String, String> valueMap)throws IOException{
        insert(indexName,typeName,valueMap);
    }

    /**
     * 根据id进行删除
     *
     * @param indexName 索引
     * @param typeName  类型
     * @param id        id
     * @throws IOException 异常
     */
    public void delete(String indexName, String typeName, String id) throws IOException {
        DeleteRequest deleteRequest = new DeleteRequest(indexName, typeName, id);
        client.delete(deleteRequest);
    }

    public SearchResponse selectAll(String[] indexName, String typeName) throws IOException {
        SearchRequest searchRequest = new SearchRequest(filterIndexName(indexName));
        searchRequest.types(typeName);
        searchRequest.source().query(QueryBuilders.boolQuery());
        return client.search(searchRequest);
    }

    /**
     * Es文档数据插入(插入前会自动生成index)
     *
     * @param indexName 索引名称
     * @param typeName  类型名称
     * @param id        id
     * @param jsonStr   json数据
     * @return IndexResponse
     * @throws IOException 异常
     */
    public IndexResponse insert(String indexName, String typeName, String id, String jsonStr) throws IOException {
        IndexRequest indexRequest = new IndexRequest(indexName, typeName, id);
        indexRequest.source(jsonStr, XContentType.JSON);
        return client.index(indexRequest);
    }

    /**
     * 过滤不存在的indexName
     *
     * @param indexNameArray 索引数组
     * @return 索引数组
     * @throws IOException 异常
     */
    private String[] filterIndexName(String[] indexNameArray) throws IOException {
        List<String> resultList = new ArrayList<>();
        for (String indexName : indexNameArray) {
            GetIndexRequest request = new GetIndexRequest().indices(indexName);
            boolean exists = client.indices().exists(request);
            if (exists) resultList.add(indexName);
        }
        int size = resultList.size();
        return resultList.toArray(new String[size]);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

接下来就是对取到的Es返回值做解析，这个应该很简单了

//这边涉及到业务代码，就不放全了了，简单放几个解析的方法
SearchResponse response = getClient().page(...);
      if (null != response) {
      	//取到hits
        SearchHit[] hits = response.getHits().getHits();
        if (null != hits) {
          for (SearchHit hit : hits) {
            //这就是取到的数据的Json格式数据
            String source = hit.getSourceAsString();
            //使用Gson转换成Bean放进结果list中
            T obj = GsonUtils.read(source, clazz);
            resultList.add(obj);
          }
        }
      }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

下面是我们取到的返回值的真实数据

所以:
SearchHit[] hits = response.getHits().getHits(); 就是获取所取到列表的全部数据
String source = hit.getSourceAsString();然后每一个hit的sourse字符串当然就是取到对象的Json字符串了
1
2
3

以上